merge latest upstream main into i18n branch

# Conflicts:
#	ui/app/workspace/mcp-registry/views/mcpClientSheet.tsx
#	ui/app/workspace/providers/dialogs/addNewCustomProviderSheet.tsx

Author: m7rick

.github/workflows/scripts/run-migration-tests.sh

@@ -3509,8 +3509,10 @@ compare_postgres_snapshots() {
     # calendar_aligned was dropped from governance_budgets in prerelease2 (add_multi_budget_tables) but
     # re-added in prerelease4 (migrateCalendarAlignedToBudgetsAndRateLimitsTable) - no longer dropped
     # enable_litellm_fallbacks (dropped from config_client in latest cut - behavior moved elsewhere)
+    # allow_direct_keys (dropped from config_client in v1.5.0 - direct-keys-only mode removed; HTTP header
+    # pass-through is no longer accepted)
     if [ "$table" = "config_client" ]; then
-      dropped_columns="$dropped_columns enable_litellm_fallbacks"
+      dropped_columns="$dropped_columns enable_litellm_fallbacks allow_direct_keys"
     fi
 
     local before_col_array

.github/workflows/scripts/schemasync/main.go

@@ -90,6 +90,10 @@ var ignoreGoFields = map[string]string{
 	// provider_key_id is the internal DB column resolved from provider_key_name at config load time;
 	// schema documents only the human-readable provider_key_name alias.
 	"/properties/governance/properties/pricing_overrides/items|provider_key_id": "internal DB column; config uses provider_key_name alias instead",
+	// oauth_client_id / oauth_client_secret are response-only fields on MCPClientConfig:
+	// populated on GET from the oauth_configs table, never accepted as config.json input.
+	"/properties/mcp/properties/client_configs/items|oauth_client_id":     "response-only; populated on GET from oauth_configs, not user-configurable via config.json",
+	"/properties/mcp/properties/client_configs/items|oauth_client_secret": "response-only; populated on GET from oauth_configs, not user-configurable via config.json",
 }
 
 // ignoreGoFieldNames are field names (regardless of parent path) that are

.github/workflows/scripts/test-bifrost-http.sh

@@ -91,7 +91,6 @@ CONFIGS_TO_TEST=(
   "withdynamicplugin"
   "withobservability"
   "withsemanticcache"
-  "withpostgresmcpclientsinconfig"
 )
 
 TEST_BINARY="../tmp/bifrost-http"

.github/workflows/scripts/validate-helm-config-fields.sh

@@ -39,12 +39,10 @@ report_result() {
 # Usage: render_config <values-file>
 render_config() {
   local values_file=$1
-  helm template bifrost "$CHART_DIR" \
-    --set image.tag=v1.0.0 \
-    -f "$values_file" \
-    > "$TMPDIR/rendered.yaml" 2>"$TMPDIR/render-err.txt"
-  local rc=$?
-  if [ "$rc" -ne 0 ]; then
+  if ! helm template bifrost "$CHART_DIR" \
+       --set image.tag=v1.0.0 \
+       -f "$values_file" \
+       > "$TMPDIR/rendered.yaml" 2>"$TMPDIR/render-err.txt"; then
     echo -e "${RED}    Render failed:${NC}"
     head -5 "$TMPDIR/render-err.txt" | sed 's/^/      /'
     return 1
@@ -162,7 +160,6 @@ bifrost:
     disableDbPingsInHealth: true
     logRetentionDays: 30
     enforceGovernanceHeader: true
-    allowDirectKeys: true
     maxRequestBodySizeMb: 50
     compat:
       convertTextToChat: true
@@ -202,7 +199,6 @@ assert_field_value 'client.disable_content_logging' '.client.disable_content_log
 assert_field_value 'client.disable_db_pings_in_health' '.client.disable_db_pings_in_health' 'true'
 assert_field_value 'client.log_retention_days' '.client.log_retention_days' '30'
 assert_field_value 'client.enforce_governance_header' '.client.enforce_governance_header' 'true'
-assert_field_value 'client.allow_direct_keys' '.client.allow_direct_keys' 'true'
 assert_field_value 'client.max_request_body_size_mb' '.client.max_request_body_size_mb' '50'
 assert_field_value 'client.compat.convert_text_to_chat' '.client.compat.convert_text_to_chat' 'true'
 assert_field_value 'client.compat.convert_chat_to_responses' '.client.compat.convert_chat_to_responses' 'true'

core/bifrost.go

@@ -5675,13 +5675,15 @@ func (bifrost *Bifrost) requestWorker(provider schemas.Provider, config *schemas
 		// Step 1: compute effective value for each flag (provider config ← per-request override).
 		effectiveSendBackReq := config.SendBackRawRequest
 		allowRawOverride, _ := req.Context.Value(schemas.BifrostContextKeyAllowPerRequestRawOverride).(bool)
-		if allowRawOverride {
+		passthroughOverridePresent, _ := req.Context.Value(schemas.BifrostContextKeyPassthroughOverridesPresent).(bool)
+
+		if allowRawOverride || passthroughOverridePresent {
 			if override, ok := req.Context.Value(schemas.BifrostContextKeySendBackRawRequest).(bool); ok {
 				effectiveSendBackReq = override
 			}
 		}
 		effectiveSendBackResp := config.SendBackRawResponse
-		if allowRawOverride {
+		if allowRawOverride || passthroughOverridePresent {
 			if override, ok := req.Context.Value(schemas.BifrostContextKeySendBackRawResponse).(bool); ok {
 				effectiveSendBackResp = override
 			}

core/providers/anthropic/utils_test.go

@@ -2541,3 +2541,95 @@ func TestRemapRawToolVersionsForProvider_NormalizesComputerUse(t *testing.T) {
 		})
 	}
 }
+
+// TestIsClaudeCodeRequest covers detection of Claude CLI / Claude Code clients
+// via the User-Agent stored on BifrostContext. ClaudeCLI.Matches uses a
+// case-insensitive substring check, so identifiers such as "claude-cli" should
+// match version-suffixed strings like "claude-cli/2.1.128 (external, cli)".
+func TestIsClaudeCodeRequest(t *testing.T) {
+	tests := []struct {
+		name      string
+		setUA     bool        // false: do not set the user-agent key on the context
+		userAgent interface{} // interface{} so we can also test non-string values
+		expected  bool
+	}{
+		{
+			name:      "claude-cli with version and metadata suffix",
+			setUA:     true,
+			userAgent: "claude-cli/2.1.128 (external, cli)",
+			expected:  true,
+		},
+		{
+			name:      "claude-cli older version",
+			setUA:     true,
+			userAgent: "claude-cli/1.0.0",
+			expected:  true,
+		},
+		{
+			name:      "claude-code identifier",
+			setUA:     true,
+			userAgent: "claude-code/0.5.2",
+			expected:  true,
+		},
+		{
+			name:      "claude-vscode identifier",
+			setUA:     true,
+			userAgent: "claude-vscode/0.1.0 (vscode)",
+			expected:  true,
+		},
+		{
+			name:      "uppercase CLAUDE-CLI matches case-insensitively",
+			setUA:     true,
+			userAgent: "CLAUDE-CLI/2.1.128 (external, cli)",
+			expected:  true,
+		},
+		{
+			name:      "claude-cli embedded in a larger user-agent string",
+			setUA:     true,
+			userAgent: "Mozilla/5.0 (compatible; claude-cli/2.1.128) extra-suffix",
+			expected:  true,
+		},
+		{
+			name:      "non-claude client (geminicli) does not match",
+			setUA:     true,
+			userAgent: "geminicli/0.4.1",
+			expected:  false,
+		},
+		{
+			name:      "non-claude client (python-requests) does not match",
+			setUA:     true,
+			userAgent: "python-requests/2.28.0",
+			expected:  false,
+		},
+		{
+			name:      "empty user-agent string",
+			setUA:     true,
+			userAgent: "",
+			expected:  false,
+		},
+		{
+			name:     "no user-agent set on context",
+			setUA:    false,
+			expected: false,
+		},
+		{
+			name:      "non-string value stored under the user-agent key",
+			setUA:     true,
+			userAgent: 12345,
+			expected:  false,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := schemas.NewBifrostContext(context.Background(), time.Time{})
+			if tc.setUA {
+				ctx.SetValue(schemas.BifrostContextKeyUserAgent, tc.userAgent)
+			}
+			got := IsClaudeCodeRequest(ctx)
+			if got != tc.expected {
+				t.Errorf("IsClaudeCodeRequest() = %v, want %v (userAgent=%v)", got, tc.expected, tc.userAgent)
+			}
+		})
+	}
+}

core/schemas/bifrost.go

@@ -262,7 +262,7 @@ const (
 	BifrostContextKeyTargetUserID                        BifrostContextKey = "target_user_id"
 	BifrostContextKeyIsAzureUserAgent                    BifrostContextKey = "bifrost-is-azure-user-agent" // bool (set by bifrost - DO NOT SET THIS MANUALLY)) - whether the request is an Azure user agent (only used in gateway)
 	BifrostContextKeyVideoOutputRequested                BifrostContextKey = "bifrost-video-output-requested"
-BifrostContextKeyValidateKeys                        BifrostContextKey = "bifrost-validate-keys"                         // bool (triggers additional key validation during provider add/update)
+	BifrostContextKeyValidateKeys                        BifrostContextKey = "bifrost-validate-keys"                         // bool (triggers additional key validation during provider add/update)
 	BifrostContextKeyProviderResponseHeaders             BifrostContextKey = "bifrost-provider-response-headers"             // map[string]string (set by provider handlers for response header forwarding)
 	BifrostContextKeyMCPAddedTools                       BifrostContextKey = "bifrost-mcp-added-tools"                       // []string (set by bifrost - DO NOT SET THIS MANUALLY)) - list of tools added to the request by MCP, all the tool are in the format "clientName-toolName"
 	BifrostContextKeyLargePayloadMode                    BifrostContextKey = "bifrost-large-payload-mode"                    // bool (set by bifrost - DO NOT SET THIS MANUALLY)) indicates large payload streaming mode is active
@@ -286,7 +286,7 @@ BifrostContextKeyValidateKeys                        BifrostContextKey = "bifros
 	BifrostContextKeySessionID                           BifrostContextKey = "bifrost-session-id"                            // string session ID for the request (session stickiness)
 	BifrostContextKeySessionTTL                          BifrostContextKey = "bifrost-session-ttl"                           // time.Duration session TTL for the request (session stickiness)
 	BifrostContextKeyMCPExtraHeaders                     BifrostContextKey = "bifrost-mcp-extra-headers"                     // map[string][]string (these headers are forwarded only to the MCP while tool execution if they are in the allowlist of the MCP client)
-	BifrostContextKeyMCPLogID                            BifrostContextKey = "bifrost-mcp-log-id"                             // string (unique UUID for each MCP tool log entry - set per goroutine by agent executor - DO NOT SET THIS MANUALLY)
+	BifrostContextKeyMCPLogID                            BifrostContextKey = "bifrost-mcp-log-id"                            // string (unique UUID for each MCP tool log entry - set per goroutine by agent executor - DO NOT SET THIS MANUALLY)
 	BifrostContextKeyCompatConvertTextToChat             BifrostContextKey = "bifrost-compat-convert-text-to-chat"           // bool (per-request override from x-bf-compat header)
 	BifrostContextKeyCompatConvertChatToResponses        BifrostContextKey = "bifrost-compat-convert-chat-to-responses"      // bool (per-request override from x-bf-compat header)
 	BifrostContextKeyCompatShouldDropParams              BifrostContextKey = "bifrost-compat-should-drop-params"             // bool (per-request override from x-bf-compat header)
@@ -295,7 +295,9 @@ BifrostContextKeyValidateKeys                        BifrostContextKey = "bifros
 	BifrostContextKeyDimensions                          BifrostContextKey = "bifrost-dimensions"                            // map[string]string (set by HTTP transport from x-bf-dim-* headers) BifrostContextKeyDimensions holds per-request key/value dimensions supplied via x-bf-dim-<key> request headers. These dimensions are forwarded to internal logs (as metadata)
 	BifrostContextKeySkipModelCatalogProviderSelection   BifrostContextKey = "bifrost-skip-model-catalog-provider-selection" // bool (set by bifrost - DO NOT SET THIS MANUALLY)) - skip model catalog provider selection
 	IsAPIKeyAuthContextKey                               BifrostContextKey = "is_api_key_auth"
-	IsLocalAdminContextKey                               BifrostContextKey = "is_local_admin"                                // bool (set by auth middleware when password-based auth succeeds - local admin user bypasses RBAC)
+	IsLocalAdminContextKey                               BifrostContextKey = "is_local_admin"                // bool (set by auth middleware when password-based auth succeeds - local admin user bypasses RBAC)
+	BifrostContextKeyPassthroughOverridesPresent         BifrostContextKey = "passthrough_overrides_present" // bool (set by HTTP transport) - passthrough raw request requested
+
 )
 
 const (

core/schemas/context.go

@@ -41,13 +41,6 @@ var pluginLogStorePool = sync.Pool{
 	},
 }
 
-// pluginScopePool pools BifrostContext instances used as scoped plugin contexts.
-var pluginScopePool = sync.Pool{
-	New: func() any {
-		return &BifrostContext{}
-	},
-}
-
 // BifrostContext is a custom context.Context implementation that tracks user-set values.
 // It supports deadlines, can be derived from other contexts, and provides layered
 // value inheritance when derived from another BifrostContext.
@@ -76,6 +69,18 @@ func NewBifrostContext(parent context.Context, deadline time.Time) *BifrostConte
 	if parent == nil {
 		parent = context.Background()
 	}
+	// Unwrap pooled scoped BifrostContexts to their delegate root. A scoped
+	// context (from WithPluginScope) is reset and returned to a sync.Pool when
+	// ReleasePluginScope is called, which can happen before a derived context's
+	// watchCancellation goroutine has finished observing parent.Deadline()/Done().
+	// Pointing the derived parent at the long-lived root avoids that race.
+	for {
+		bc, ok := parent.(*BifrostContext)
+		if !ok || bc.valueDelegate == nil {
+			break
+		}
+		parent = bc.valueDelegate
+	}
 	ctx := &BifrostContext{
 		parent:                parent,
 		deadline:              deadline,
@@ -399,10 +404,17 @@ func AppendToContextList[T any](ctx *BifrostContext, key BifrostContextKey, valu
 	ctx.SetValue(key, append(existingValues, value))
 }
 
-// WithPluginScope returns a lightweight scoped BifrostContext from the pool.
-// The scoped context shares the root's pluginLogs store and delegates all
-// Value/SetValue operations to the root context.
-// Call ReleasePluginScope() when done to return the scoped context to the pool.
+// WithPluginScope returns a scoped BifrostContext that shares the root's
+// pluginLogs store and delegates Value/SetValue/Deadline/Err/Done operations
+// to the root.
+//
+// Scoped contexts are NOT pool-reused. Plugins routinely pass the scoped ctx
+// to stdlib helpers (context.WithDeadline, HTTP clients, vector store SDKs)
+// which spawn watcher goroutines via context.propagateCancel — those watchers
+// can read the scoped struct's fields long after the plugin returns. Reusing
+// the struct across requests would race those reads. Allocating fresh is
+// idiomatic Go context handling (the stdlib context types are not pooled
+// either) and keeps the lifecycle race-free without atomics.
 func (bc *BifrostContext) WithPluginScope(name *string) *BifrostContext {
 	// Lazily initialize the plugin log store on the root context (CAS to avoid race)
 	if bc.pluginLogs.Load() == nil {
@@ -413,28 +425,32 @@ func (bc *BifrostContext) WithPluginScope(name *string) *BifrostContext {
 		}
 	}
 
-	scoped := pluginScopePool.Get().(*BifrostContext)
-	scoped.parent = bc.parent
-	scoped.done = bc.done
-	scoped.pluginScope = name
+	scoped := &BifrostContext{
+		parent:        bc.parent,
+		done:          bc.done,
+		pluginScope:   name,
+		valueDelegate: bc,
+	}
 	scoped.pluginLogs.Store(bc.pluginLogs.Load())
-	scoped.valueDelegate = bc
 	return scoped
 }
 
-// ReleasePluginScope returns a scoped context to the pool.
-// Safe no-op if called on a non-scoped context.
-// Do not use the scoped context after calling this method.
+// ReleasePluginScope marks a scoped context as released. Safe no-op if called
+// on a non-scoped context.
+//
+// We deliberately do NOT mutate the scoped struct's fields here. External
+// watcher goroutines spawned via stdlib context helpers (e.g. propagateCancel
+// from context.WithDeadline) may still hold references and read parent/done
+// asynchronously. Mutating those fields would race the watchers. The struct
+// becomes garbage and is reclaimed by the GC once all watchers have exited.
+//
+// We still release the plugin log store reference so it can be drained or
+// reclaimed independently of the scope's lifetime.
 func (bc *BifrostContext) ReleasePluginScope() {
 	if bc.valueDelegate == nil {
 		return // not a scoped context
 	}
-	bc.parent = nil
-	bc.done = nil
-	bc.pluginScope = nil
 	bc.pluginLogs.Store(nil)
-	bc.valueDelegate = nil
-	pluginScopePool.Put(bc)
 }
 
 // AddSpanAttribute adds an attribute to the span.

core/schemas/context_test.go

@@ -329,3 +329,71 @@ func TestPluginLog_PoolReuse(t *testing.T) {
 		t.Errorf("expected 100 logs from pool reuse, got %d", len(logs))
 	}
 }
+
+// TestNewBifrostContext_DerivedFromReleasedScope_NoPanic locks in the
+// deterministic half of the scoped-parent-release bug: a derived BifrostContext
+// must not deref a pool-released scoped ancestor when its accessors are called.
+//
+// Pre-fix shape (see plugins/semanticcache/utils.go:71):
+//
+//	root := NewBifrostContext(...)
+//	scope := root.WithPluginScope(...)
+//	derived := NewBifrostContext(scope, NoDeadline)   // derived.parent = scope
+//	scope.ReleasePluginScope()                        // scope.parent = nil, valueDelegate = nil
+//	derived.Deadline()                                 // → scope.Deadline() → nil deref panic
+//
+// The fix unwraps scoped parents to their valueDelegate (root) at construction
+// time, so derived.parent is root and the release of scope cannot affect it.
+func TestNewBifrostContext_DerivedFromReleasedScope_NoPanic(t *testing.T) {
+	root := NewBifrostContext(context.Background(), NoDeadline)
+	pluginName := "release-race"
+	scope := root.WithPluginScope(&pluginName)
+
+	derived := NewBifrostContext(scope, NoDeadline)
+
+	// Release the scope while a derived child is still alive — same shape as
+	// core/bifrost.go's plugin pipeline releasing pluginCtx after PreLLMHook
+	// returns, while plugins/semanticcache holds the embeddingCtx child.
+	scope.ReleasePluginScope()
+
+	// All three accessors used to crash via the parent chain. After the unwrap
+	// fix, derived.parent is the (still-live) root.
+	_, _ = derived.Deadline()
+	_ = derived.Err()
+	_ = derived.Done()
+}
+
+// TestNewBifrostContext_WatchdogRaceWithReleasedScope is the stress companion
+// to the deterministic test above. Run with `go test -race` to surface the
+// data race between watchCancellation reading bc.parent (context.go:202) and
+// ReleasePluginScope writing bc.parent = nil (context.go:432).
+//
+// With the unwrap fix, watchCancellation observes root (long-lived) instead of
+// the pool-released scope, so the race window does not exist.
+func TestNewBifrostContext_WatchdogRaceWithReleasedScope(t *testing.T) {
+	root := NewBifrostContext(context.Background(), NoDeadline)
+	pluginName := "watchdog-race"
+
+	const iterations = 200
+	derivedCtxs := make([]*BifrostContext, 0, iterations)
+	for i := 0; i < iterations; i++ {
+		scope := root.WithPluginScope(&pluginName)
+		// Spawning watchCancellation: parent (scope) has a non-nil Done()
+		// channel, so NewBifrostContext schedules the goroutine.
+		derivedCtxs = append(derivedCtxs, NewBifrostContext(scope, NoDeadline))
+		scope.ReleasePluginScope()
+	}
+
+	// Yield so any late-scheduled watchdog goroutines run their Deadline()
+	// observation after the surrounding scope was released. Under -race, any
+	// remaining racy read of a pool-reset field would be flagged here.
+	runtime.Gosched()
+	time.Sleep(50 * time.Millisecond)
+
+	// Touch each derived context to keep it live across the sleep — without
+	// this, the compiler/GC could optimize them away before the race window
+	// has a chance to manifest.
+	for _, c := range derivedCtxs {
+		_, _ = c.Deadline()
+	}
+}

core/version

@@ -1 +1 @@
-1.5.7
+1.5.8