diff --git a/internal/app/controlplane/runtime_config.go b/internal/app/controlplane/runtime_config.go index b2422c339..fd6308910 100644 --- a/internal/app/controlplane/runtime_config.go +++ b/internal/app/controlplane/runtime_config.go @@ -185,11 +185,24 @@ func runtimeToolConfigFrom(ctx context.Context, reader controlplanerpc.ResourceR return err } headers := make(map[string]map[string]string, len(out.Tools.MCPServers)) + fileParallelToolCalls := make(map[string]bool, len(out.Tools.MCPServers)) for _, server := range out.Tools.MCPServers { headers[server.Name] = server.Headers + fileParallelToolCalls[server.Name] = server.ParallelToolCalls } servers := make([]config.MCPServer, 0, len(settings.MCPServers)) for _, server := range settings.MCPServers { + // This assignment replaces cfg.Tools wholesale, so every field the + // stored resource does not carry has to be taken back from the file + // or the operator's file value is dropped. Headers have always been + // file-owned; ParallelToolCalls joins them when the store predates + // the field, because a nil pointer means "no stored decision", not + // "false". A server with no file entry has nothing to inherit and + // gets the zero value. + parallelToolCalls := fileParallelToolCalls[server.Name] + if server.ParallelToolCalls != nil { + parallelToolCalls = *server.ParallelToolCalls + } servers = append(servers, config.MCPServer{ Name: server.Name, Transport: server.Transport, @@ -200,7 +213,7 @@ func runtimeToolConfigFrom(ctx context.Context, reader controlplanerpc.ResourceR Headers: headers[server.Name], SSEEndpoint: server.SSEEndpoint, MessageEndpoint: server.MessageEndpoint, - ParallelToolCalls: server.ParallelToolCalls, + ParallelToolCalls: parallelToolCalls, }) } out.Tools = config.ToolsConfig{MCPServers: servers, Policy: settings.Policy, WebFetch: settings.WebFetch, Minimax: config.MinimaxConfig{Enabled: settings.Minimax.Enabled, APIKey: settings.Minimax.APIKey, BaseURL: settings.Minimax.BaseURL}} diff --git a/internal/app/controlplane/runtime_config_test.go b/internal/app/controlplane/runtime_config_test.go index 6f79aa623..47d312f79 100644 --- a/internal/app/controlplane/runtime_config_test.go +++ b/internal/app/controlplane/runtime_config_test.go @@ -196,6 +196,57 @@ func TestRuntimeConfigCarriesParallelToolCallsThroughTheProjection(t *testing.T) } } +// TestRuntimeConfigInheritsAnAbsentParallelToolCallsFromTheFile is the other +// half of the round trip above, and the reason the projection field is a +// pointer. A tool-settings resource seeded before parallel_tool_calls existed +// carries no key for it, and the layering replaces cfg.Tools wholesale -- so +// without an inherited default the operator's file-level +// parallel_tool_calls = true is inert for exactly the stores that already +// exist, which are the ones a new field cannot reach. Absence has to mean "the +// file's value": the shape mcp headers already use in this same function, and +// the one schedulingPolicy.Label documents. +func TestRuntimeConfigInheritsAnAbsentParallelToolCallsFromTheFile(t *testing.T) { + base := config.Config{Tools: config.ToolsConfig{MCPServers: []config.MCPServer{{ + Name: "docs", Transport: "stdio", Command: "docs-server", ParallelToolCalls: true, + }}}} + + // A store seeded before the field existed: the key is absent, not false. + stored := []byte(`{"mcp_servers":[{"name":"docs","transport":"stdio","command":"docs-server"}]}`) + + got := layerToolSettings(t, stored, base) + if !got.Tools.MCPServers[0].ParallelToolCalls { + t.Fatalf("ParallelToolCalls = false, want the file's true inherited: an absent key must not mean the zero value (%+v)", got.Tools.MCPServers[0]) + } +} + +// TestRuntimeConfigPrefersAStoredParallelToolCalls is the other direction: the +// inherit rule must not become "the file always wins". An explicit stored value +// is the operator's decision through the control plane. +func TestRuntimeConfigPrefersAStoredParallelToolCalls(t *testing.T) { + base := config.Config{Tools: config.ToolsConfig{MCPServers: []config.MCPServer{{ + Name: "docs", Transport: "stdio", Command: "docs-server", ParallelToolCalls: false, + }}}} + + stored := []byte(`{"mcp_servers":[{"name":"docs","transport":"stdio","command":"docs-server","parallel_tool_calls":true}]}`) + + got := layerToolSettings(t, stored, base) + if !got.Tools.MCPServers[0].ParallelToolCalls { + t.Fatalf("ParallelToolCalls = false, want the stored true: a stored value outranks the file") + } +} + +// TestRuntimeConfigAbsentKeyWithNoFileEntryIsFalse covers the case with nothing +// to inherit: a server that exists only in the resource has no file value, so +// absence is the zero value there rather than an error. +func TestRuntimeConfigAbsentKeyWithNoFileEntryIsFalse(t *testing.T) { + stored := []byte(`{"mcp_servers":[{"name":"resource-only","transport":"stdio","command":"x"}]}`) + + got := layerToolSettings(t, stored, config.Config{}) + if got.Tools.MCPServers[0].ParallelToolCalls { + t.Fatalf("ParallelToolCalls = true, want the zero value when the file has no entry to inherit from") + } +} + // settingsProjectionSpec describes a source config struct and the explicit // control-plane document struct that projects it. Overrides cover renamed or // transformed keys; the two allowlists require a reason for one-way fields. diff --git a/internal/app/controlplane/tool_settings.go b/internal/app/controlplane/tool_settings.go index e4ddb6f12..0cd23b8f4 100644 --- a/internal/app/controlplane/tool_settings.go +++ b/internal/app/controlplane/tool_settings.go @@ -15,16 +15,23 @@ type toolSettings struct { } type mcpServerSettings struct { - Name string `json:"name"` - Transport string `json:"transport"` - Command string `json:"command,omitempty"` - Args []string `json:"args,omitempty"` - WorkDir string `json:"work_dir,omitempty"` - URL string `json:"url,omitempty"` - SSEEndpoint string `json:"sse_endpoint,omitempty"` - MessageEndpoint string `json:"message_endpoint,omitempty"` - ParallelToolCalls bool `json:"parallel_tool_calls"` - HeadersConfigured bool `json:"headers_configured"` + Name string `json:"name"` + Transport string `json:"transport"` + Command string `json:"command,omitempty"` + Args []string `json:"args,omitempty"` + WorkDir string `json:"work_dir,omitempty"` + URL string `json:"url,omitempty"` + SSEEndpoint string `json:"sse_endpoint,omitempty"` + MessageEndpoint string `json:"message_endpoint,omitempty"` + // ParallelToolCalls is a pointer, not a bool, for the same reason + // schedulingPolicy.Label is: a resource seeded before this field existed + // carries no key for it, and the layering replaces cfg.Tools wholesale, so + // absence has to mean "leave the file document's value in force" rather + // than "false". A plain bool cannot tell the two apart, which made the + // file's parallel_tool_calls inert on every store that predates the field + // -- the stores that cannot be re-seeded. + ParallelToolCalls *bool `json:"parallel_tool_calls,omitempty"` + HeadersConfigured bool `json:"headers_configured"` } type minimaxSettings struct { @@ -37,6 +44,9 @@ type minimaxSettings struct { func seedTools(cfg config.Config) any { servers := make([]mcpServerSettings, 0, len(cfg.Tools.MCPServers)) for _, server := range cfg.Tools.MCPServers { + // The seed states the file's value explicitly: it is written on a fresh + // store, where there is nothing older to inherit from. + parallelToolCalls := server.ParallelToolCalls servers = append(servers, mcpServerSettings{ Name: server.Name, Transport: server.Transport, @@ -46,7 +56,7 @@ func seedTools(cfg config.Config) any { URL: server.URL, SSEEndpoint: server.SSEEndpoint, MessageEndpoint: server.MessageEndpoint, - ParallelToolCalls: server.ParallelToolCalls, + ParallelToolCalls: ¶llelToolCalls, HeadersConfigured: len(server.Headers) > 0, }) }