Merge branch 'main' into fix/go-allowed-headers-mcp

Author: EItanya

.github/dependabot.yml

@@ -48,18 +48,15 @@ updates:
           - "minor"
           - "patch"
 
-  # Python (uv) — workspace root and all packages
+  # Python (uv) — single workspace root.
+  # Dependabot's native `uv` ecosystem detects workspace members through
+  # python/pyproject.toml's [tool.uv.workspace] section and updates the
+  # root python/uv.lock alongside any member's pyproject.toml in the
+  # same PR. Listing each member as its own directory caused Dependabot
+  # to open per-member PRs that did not refresh the root lockfile,
+  # which then failed `uv sync --locked` in CI.
   - package-ecosystem: "uv"
-    directories:
-      - "/python"
-      - "/python/packages/kagent-adk"
-      - "/python/packages/kagent-core"
-      - "/python/packages/kagent-skills"
-      - "/python/packages/kagent-crewai"
-      - "/python/packages/kagent-langgraph"
-      - "/python/packages/kagent-openai"
-      - "/python/packages/agentsts-core"
-      - "/python/packages/agentsts-adk"
+    directory: "/python"
     schedule:
       interval: "weekly"
       day: "monday"
@@ -73,7 +70,24 @@ updates:
       - "peterj"
       - "yuval-k"
     groups:
+      python-opentelemetry:
+        applies-to: version-updates
+        patterns:
+          - "opentelemetry-*"
+        update-types:
+          - "minor"
+          - "patch"
+      python-google-ai:
+        applies-to: version-updates
+        patterns:
+          - "google-adk"
+          - "google-genai"
+          - "google-auth"
+        update-types:
+          - "minor"
+          - "patch"
       python-minor-patch:
+        applies-to: version-updates
         patterns:
           - "*"
         update-types:
@@ -93,6 +107,13 @@ updates:
       prefix: "chore(deps):"
     reviewers:
       - "peterj"
+    ignore:
+      # Suppress major UI dependency bumps (e.g., Next.js, React) until
+      # the frontend is ready for those migrations. Minor/patch updates
+      # still flow through via the npm-minor-patch group below.
+      - dependency-name: "*"
+        update-types:
+          - "version-update:semver-major"
     groups:
       npm-minor-patch:
         patterns:

go/adk/pkg/telemetry/tracing.go

