diff --git a/internal/app/servicekit/providers.go b/internal/app/servicekit/providers.go index 527e96724..0869660d0 100644 --- a/internal/app/servicekit/providers.go +++ b/internal/app/servicekit/providers.go @@ -75,6 +75,7 @@ func resolveProviderMap(scope string, providers map[string]config.Provider, regi func disableProvider(providers map[string]config.Provider, id string, provider config.Provider, log *slog.Logger, reason string, cause error) { provider.APIKey = secret.SecretRef{} provider.APIKeyEnv = "" + provider.Disabled = true providers[id] = provider if cause != nil { log.Warn("provider disabled: "+reason, "provider", id, "err", cause) diff --git a/internal/config/config.go b/internal/config/config.go index 86f88ae9f..f318476d7 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -155,6 +155,12 @@ type Provider struct { APIKeyEnv string `toml:"api_key_env" yaml:"api_key_env" json:"api_key_env"` APIKey SecretRef `toml:"api_key" yaml:"api_key" json:"-"` BaseURL string `toml:"base_url" yaml:"base_url" json:"base_url"` + // Disabled marks a configured provider whose api_key could not be + // resolved at boot. It is runtime state, not a setting: without it a + // disabled provider is indistinguishable from one the operator never + // configured, and the model catalog would serve it from an ambient + // environment variable. + Disabled bool `toml:"-" yaml:"-" json:"-"` } // Forge intake modes for Forge.Intake. Poll is the default; webhook reacts to diff --git a/internal/infrastructure/modelcatalog/cache.go b/internal/infrastructure/modelcatalog/cache.go index 7b1b2c9de..d952986fd 100644 --- a/internal/infrastructure/modelcatalog/cache.go +++ b/internal/infrastructure/modelcatalog/cache.go @@ -106,6 +106,9 @@ func mergeProviders(base, overrides map[string]config.Provider) map[string]confi if override.BaseURL != "" { resolved.BaseURL = override.BaseURL } + if override.Disabled { + resolved.Disabled = true + } merged[id] = resolved } return merged diff --git a/internal/infrastructure/modelcatalog/catalog.go b/internal/infrastructure/modelcatalog/catalog.go index 0ae3a0a87..c42ad9c56 100644 --- a/internal/infrastructure/modelcatalog/catalog.go +++ b/internal/infrastructure/modelcatalog/catalog.go @@ -162,12 +162,8 @@ func usableProvider(key string, source catalogProvider, opts Options) (Provider, id = key } override, configured := opts.Configured[id] - envVar := firstSetEnv(source.Env, opts.Getenv) - if configured && override.APIKeyEnv != "" { - envVar = override.APIKeyEnv - } - if (!configured && envVar == "") || - (configured && override.APIKeyEnv != "" && opts.Getenv(override.APIKeyEnv) == "") { + envVar, ok := providerCredentialEnv(configured, override, source, opts.Getenv) + if !ok { return Provider{}, false } models := toolModels(source.Models) @@ -193,6 +189,28 @@ func usableProvider(key string, source catalogProvider, opts Options) (Provider, }, true } +// providerCredentialEnv returns the environment variable whose value is the +// provider's key, and whether the provider may be served at all. A configured +// provider is disabled when its key failed to resolve and must never fall +// back to the catalog's ambient environment, which would send a turn with a +// key the operator did not choose: the catalog names the environment +// variables it would use, and a configured provider overrides that with the +// variable its own resolution exported. +func providerCredentialEnv(configured bool, override config.Provider, source catalogProvider, getenv func(string) string) (string, bool) { + if configured && override.Disabled { + return "", false + } + envVar := firstSetEnv(source.Env, getenv) + if configured && override.APIKeyEnv != "" { + envVar = override.APIKeyEnv + } + if (!configured && envVar == "") || + (configured && override.APIKeyEnv != "" && getenv(override.APIKeyEnv) == "") { + return "", false + } + return envVar, true +} + func providerRuntimeDefaults(source catalogProvider) (class, baseURL string) { class = "openai-compatible" if mapped, ok := catalog.NPMClassMapping[source.NPM]; ok { diff --git a/internal/infrastructure/modelcatalog/catalog_test.go b/internal/infrastructure/modelcatalog/catalog_test.go new file mode 100644 index 000000000..14b8fcc48 --- /dev/null +++ b/internal/infrastructure/modelcatalog/catalog_test.go @@ -0,0 +1,109 @@ +package modelcatalog + +import ( + "testing" + + sdkcatalog "github.com/samcharles93/ai-sdk/catalog" + + "github.com/samcharles93/archie-core/internal/config" +) + +func envFrom(values map[string]string) func(string) string { + return func(name string) string { return values[name] } +} + +// modelProvider is one catalog entry shaped so usableProvider keeps it: it +// drops any provider with no tool-calling model. +func modelProvider(env []string) catalogProvider { + return catalogProvider{ + ID: "test", + NPM: "@ai-sdk/openai", + Env: env, + Models: map[string]sdkcatalog.Model{"m": {ID: "m", ToolCall: true}}, + } +} + +// TestUsableProviderCredentials pins which provider a credential makes usable. +// A configured provider whose key failed to resolve is disabled, and must not +// borrow an ambient environment variable: that would send a turn with a key +// the operator did not choose and surface as a provider auth error. +func TestUsableProviderCredentials(t *testing.T) { + tests := []struct { + name string + source catalogProvider + configured map[string]config.Provider + env map[string]string + want bool + wantEnv string + }{ + { + name: "unconfigured provider with an ambient key is usable", + source: modelProvider([]string{"OPENAI_API_KEY"}), + env: map[string]string{"OPENAI_API_KEY": "ambient"}, + want: true, + wantEnv: "OPENAI_API_KEY", + }, + { + name: "unconfigured provider with no key is not usable", + source: modelProvider([]string{"OPENAI_API_KEY"}), + want: false, + }, + { + name: "configured provider with a resolved key uses its own env var", + source: modelProvider([]string{"OPENAI_API_KEY"}), + configured: map[string]config.Provider{"test": {APIKeyEnv: "ARCHIE_PROVIDER_1_API_KEY"}}, + env: map[string]string{"ARCHIE_PROVIDER_1_API_KEY": "resolved", "OPENAI_API_KEY": "ambient"}, + want: true, + wantEnv: "ARCHIE_PROVIDER_1_API_KEY", + }, + { + name: "configured provider whose resolved env var is empty is not usable", + source: modelProvider([]string{"OPENAI_API_KEY"}), + configured: map[string]config.Provider{"test": {APIKeyEnv: "ARCHIE_PROVIDER_1_API_KEY"}}, + env: map[string]string{"OPENAI_API_KEY": "ambient"}, + want: false, + }, + { + name: "configured provider disabled by a failed resolution never borrows the ambient key", + source: modelProvider([]string{"OPENAI_API_KEY"}), + configured: map[string]config.Provider{"test": {Disabled: true}}, + env: map[string]string{"OPENAI_API_KEY": "ambient"}, + want: false, + }, + { + name: "configured keyless provider stays usable", + source: modelProvider(nil), + configured: map[string]config.Provider{"test": {Class: "ollama"}}, + want: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + provider, ok := usableProvider("test", tt.source, Options{ + Configured: tt.configured, + Getenv: envFrom(tt.env), + }) + if ok != tt.want { + t.Fatalf("usableProvider ok = %v, want %v", ok, tt.want) + } + if ok && provider.APIKeyEnv != tt.wantEnv { + t.Errorf("APIKeyEnv = %q, want %q", provider.APIKeyEnv, tt.wantEnv) + } + }) + } +} + +// TestMergeProvidersKeepsDisabled covers the other half of a disabled +// provider's lifetime: Apply rewrites cfg.Providers through mergeProviders, +// and a dropped flag would let the next catalog refresh serve the ambient key +// again. +func TestMergeProvidersKeepsDisabled(t *testing.T) { + merged := mergeProviders( + map[string]config.Provider{"openai": {Class: "openai", APIKeyEnv: "OPENAI_API_KEY"}}, + map[string]config.Provider{"openai": {Disabled: true}}, + ) + if !merged["openai"].Disabled { + t.Fatal("mergeProviders dropped Disabled; a refresh would serve the ambient key") + } +}