Merge pull request #1895 from dgageot/fixes_daily

Daily fixes of the bot-detected issues

Author: dgageot

cmd/root/debug_auth.go

@@ -102,7 +102,12 @@ func parseAuthInfo(token string) (*authInfo, error) {
 }
 
 func printAuthInfoText(w io.Writer, info *authInfo) {
-	fmt.Fprintf(w, "Token:      %s...%s\n", info.Token[:10], info.Token[len(info.Token)-10:])
+	const previewLen = 10
+	if len(info.Token) <= previewLen*2 {
+		fmt.Fprintf(w, "Token:      %s\n", info.Token)
+	} else {
+		fmt.Fprintf(w, "Token:      %s...%s\n", info.Token[:previewLen], info.Token[len(info.Token)-previewLen:])
+	}
 
 	if info.Username != "" {
 		fmt.Fprintf(w, "Username:   %s\n", info.Username)

cmd/root/otel.go

@@ -3,7 +3,9 @@ package root
 import (
 	"context"
 	"fmt"
+	"net"
 	"os"
+	"strings"
 	"time"
 
 	"go.opentelemetry.io/otel"
@@ -34,10 +36,13 @@ func initOTelSDK(ctx context.Context) (err error) {
 
 	// Only initialize if endpoint is configured
 	if endpoint != "" {
-		traceExporter, err = otlptracehttp.New(ctx,
+		opts := []otlptracehttp.Option{
 			otlptracehttp.WithEndpoint(endpoint),
-			otlptracehttp.WithInsecure(), // TODO: make configurable
-		)
+		}
+		if isLocalhostEndpoint(endpoint) {
+			opts = append(opts, otlptracehttp.WithInsecure())
+		}
+		traceExporter, err = otlptracehttp.New(ctx, opts...)
 		if err != nil {
 			return fmt.Errorf("failed to create trace exporter: %w", err)
 		}
@@ -67,3 +72,17 @@ func initOTelSDK(ctx context.Context) (err error) {
 
 	return nil
 }
+
+// isLocalhostEndpoint reports whether the given endpoint refers to a
+// loopback address so that we can safely skip TLS.
+func isLocalhostEndpoint(endpoint string) bool {
+	host := endpoint
+	// Strip port if present.
+	if h, _, err := net.SplitHostPort(endpoint); err == nil {
+		host = h
+	}
+	// Strip brackets from IPv6 addresses (e.g. "[::1]" without a port).
+	host = strings.TrimPrefix(host, "[")
+	host = strings.TrimSuffix(host, "]")
+	return host == "localhost" || host == "127.0.0.1" || host == "::1"
+}

cmd/root/otel_test.go

@@ -0,0 +1,36 @@
+package root
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsLocalhostEndpoint(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		endpoint string
+		want     bool
+	}{
+		{"localhost no port", "localhost", true},
+		{"localhost with port", "localhost:4318", true},
+		{"ipv4 loopback no port", "127.0.0.1", true},
+		{"ipv4 loopback with port", "127.0.0.1:4318", true},
+		{"ipv6 loopback no port", "::1", true},
+		{"ipv6 loopback bracketed", "[::1]", true},
+		{"ipv6 loopback with port", "[::1]:4318", true},
+		{"remote host", "example.com", false},
+		{"remote host with port", "example.com:4318", false},
+		{"remote ip", "192.168.1.1", false},
+		{"remote ip with port", "192.168.1.1:4318", false},
+		{"empty string", "", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			assert.Equal(t, tt.want, isLocalhostEndpoint(tt.endpoint))
+		})
+	}
+}

pkg/connectrpc/server.go

@@ -361,12 +361,22 @@ func toolCallToProto(tc tools.ToolCall) *cagentv1.ToolCall {
 func toolToProto(t tools.Tool) *cagentv1.Tool {
 	var paramsJSON []byte
 	if t.Parameters != nil {
-		paramsJSON, _ = json.Marshal(t.Parameters)
+		var err error
+		paramsJSON, err = json.Marshal(t.Parameters)
+		if err != nil {
+			slog.Warn("Failed to marshal tool parameters", "tool", t.Name, "error", err)
+			paramsJSON = nil
+		}
 	}
 
 	var outputSchemaJSON []byte
 	if t.OutputSchema != nil {
-		outputSchemaJSON, _ = json.Marshal(t.OutputSchema)
+		var err error
+		outputSchemaJSON, err = json.Marshal(t.OutputSchema)
+		if err != nil {
+			slog.Warn("Failed to marshal tool output schema", "tool", t.Name, "error", err)
+			outputSchemaJSON = nil
+		}
 	}
 
 	annotations := &cagentv1.ToolAnnotations{

pkg/runtime/runtime.go

@@ -936,6 +936,10 @@ func (r *LocalRuntime) registerDefaultTools() {
 }
 
 func (r *LocalRuntime) finalizeEventChannel(ctx context.Context, sess *session.Session, events chan Event) {
+	// Clear the elicitation events channel before closing the events channel
+	// to prevent a send-on-closed-channel panic in elicitationHandler.
+	r.clearElicitationEventsChannel()
+
 	defer close(events)
 
 	events <- StreamStopped(sess.ID, r.currentAgent)
@@ -961,7 +965,6 @@ func (r *LocalRuntime) RunStream(ctx context.Context, sess *session.Session) <-c
 
 		// Set the events channel for elicitation requests
 		r.setElicitationEventsChannel(events)
-		defer r.clearElicitationEventsChannel()
 
 		// Set elicitation handler on all MCP toolsets before getting tools
 		a := r.CurrentAgent()
@@ -2095,12 +2098,12 @@ func (r *LocalRuntime) clearElicitationEventsChannel() {
 func (r *LocalRuntime) elicitationHandler(ctx context.Context, req *mcp.ElicitParams) (tools.ElicitationResult, error) {
 	slog.Debug("Elicitation request received from MCP server", "message", req.Message)
 
-	// Get the current events channel
+	// Hold the read lock while sending to the channel to prevent a race
+	// with clearElicitationEventsChannel / close(events).
 	r.elicitationEventsChannelMux.RLock()
 	eventsChannel := r.elicitationEventsChannel
-	r.elicitationEventsChannelMux.RUnlock()
-
 	if eventsChannel == nil {
+		r.elicitationEventsChannelMux.RUnlock()
 		return tools.ElicitationResult{}, fmt.Errorf("no events channel available for elicitation")
 	}
 
@@ -2111,6 +2114,7 @@ func (r *LocalRuntime) elicitationHandler(ctx context.Context, req *mcp.ElicitPa
 
 	// Send elicitation request event to the runtime's client
 	eventsChannel <- ElicitationRequest(req.Message, req.Mode, req.RequestedSchema, req.URL, req.ElicitationID, req.Meta, r.currentAgent)
+	r.elicitationEventsChannelMux.RUnlock()
 
 	// Wait for response from the client
 	select {

pkg/server/session_manager.go

@@ -402,6 +402,11 @@ func (sm *SessionManager) GetAgentToolCount(ctx context.Context, agentFilename,
 	if err != nil {
 		return 0, err
 	}
+	defer func() {
+		if stopErr := t.StopToolSets(ctx); stopErr != nil {
+			slog.Error("Failed to stop tool sets", "error", stopErr)
+		}
+	}()
 
 	a, err := t.Agent(agentName)
 	if err != nil {

pkg/tools/builtin/lsp.go

@@ -1456,16 +1456,18 @@ func (h *lspHandler) readMessageLocked() ([]byte, error) {
 }
 
 func (h *lspHandler) readNotifications(ctx context.Context, stderrBuf *bytes.Buffer) {
+	ticker := time.NewTicker(100 * time.Millisecond)
+	defer ticker.Stop()
+
 	for {
 		select {
 		case <-ctx.Done():
 			return
-		default:
-		}
-
-		if stderrBuf.Len() > 0 {
-			slog.Debug("LSP stderr", "content", stderrBuf.String())
-			stderrBuf.Reset()
+		case <-ticker.C:
+			if stderrBuf.Len() > 0 {
+				slog.Debug("LSP stderr", "content", stderrBuf.String())
+				stderrBuf.Reset()
+			}
 		}
 	}
 }