@@ -2,14 +2,17 @@ package telemetry
 
 import (
 	"context"
+	"fmt"
 	"net/url"
 	"os"
 	"strings"
 	"time"
 
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
+	"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
 	"go.opentelemetry.io/otel/propagation"
 	sdklog "go.opentelemetry.io/otel/sdk/log"
 	"go.opentelemetry.io/otel/sdk/resource"
@@ -54,14 +57,14 @@ func Init(ctx context.Context, serviceName string, serviceNamespace string) (shu
 	loggingEnabled := strings.EqualFold(strings.TrimSpace(os.Getenv("OTEL_LOGGING_ENABLED")), "true")
 	otelOpts := []adktelemetry.Option{adktelemetry.WithResource(telemetryResource)}
 	if tracingEnabled {
-		tracerProvider, tpErr := newGRPCTracerProvider(ctx, telemetryResource)
+		tracerProvider, tpErr := newTracerProvider(ctx, telemetryResource)
 		if tpErr != nil {
 			return nil, true, tpErr
 		}
 		otelOpts = append(otelOpts, adktelemetry.WithTracerProvider(tracerProvider))
 	}
 	if loggingEnabled {
-		loggerProvider, lpErr := newGRPCLoggerProvider(ctx, telemetryResource)
+		loggerProvider, lpErr := newLoggerProvider(ctx, telemetryResource)
 		if lpErr != nil {
 			return nil, true, lpErr
 		}
@@ -87,35 +90,66 @@ func isTelemetryEnabled() bool {
 		strings.EqualFold(strings.TrimSpace(os.Getenv("OTEL_LOGGING_ENABLED")), "true")
 }
 
-func newGRPCTracerProvider(ctx context.Context, res *resource.Resource) (*sdktrace.TracerProvider, error) {
-	traceEndpoint := strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"))
-	if traceEndpoint == "" {
-		traceEndpoint = strings.TrimSpace(os.Getenv("OTEL_TRACING_EXPORTER_OTLP_ENDPOINT"))
+// resolveOTLPProtocol returns the OTLP protocol for the given signal,
+// following OTel spec precedence: signal-specific > general > default (grpc).
+func resolveOTLPProtocol(signal string) string {
+	if v := strings.TrimSpace(os.Getenv(fmt.Sprintf("OTEL_EXPORTER_OTLP_%s_PROTOCOL", signal))); v != "" {
+		return strings.ToLower(v)
 	}
-	if traceEndpoint == "" {
-		traceEndpoint = strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT"))
+	if v := strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_PROTOCOL")); v != "" {
+		return strings.ToLower(v)
 	}
+	return "grpc"
+}
+
+func resolveEndpoint(signalEnvSuffix string) string {
+	endpoint := strings.TrimSpace(os.Getenv(fmt.Sprintf("OTEL_EXPORTER_OTLP_%s_ENDPOINT", signalEnvSuffix)))
+	if endpoint == "" {
+		endpoint = strings.TrimSpace(os.Getenv(fmt.Sprintf("OTEL_%s_EXPORTER_OTLP_ENDPOINT", signalEnvSuffix)))
+	}
+	if endpoint == "" {
+		endpoint = strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT"))
+	}
+	return endpoint
+}
 
-	opts := []otlptracegrpc.Option{
-		// Retry on transient failures
-		otlptracegrpc.WithRetry(otlptracegrpc.RetryConfig{
+func newTracerProvider(ctx context.Context, res *resource.Resource) (*sdktrace.TracerProvider, error) {
+	protocol := resolveOTLPProtocol("TRACES")
+	traceEndpoint := resolveEndpoint("TRACES")
+
+	var exporter sdktrace.SpanExporter
+	var err error
+
+	switch protocol {
+	case "http/protobuf":
+		var opts []otlptracehttp.Option
+		if traceEndpoint != "" {
+			opts = append(opts, otlptracehttp.WithEndpointURL(traceEndpoint))
+		}
+		opts = append(opts, otlptracehttp.WithRetry(otlptracehttp.RetryConfig{
 			Enabled:         true,
 			InitialInterval: 1 * time.Second,
 			MaxInterval:     5 * time.Second,
 			MaxElapsedTime:  30 * time.Second,
-		}),
-	}
-	if traceEndpoint != "" {
-		// If the endpoint has a valid scheme, host, port, path ("scheme://host:port/path"), set endpoint url.
-		if u, err := url.Parse(traceEndpoint); err == nil && u.Scheme != "" && u.Host != "" {
-			opts = append(opts, otlptracegrpc.WithEndpointURL(u.String()))
-		} else {
-			// Else, treat it as a regular endpoint ("example.com:4317", no scheme or path)
-			opts = append(opts, otlptracegrpc.WithEndpoint(traceEndpoint))
+		}))
+		exporter, err = otlptracehttp.New(ctx, opts...)
+	default:
+		var opts []otlptracegrpc.Option
+		opts = append(opts, otlptracegrpc.WithRetry(otlptracegrpc.RetryConfig{
+			Enabled:         true,
+			InitialInterval: 1 * time.Second,
+			MaxInterval:     5 * time.Second,
+			MaxElapsedTime:  30 * time.Second,
+		}))
+		if traceEndpoint != "" {
+			if u, parseErr := url.Parse(traceEndpoint); parseErr == nil && u.Scheme != "" && u.Host != "" {
+				opts = append(opts, otlptracegrpc.WithEndpointURL(u.String()))
+			} else {
+				opts = append(opts, otlptracegrpc.WithEndpoint(traceEndpoint))
+			}
 		}
+		exporter, err = otlptracegrpc.New(ctx, opts...)
 	}
-
-	exporter, err := otlptracegrpc.New(ctx, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -127,25 +161,31 @@ func newGRPCTracerProvider(ctx context.Context, res *resource.Resource) (*sdktra
 	), nil
 }
 
-func newGRPCLoggerProvider(ctx context.Context, res *resource.Resource) (*sdklog.LoggerProvider, error) {
-	logEndpoint := strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT"))
-	if logEndpoint == "" {
-		logEndpoint = strings.TrimSpace(os.Getenv("OTEL_LOGGING_EXPORTER_OTLP_ENDPOINT"))
-	}
-	if logEndpoint == "" {
-		logEndpoint = strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT"))
-	}
+func newLoggerProvider(ctx context.Context, res *resource.Resource) (*sdklog.LoggerProvider, error) {
+	protocol := resolveOTLPProtocol("LOGS")
+	logEndpoint := resolveEndpoint("LOGS")
+
+	var exporter sdklog.Exporter
+	var err error
 
-	var opts []otlploggrpc.Option
-	if logEndpoint != "" {
-		if u, err := url.Parse(logEndpoint); err == nil && u.Scheme != "" && u.Host != "" {
-			opts = append(opts, otlploggrpc.WithEndpointURL(u.String()))
-		} else {
-			opts = append(opts, otlploggrpc.WithEndpoint(logEndpoint))
+	switch protocol {
+	case "http/protobuf":
+		var opts []otlploghttp.Option
+		if logEndpoint != "" {
+			opts = append(opts, otlploghttp.WithEndpointURL(logEndpoint))
 		}
+		exporter, err = otlploghttp.New(ctx, opts...)
+	default:
+		var opts []otlploggrpc.Option
+		if logEndpoint != "" {
+			if u, parseErr := url.Parse(logEndpoint); parseErr == nil && u.Scheme != "" && u.Host != "" {
+				opts = append(opts, otlploggrpc.WithEndpointURL(u.String()))
+			} else {
+				opts = append(opts, otlploggrpc.WithEndpoint(logEndpoint))
+			}
+		}
+		exporter, err = otlploggrpc.New(ctx, opts...)
 	}
-
-	exporter, err := otlploggrpc.New(ctx, opts...)
 	if err != nil {
 		return nil, err
 	}

go/core/cli/internal/cli/agent/const.go

@@ -28,6 +28,14 @@ func GetModelProvider() v1alpha2.ModelProvider {
 		return v1alpha2.ModelProviderAnthropic
 	case GetModelProviderHelmValuesKey(v1alpha2.ModelProviderAzureOpenAI):
 		return v1alpha2.ModelProviderAzureOpenAI
+	case GetModelProviderHelmValuesKey(v1alpha2.ModelProviderGemini):
+		return v1alpha2.ModelProviderGemini
+	case GetModelProviderHelmValuesKey(v1alpha2.ModelProviderGeminiVertexAI):
+		return v1alpha2.ModelProviderGeminiVertexAI
+	case GetModelProviderHelmValuesKey(v1alpha2.ModelProviderAnthropicVertexAI):
+		return v1alpha2.ModelProviderAnthropicVertexAI
+	case GetModelProviderHelmValuesKey(v1alpha2.ModelProviderBedrock):
+		return v1alpha2.ModelProviderBedrock
 	default:
 		return v1alpha2.ModelProviderOpenAI
 	}
@@ -42,7 +50,9 @@ func GetModelProviderHelmValuesKey(provider v1alpha2.ModelProvider) string {
 	return helmKey
 }
 
-// GetProviderAPIKey returns API_KEY env var name from provider type
+// GetProviderAPIKey returns the env var name for the provider's API key.
+// Returns "" for providers that use cloud credentials instead of an API key
+// (Ollama, Bedrock, GeminiVertexAI, AnthropicVertexAI).
 func GetProviderAPIKey(provider v1alpha2.ModelProvider) string {
 	switch provider {
 	case v1alpha2.ModelProviderOpenAI:
@@ -51,7 +61,16 @@ func GetProviderAPIKey(provider v1alpha2.ModelProvider) string {
 		return env.AnthropicAPIKey.Name()
 	case v1alpha2.ModelProviderAzureOpenAI:
 		return env.AzureOpenAIAPIKey.Name()
+	case v1alpha2.ModelProviderGemini:
+		// Prefer GOOGLE_API_KEY, fall back to GEMINI_API_KEY to match the
+		// runtime behaviour in go/adk/pkg/agent/agent.go.
+		if _, ok := os.LookupEnv(env.GoogleAPIKey.Name()); ok {
+			return env.GoogleAPIKey.Name()
+		}
+		return "GEMINI_API_KEY"
 	default:
+		// Ollama, Bedrock, GeminiVertexAI, AnthropicVertexAI use cloud
+		// credentials rather than a simple API key, so no check is needed.
 		return ""
 	}
 }

go/core/cli/internal/cli/agent/install.go

@@ -86,6 +86,7 @@ func InstallCmd(ctx context.Context, cfg *InstallCfg) *PortForward {
 	if apiKeyName != "" && apiKeyValue == "" {
 		fmt.Fprintf(os.Stderr, "%s is not set\n", apiKeyName)
 		fmt.Fprintf(os.Stderr, "Please set the %s environment variable\n", apiKeyName)
+		fmt.Fprintf(os.Stderr, "To use a different provider set KAGENT_DEFAULT_MODEL_PROVIDER (e.g. ollama, anthropic, gemini)\n")
 		return nil
 	}
 
@@ -127,6 +128,7 @@ func InteractiveInstallCmd(ctx context.Context, c *ishell.Context) *PortForward
 	if apiKeyName != "" && apiKeyValue == "" {
 		fmt.Fprintf(os.Stderr, "%s is not set\n", apiKeyName)
 		fmt.Fprintf(os.Stderr, "Please set the %s environment variable\n", apiKeyName)
+		fmt.Fprintf(os.Stderr, "To use a different provider set KAGENT_DEFAULT_MODEL_PROVIDER (e.g. ollama, anthropic, gemini)\n")
 		return nil
 	}
 

go/core/internal/httpserver/handlers/memory.go

@@ -3,10 +3,11 @@ package handlers
 import (
 	"encoding/json"
 	"fmt"
-	"log"
 	"net/http"
 	"time"
 
+	ctrllog "sigs.k8s.io/controller-runtime/pkg/log"
+
 	"github.com/kagent-dev/kagent/go/api/database"
 	"github.com/pgvector/pgvector-go"
 )
@@ -69,6 +70,7 @@ type ListMemoryResponse struct {
 
 // AddSession handles POST /api/memories/sessions
 func (h *MemoryHandler) AddSession(w ErrorResponseWriter, r *http.Request) {
+	log := ctrllog.FromContext(r.Context())
 	var req AddSessionMemoryRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		RespondWithError(w, http.StatusBadRequest, "Invalid request body")
@@ -106,12 +108,12 @@ func (h *MemoryHandler) AddSession(w ErrorResponseWriter, r *http.Request) {
 	}
 
 	if err := h.DatabaseService.StoreAgentMemory(r.Context(), memory); err != nil {
-		log.Printf("Failed to store agent memory: %v", err)
+		log.Error(err, "failed to store agent memory")
 		RespondWithError(w, http.StatusInternalServerError, fmt.Sprintf("failed to save memory: %v", err))
 		return
 	}
 
-	log.Printf("Successfully added memory ID %s for user %s agent %s", memory.ID, req.UserID, req.AgentName)
+	log.Info("added memory", "id", memory.ID, "userID", req.UserID, "agentName", req.AgentName)
 
 	RespondWithJSON(w, http.StatusCreated, map[string]string{"id": memory.ID})
 }
@@ -123,6 +125,7 @@ type AddSessionMemoryBatchRequest struct {
 
 // AddSessionBatch handles POST /api/memories/sessions/batch
 func (h *MemoryHandler) AddSessionBatch(w ErrorResponseWriter, r *http.Request) {
+	log := ctrllog.FromContext(r.Context())
 	var req AddSessionMemoryBatchRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		RespondWithError(w, http.StatusBadRequest, "Invalid request body")
@@ -174,12 +177,12 @@ func (h *MemoryHandler) AddSessionBatch(w ErrorResponseWriter, r *http.Request)
 	}
 
 	if err := h.DatabaseService.StoreAgentMemories(r.Context(), memories); err != nil {
-		log.Printf("Failed to store agent memory batch: %v", err)
+		log.Error(err, "failed to store agent memory batch")
 		RespondWithError(w, http.StatusInternalServerError, fmt.Sprintf("failed to save memory batch: %v", err))
 		return
 	}
 
-	log.Printf("Successfully added %d memory items", len(memories))
+	log.Info("added memory batch", "count", len(memories))
 	RespondWithJSON(w, http.StatusCreated, map[string]int{"count": len(memories)})
 }
 
@@ -242,6 +245,7 @@ func (h *MemoryHandler) Search(w ErrorResponseWriter, r *http.Request) {
 
 // List handles GET /api/memories and returns all memories for an agent+user, ranked by access frequency
 func (h *MemoryHandler) List(w ErrorResponseWriter, r *http.Request) {
+	log := ctrllog.FromContext(r.Context())
 	agentName := r.URL.Query().Get("agent_name")
 	userID := r.URL.Query().Get("user_id")
 
@@ -252,7 +256,7 @@ func (h *MemoryHandler) List(w ErrorResponseWriter, r *http.Request) {
 
 	memories, err := h.DatabaseService.ListAgentMemories(r.Context(), agentName, userID)
 	if err != nil {
-		log.Printf("Failed to list agent memories: %v", err)
+		log.Error(err, "failed to list agent memories")
 		RespondWithError(w, http.StatusInternalServerError, fmt.Sprintf("failed to list memories: %v", err))
 		return
 	}
@@ -276,6 +280,7 @@ func (h *MemoryHandler) List(w ErrorResponseWriter, r *http.Request) {
 
 // Delete handles DELETE /api/memories
 func (h *MemoryHandler) Delete(w ErrorResponseWriter, r *http.Request) {
+	log := ctrllog.FromContext(r.Context())
 	agentName := r.URL.Query().Get("agent_name")
 	userID := r.URL.Query().Get("user_id")
 
@@ -285,7 +290,7 @@ func (h *MemoryHandler) Delete(w ErrorResponseWriter, r *http.Request) {
 	}
 
 	if err := h.DatabaseService.DeleteAgentMemory(r.Context(), agentName, userID); err != nil {
-		log.Printf("Failed to delete agent memory: %v", err)
+		log.Error(err, "failed to delete agent memory")
 		RespondWithError(w, http.StatusInternalServerError, fmt.Sprintf("failed to delete memory: %v", err))
 		return
 	}