@phi-code-admin/phi-code 0.74.2 → 0.75.0

package/dist/core/model-registry.js

@@ -1,31 +1,64 @@
 /**
  * Model registry - manages built-in and custom models, provides API key resolution.
  */
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
 import { getModels, getProviders, registerApiProvider, resetApiProviders, } from "phi-code-ai";
 import { registerOAuthProvider, resetOAuthProviders } from "phi-code-ai/oauth";
-import { Type } from "@sinclair/typebox";
-import AjvModule from "ajv";
-import { existsSync, readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { Type } from "typebox";
+import { Compile } from "typebox/compile";
 import { getAgentDir } from "../config.js";
-import { clearConfigValueCache, resolveConfigValue, resolveHeaders } from "./resolve-config-value.js";
-const Ajv = AjvModule.default || AjvModule;
-const ajv = new Ajv();
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const DEFAULT_MODELS_PATH = join(__dirname, "default-models.json");
+import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "./provider-display-names.js";
+import { clearConfigValueCache, resolveConfigValueOrThrow, resolveConfigValueUncached, resolveHeadersOrThrow, } from "./resolve-config-value.js";
 // Schema for OpenRouter routing preferences
+const PercentileCutoffsSchema = Type.Object({
+    p50: Type.Optional(Type.Number()),
+    p75: Type.Optional(Type.Number()),
+    p90: Type.Optional(Type.Number()),
+    p99: Type.Optional(Type.Number()),
+});
 const OpenRouterRoutingSchema = Type.Object({
-    only: Type.Optional(Type.Array(Type.String())),
+    allow_fallbacks: Type.Optional(Type.Boolean()),
+    require_parameters: Type.Optional(Type.Boolean()),
+    data_collection: Type.Optional(Type.Union([Type.Literal("deny"), Type.Literal("allow")])),
+    zdr: Type.Optional(Type.Boolean()),
+    enforce_distillable_text: Type.Optional(Type.Boolean()),
     order: Type.Optional(Type.Array(Type.String())),
+    only: Type.Optional(Type.Array(Type.String())),
+    ignore: Type.Optional(Type.Array(Type.String())),
+    quantizations: Type.Optional(Type.Array(Type.String())),
+    sort: Type.Optional(Type.Union([
+        Type.String(),
+        Type.Object({
+            by: Type.Optional(Type.String()),
+            partition: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+        }),
+    ])),
+    max_price: Type.Optional(Type.Object({
+        prompt: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+        completion: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+        image: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+        audio: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+        request: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    })),
+    preferred_min_throughput: Type.Optional(Type.Union([Type.Number(), PercentileCutoffsSchema])),
+    preferred_max_latency: Type.Optional(Type.Union([Type.Number(), PercentileCutoffsSchema])),
 });
 // Schema for Vercel AI Gateway routing preferences
 const VercelGatewayRoutingSchema = Type.Object({
     only: Type.Optional(Type.Array(Type.String())),
     order: Type.Optional(Type.Array(Type.String())),
 });
-// Schema for OpenAI compatibility settings
+// Schema for thinking level support and provider-specific values
+const ThinkingLevelMapValueSchema = Type.Union([Type.String(), Type.Null()]);
+const ThinkingLevelMapSchema = Type.Object({
+    off: Type.Optional(ThinkingLevelMapValueSchema),
+    minimal: Type.Optional(ThinkingLevelMapValueSchema),
+    low: Type.Optional(ThinkingLevelMapValueSchema),
+    medium: Type.Optional(ThinkingLevelMapValueSchema),
+    high: Type.Optional(ThinkingLevelMapValueSchema),
+    xhigh: Type.Optional(ThinkingLevelMapValueSchema),
+});
 const OpenAICompletionsCompatSchema = Type.Object({
     supportsStore: Type.Optional(Type.Boolean()),
     supportsDeveloperRole: Type.Optional(Type.Boolean()),
@@ -35,15 +68,35 @@ const OpenAICompletionsCompatSchema = Type.Object({
     requiresToolResultName: Type.Optional(Type.Boolean()),
     requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
     requiresThinkingAsText: Type.Optional(Type.Boolean()),
-    requiresMistralToolIds: Type.Optional(Type.Boolean()),
-    thinkingFormat: Type.Optional(Type.Union([Type.Literal("openai"), Type.Literal("zai"), Type.Literal("qwen")])),
+    requiresReasoningContentOnAssistantMessages: Type.Optional(Type.Boolean()),
+    thinkingFormat: Type.Optional(Type.Union([
+        Type.Literal("openai"),
+        Type.Literal("openrouter"),
+        Type.Literal("together"),
+        Type.Literal("deepseek"),
+        Type.Literal("zai"),
+        Type.Literal("qwen"),
+        Type.Literal("qwen-chat-template"),
+    ])),
+    cacheControlFormat: Type.Optional(Type.Literal("anthropic")),
     openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
     vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema),
+    supportsStrictMode: Type.Optional(Type.Boolean()),
+    supportsLongCacheRetention: Type.Optional(Type.Boolean()),
 });
 const OpenAIResponsesCompatSchema = Type.Object({
-// Reserved for future use
+    sendSessionIdHeader: Type.Optional(Type.Boolean()),
+    supportsLongCacheRetention: Type.Optional(Type.Boolean()),
+});
+const AnthropicMessagesCompatSchema = Type.Object({
+    supportsEagerToolInputStreaming: Type.Optional(Type.Boolean()),
+    supportsLongCacheRetention: Type.Optional(Type.Boolean()),
 });
-const OpenAICompatSchema = Type.Union([OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema]);
+const ProviderCompatSchema = Type.Union([
+    OpenAICompletionsCompatSchema,
+    OpenAIResponsesCompatSchema,
+    AnthropicMessagesCompatSchema,
+]);
 // Schema for custom model definition
 // Most fields are optional with sensible defaults for local models (Ollama, LM Studio, etc.)
 const ModelDefinitionSchema = Type.Object({
@@ -52,6 +105,7 @@ const ModelDefinitionSchema = Type.Object({
     api: Type.Optional(Type.String({ minLength: 1 })),
     baseUrl: Type.Optional(Type.String({ minLength: 1 })),
     reasoning: Type.Optional(Type.Boolean()),
+    thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
     input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
     cost: Type.Optional(Type.Object({
         input: Type.Number(),
@@ -62,12 +116,13 @@ const ModelDefinitionSchema = Type.Object({
     contextWindow: Type.Optional(Type.Number()),
     maxTokens: Type.Optional(Type.Number()),
     headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-    compat: Type.Optional(OpenAICompatSchema),
+    compat: Type.Optional(ProviderCompatSchema),
 });
 // Schema for per-model overrides (all fields optional, merged with built-in model)
 const ModelOverrideSchema = Type.Object({
     name: Type.Optional(Type.String({ minLength: 1 })),
     reasoning: Type.Optional(Type.Boolean()),
+    thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
     input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
     cost: Type.Optional(Type.Object({
         input: Type.Optional(Type.Number()),
@@ -78,13 +133,15 @@ const ModelOverrideSchema = Type.Object({
     contextWindow: Type.Optional(Type.Number()),
     maxTokens: Type.Optional(Type.Number()),
     headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-    compat: Type.Optional(OpenAICompatSchema),
+    compat: Type.Optional(ProviderCompatSchema),
 });
 const ProviderConfigSchema = Type.Object({
+    name: Type.Optional(Type.String({ minLength: 1 })),
     baseUrl: Type.Optional(Type.String({ minLength: 1 })),
     apiKey: Type.Optional(Type.String({ minLength: 1 })),
     api: Type.Optional(Type.String({ minLength: 1 })),
     headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+    compat: Type.Optional(ProviderCompatSchema),
     authHeader: Type.Optional(Type.Boolean()),
     models: Type.Optional(Type.Array(ModelDefinitionSchema)),
     modelOverrides: Type.Optional(Type.Record(Type.String(), ModelOverrideSchema)),
@@ -92,7 +149,25 @@ const ProviderConfigSchema = Type.Object({
 const ModelsConfigSchema = Type.Object({
     providers: Type.Record(Type.String(), ProviderConfigSchema),
 });
-ajv.addSchema(ModelsConfigSchema, "ModelsConfig");
+const validateModelsConfig = Compile(ModelsConfigSchema);
+function formatValidationPath(error) {
+    if (error.keyword === "required") {
+        const requiredProperties = error.params.requiredProperties;
+        const requiredProperty = requiredProperties?.[0];
+        if (requiredProperty) {
+            const basePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+            return basePath ? `${basePath}.${requiredProperty}` : requiredProperty;
+        }
+    }
+    const path = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+    return path || "root";
+}
+/** Strip `//` line comments and trailing commas from JSON, leaving string literals untouched. */
+function stripJsonComments(input) {
+    return input
+        .replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*/g, (m) => (m[0] === '"' ? m : ""))
+        .replace(/"(?:\\.|[^"\\])*"|,(\s*[}\]])/g, (m, tail) => tail ?? (m[0] === '"' ? m : ""));
+}
 function emptyCustomModelsResult(error) {
     return { models: [], overrides: new Map(), modelOverrides: new Map(), error };
 }
@@ -130,6 +205,9 @@ function applyModelOverride(model, override) {
         result.name = override.name;
     if (override.reasoning !== undefined)
         result.reasoning = override.reasoning;
+    if (override.thinkingLevelMap !== undefined) {
+        result.thinkingLevelMap = { ...model.thinkingLevelMap, ...override.thinkingLevelMap };
+    }
     if (override.input !== undefined)
         result.input = override.input;
     if (override.contextWindow !== undefined)
@@ -145,11 +223,6 @@ function applyModelOverride(model, override) {
             cacheWrite: override.cost.cacheWrite ?? model.cost.cacheWrite,
         };
     }
-    // Merge headers
-    if (override.headers) {
-        const resolvedHeaders = resolveHeaders(override.headers);
-        result.headers = resolvedHeaders ? { ...model.headers, ...resolvedHeaders } : model.headers;
-    }
     // Deep merge compat
     result.compat = mergeCompat(model.compat, override.compat);
     return result;
@@ -160,29 +233,30 @@ export const clearApiKeyCache = clearConfigValueCache;
  * Model registry - loads and manages models, resolves API keys via AuthStorage.
  */
 export class ModelRegistry {
-    constructor(authStorage, modelsJsonPath = join(getAgentDir(), "models.json")) {
+    authStorage;
+    modelsJsonPath;
+    models = [];
+    providerRequestConfigs = new Map();
+    modelRequestHeaders = new Map();
+    registeredProviders = new Map();
+    loadError = undefined;
+    constructor(authStorage, modelsJsonPath) {
         this.authStorage = authStorage;
         this.modelsJsonPath = modelsJsonPath;
-        this.models = [];
-        this.customProviderApiKeys = new Map();
-        this.registeredProviders = new Map();
-        this.loadError = undefined;
-        // Set up fallback resolver for custom provider API keys
-        this.authStorage.setFallbackResolver((provider) => {
-            const keyConfig = this.customProviderApiKeys.get(provider);
-            if (keyConfig) {
-                return resolveConfigValue(keyConfig);
-            }
-            return undefined;
-        });
-        // Load models
         this.loadModels();
     }
+    static create(authStorage, modelsJsonPath = join(getAgentDir(), "models.json")) {
+        return new ModelRegistry(authStorage, modelsJsonPath);
+    }
+    static inMemory(authStorage) {
+        return new ModelRegistry(authStorage, undefined);
+    }
     /**
      * Reload models from disk (built-in + custom from models.json).
      */
     refresh() {
-        this.customProviderApiKeys.clear();
+        this.providerRequestConfigs.clear();
+        this.modelRequestHeaders.clear();
         this.loadError = undefined;
         // Ensure dynamic API/OAuth registrations are rebuilt from current provider state.
         resetApiProviders();
@@ -224,13 +298,12 @@ export class ModelRegistry {
             const perModelOverrides = modelOverrides.get(provider);
             return models.map((m) => {
                 let model = m;
-                // Apply provider-level baseUrl/headers override
+                // Apply provider-level baseUrl/headers/compat override
                 if (providerOverride) {
-                    const resolvedHeaders = resolveHeaders(providerOverride.headers);
                     model = {
                         ...model,
                         baseUrl: providerOverride.baseUrl ?? model.baseUrl,
-                        headers: resolvedHeaders ? { ...model.headers, ...resolvedHeaders } : model.headers,
+                        compat: mergeCompat(model.compat, providerOverride.compat),
                     };
                 }
                 // Apply per-model override
@@ -258,68 +331,62 @@ export class ModelRegistry {
     }
     loadCustomModels(modelsJsonPath) {
         if (!existsSync(modelsJsonPath)) {
-            // If user's models.json doesn't exist, try to load default models
-            if (existsSync(DEFAULT_MODELS_PATH)) {
-                return this.loadModelsFromFile(DEFAULT_MODELS_PATH);
-            }
             return emptyCustomModelsResult();
         }
-        return this.loadModelsFromFile(modelsJsonPath);
-    }
-    loadModelsFromFile(filePath) {
         try {
-            const content = readFileSync(filePath, "utf-8");
-            const config = JSON.parse(content);
-            // Validate schema
-            const validate = ajv.getSchema("ModelsConfig");
-            if (!validate(config)) {
-                const errors = validate.errors?.map((e) => `  - ${e.instancePath || "root"}: ${e.message}`).join("\n") ||
-                    "Unknown schema error";
-                return emptyCustomModelsResult(`Invalid models.json schema:\n${errors}\n\nFile: ${filePath}`);
+            const content = readFileSync(modelsJsonPath, "utf-8");
+            const parsed = JSON.parse(stripJsonComments(content));
+            if (!validateModelsConfig.Check(parsed)) {
+                const errors = validateModelsConfig
+                    .Errors(parsed)
+                    .map((error) => `  - ${formatValidationPath(error)}: ${error.message}`)
+                    .join("\n") || "Unknown schema error";
+                return emptyCustomModelsResult(`Invalid models.json schema:\n${errors}\n\nFile: ${modelsJsonPath}`);
             }
+            const config = parsed;
             // Additional validation
             this.validateConfig(config);
             const overrides = new Map();
             const modelOverrides = new Map();
             for (const [providerName, providerConfig] of Object.entries(config.providers)) {
-                // Apply provider-level baseUrl/headers/apiKey override to built-in models when configured.
-                if (providerConfig.baseUrl || providerConfig.headers || providerConfig.apiKey) {
+                if (providerConfig.baseUrl || providerConfig.compat) {
                     overrides.set(providerName, {
                         baseUrl: providerConfig.baseUrl,
-                        headers: providerConfig.headers,
-                        apiKey: providerConfig.apiKey,
+                        compat: providerConfig.compat,
                     });
                 }
-                // Store API key for fallback resolver.
-                if (providerConfig.apiKey) {
-                    this.customProviderApiKeys.set(providerName, providerConfig.apiKey);
-                }
+                this.storeProviderRequestConfig(providerName, providerConfig);
                 if (providerConfig.modelOverrides) {
                     modelOverrides.set(providerName, new Map(Object.entries(providerConfig.modelOverrides)));
+                    for (const [modelId, modelOverride] of Object.entries(providerConfig.modelOverrides)) {
+                        this.storeModelHeaders(providerName, modelId, modelOverride.headers);
+                    }
                 }
             }
             return { models: this.parseModels(config), overrides, modelOverrides, error: undefined };
         }
         catch (error) {
             if (error instanceof SyntaxError) {
-                return emptyCustomModelsResult(`Failed to parse models.json: ${error.message}\n\nFile: ${filePath}`);
+                return emptyCustomModelsResult(`Failed to parse models.json: ${error.message}\n\nFile: ${modelsJsonPath}`);
             }
-            return emptyCustomModelsResult(`Failed to load models.json: ${error instanceof Error ? error.message : error}\n\nFile: ${filePath}`);
+            return emptyCustomModelsResult(`Failed to load models.json: ${error instanceof Error ? error.message : error}\n\nFile: ${modelsJsonPath}`);
         }
     }
     validateConfig(config) {
+        const builtInProviders = new Set(getProviders());
         for (const [providerName, providerConfig] of Object.entries(config.providers)) {
+            const isBuiltIn = builtInProviders.has(providerName);
             const hasProviderApi = !!providerConfig.api;
             const models = providerConfig.models ?? [];
             const hasModelOverrides = providerConfig.modelOverrides && Object.keys(providerConfig.modelOverrides).length > 0;
             if (models.length === 0) {
-                // Override-only config: needs baseUrl OR modelOverrides (or both)
-                if (!providerConfig.baseUrl && !hasModelOverrides) {
-                    throw new Error(`Provider ${providerName}: must specify "baseUrl", "modelOverrides", or "models".`);
+                // Override-only config: needs baseUrl, headers, compat, modelOverrides, or some combination.
+                if (!providerConfig.baseUrl && !providerConfig.headers && !providerConfig.compat && !hasModelOverrides) {
+                    throw new Error(`Provider ${providerName}: must specify "baseUrl", "headers", "compat", "modelOverrides", or "models".`);
                 }
             }
-            else {
-                // Custom models are merged into provider models and require endpoint + auth.
+            else if (!isBuiltIn) {
+                // Non-built-in providers with custom models require endpoint + auth.
                 if (!providerConfig.baseUrl) {
                     throw new Error(`Provider ${providerName}: "baseUrl" is required when defining custom models.`);
                 }
@@ -327,11 +394,14 @@ export class ModelRegistry {
                     throw new Error(`Provider ${providerName}: "apiKey" is required when defining custom models.`);
                 }
             }
+            // Built-in providers with custom models: baseUrl/apiKey/api are optional,
+            // inherited from built-in models. Auth comes from env vars / auth storage.
             for (const modelDef of models) {
                 const hasModelApi = !!modelDef.api;
-                if (!hasProviderApi && !hasModelApi) {
+                if (!hasProviderApi && !hasModelApi && !isBuiltIn) {
                     throw new Error(`Provider ${providerName}, model ${modelDef.id}: no "api" specified. Set at provider or model level.`);
                 }
+                // For built-in providers, api is optional — inherited from built-in models.
                 if (!modelDef.id)
                     throw new Error(`Provider ${providerName}: model missing "id"`);
                 // Validate contextWindow/maxTokens only if provided (they have defaults)
@@ -344,46 +414,50 @@ export class ModelRegistry {
     }
     parseModels(config) {
         const models = [];
+        const builtInProviders = new Set(getProviders());
+        // Cache built-in defaults (api, baseUrl) per provider, extracted from first model.
+        const builtInDefaultsCache = new Map();
+        const getBuiltInDefaults = (providerName) => {
+            if (!builtInProviders.has(providerName))
+                return undefined;
+            if (builtInDefaultsCache.has(providerName))
+                return builtInDefaultsCache.get(providerName);
+            const builtIn = getModels(providerName);
+            if (builtIn.length === 0)
+                return undefined;
+            const defaults = { api: builtIn[0].api, baseUrl: builtIn[0].baseUrl };
+            builtInDefaultsCache.set(providerName, defaults);
+            return defaults;
+        };
         for (const [providerName, providerConfig] of Object.entries(config.providers)) {
             const modelDefs = providerConfig.models ?? [];
             if (modelDefs.length === 0)
                 continue; // Override-only, no custom models
-            // Store API key config for fallback resolver
-            if (providerConfig.apiKey) {
-                this.customProviderApiKeys.set(providerName, providerConfig.apiKey);
-            }
+            const builtInDefaults = getBuiltInDefaults(providerName);
             for (const modelDef of modelDefs) {
-                const api = modelDef.api || providerConfig.api;
+                const api = modelDef.api ?? providerConfig.api ?? builtInDefaults?.api;
                 if (!api)
                     continue;
-                // Merge headers: provider headers are base, model headers override
-                // Resolve env vars and shell commands in header values
-                const providerHeaders = resolveHeaders(providerConfig.headers);
-                const modelHeaders = resolveHeaders(modelDef.headers);
-                let headers = providerHeaders || modelHeaders ? { ...providerHeaders, ...modelHeaders } : undefined;
-                // If authHeader is true, add Authorization header with resolved API key
-                if (providerConfig.authHeader && providerConfig.apiKey) {
-                    const resolvedKey = resolveConfigValue(providerConfig.apiKey);
-                    if (resolvedKey) {
-                        headers = { ...headers, Authorization: `Bearer ${resolvedKey}` };
-                    }
-                }
-                // Provider baseUrl is required when custom models are defined.
-                // Individual models can override it with modelDef.baseUrl.
+                const baseUrl = modelDef.baseUrl ?? providerConfig.baseUrl ?? builtInDefaults?.baseUrl;
+                if (!baseUrl)
+                    continue;
+                const compat = mergeCompat(providerConfig.compat, modelDef.compat);
+                this.storeModelHeaders(providerName, modelDef.id, modelDef.headers);
                 const defaultCost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
                 models.push({
                     id: modelDef.id,
                     name: modelDef.name ?? modelDef.id,
                     api: api,
                     provider: providerName,
-                    baseUrl: modelDef.baseUrl ?? providerConfig.baseUrl,
+                    baseUrl,
                     reasoning: modelDef.reasoning ?? false,
+                    thinkingLevelMap: modelDef.thinkingLevelMap,
                     input: (modelDef.input ?? ["text"]),
                     cost: modelDef.cost ?? defaultCost,
                     contextWindow: modelDef.contextWindow ?? 128000,
                     maxTokens: modelDef.maxTokens ?? 16384,
-                    headers,
-                    compat: modelDef.compat,
+                    headers: undefined,
+                    compat,
                 });
             }
         }
@@ -401,7 +475,7 @@ export class ModelRegistry {
      * This is a fast check that doesn't refresh OAuth tokens.
      */
     getAvailable() {
-        return this.models.filter((m) => this.authStorage.hasAuth(m.provider));
+        return this.models.filter((m) => this.hasConfiguredAuth(m));
     }
     /**
      * Find a model by provider and ID.
@@ -412,14 +486,109 @@ export class ModelRegistry {
     /**
      * Get API key for a model.
      */
-    async getApiKey(model) {
-        return this.authStorage.getApiKey(model.provider);
+    hasConfiguredAuth(model) {
+        return (this.authStorage.hasAuth(model.provider) ||
+            this.providerRequestConfigs.get(model.provider)?.apiKey !== undefined);
+    }
+    getModelRequestKey(provider, modelId) {
+        return `${provider}:${modelId}`;
+    }
+    storeProviderRequestConfig(providerName, config) {
+        if (!config.apiKey && !config.headers && !config.authHeader) {
+            return;
+        }
+        this.providerRequestConfigs.set(providerName, {
+            apiKey: config.apiKey,
+            headers: config.headers,
+            authHeader: config.authHeader,
+        });
+    }
+    storeModelHeaders(providerName, modelId, headers) {
+        const key = this.getModelRequestKey(providerName, modelId);
+        if (!headers || Object.keys(headers).length === 0) {
+            this.modelRequestHeaders.delete(key);
+            return;
+        }
+        this.modelRequestHeaders.set(key, headers);
+    }
+    /**
+     * Get API key and request headers for a model.
+     */
+    async getApiKeyAndHeaders(model) {
+        try {
+            const providerConfig = this.providerRequestConfigs.get(model.provider);
+            const apiKeyFromAuthStorage = await this.authStorage.getApiKey(model.provider, { includeFallback: false });
+            const apiKey = apiKeyFromAuthStorage ??
+                (providerConfig?.apiKey
+                    ? resolveConfigValueOrThrow(providerConfig.apiKey, `API key for provider "${model.provider}"`)
+                    : undefined);
+            const providerHeaders = resolveHeadersOrThrow(providerConfig?.headers, `provider "${model.provider}"`);
+            const modelHeaders = resolveHeadersOrThrow(this.modelRequestHeaders.get(this.getModelRequestKey(model.provider, model.id)), `model "${model.provider}/${model.id}"`);
+            let headers = model.headers || providerHeaders || modelHeaders
+                ? { ...model.headers, ...providerHeaders, ...modelHeaders }
+                : undefined;
+            if (providerConfig?.authHeader) {
+                if (!apiKey) {
+                    return { ok: false, error: `No API key found for "${model.provider}"` };
+                }
+                headers = { ...headers, Authorization: `Bearer ${apiKey}` };
+            }
+            return {
+                ok: true,
+                apiKey,
+                headers: headers && Object.keys(headers).length > 0 ? headers : undefined,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Return auth status for a provider, including request auth configured in models.json.
+     * This intentionally does not execute command-backed config values.
+     */
+    getProviderAuthStatus(provider) {
+        const authStatus = this.authStorage.getAuthStatus(provider);
+        if (authStatus.source) {
+            return authStatus;
+        }
+        const providerApiKey = this.providerRequestConfigs.get(provider)?.apiKey;
+        if (!providerApiKey) {
+            return authStatus;
+        }
+        if (providerApiKey.startsWith("!")) {
+            return { configured: true, source: "models_json_command" };
+        }
+        if (process.env[providerApiKey]) {
+            return { configured: true, source: "environment", label: providerApiKey };
+        }
+        return { configured: true, source: "models_json_key" };
+    }
+    /**
+     * Get display name for a provider.
+     */
+    getProviderDisplayName(provider) {
+        const registeredProvider = this.registeredProviders.get(provider);
+        const oauthProvider = this.authStorage.getOAuthProviders().find((p) => p.id === provider);
+        return (registeredProvider?.name ??
+            registeredProvider?.oauth?.name ??
+            oauthProvider?.name ??
+            BUILT_IN_PROVIDER_DISPLAY_NAMES[provider] ??
+            provider);
     }
     /**
      * Get API key for a provider.
      */
     async getApiKeyForProvider(provider) {
-        return this.authStorage.getApiKey(provider);
+        const apiKey = await this.authStorage.getApiKey(provider, { includeFallback: false });
+        if (apiKey !== undefined) {
+            return apiKey;
+        }
+        const providerApiKey = this.providerRequestConfigs.get(provider)?.apiKey;
+        return providerApiKey ? resolveConfigValueUncached(providerApiKey) : undefined;
     }
     /**
      * Check if a model is using OAuth credentials (subscription).
@@ -436,8 +605,9 @@ export class ModelRegistry {
      * If provider has oauth: registers OAuth provider for /login support.
      */
     registerProvider(providerName, config) {
-        this.registeredProviders.set(providerName, config);
+        this.validateProviderConfig(providerName, config);
         this.applyProviderConfig(providerName, config);
+        this.upsertRegisteredProvider(providerName, config);
     }
     /**
      * Unregister a previously registered provider.
@@ -452,9 +622,46 @@ export class ModelRegistry {
         if (!this.registeredProviders.has(providerName))
             return;
         this.registeredProviders.delete(providerName);
-        this.customProviderApiKeys.delete(providerName);
         this.refresh();
     }
+    /**
+     * Upsert a provider config into registeredProviders.
+     * If the provider is already registered, defined values in the incoming config
+     * override existing ones; undefined values are preserved from the stored config.
+     * If the provider is not registered, the incoming config is stored as-is.
+     */
+    upsertRegisteredProvider(providerName, config) {
+        const existing = this.registeredProviders.get(providerName);
+        if (!existing) {
+            this.registeredProviders.set(providerName, config);
+            return;
+        }
+        for (const k of Object.keys(config)) {
+            if (config[k] !== undefined) {
+                existing[k] = config[k];
+            }
+        }
+    }
+    validateProviderConfig(providerName, config) {
+        if (config.streamSimple && !config.api) {
+            throw new Error(`Provider ${providerName}: "api" is required when registering streamSimple.`);
+        }
+        if (!config.models || config.models.length === 0) {
+            return;
+        }
+        if (!config.baseUrl) {
+            throw new Error(`Provider ${providerName}: "baseUrl" is required when defining models.`);
+        }
+        if (!config.apiKey && !config.oauth) {
+            throw new Error(`Provider ${providerName}: "apiKey" or "oauth" is required when defining models.`);
+        }
+        for (const modelDef of config.models) {
+            const api = modelDef.api || config.api;
+            if (!api) {
+                throw new Error(`Provider ${providerName}, model ${modelDef.id}: no "api" specified.`);
+            }
+        }
+    }
     applyProviderConfig(providerName, config) {
         // Register OAuth provider if provided
         if (config.oauth) {
@@ -466,9 +673,6 @@ export class ModelRegistry {
             registerOAuthProvider(oauthProvider);
         }
         if (config.streamSimple) {
-            if (!config.api) {
-                throw new Error(`Provider ${providerName}: "api" is required when registering streamSimple.`);
-            }
             const streamSimple = config.streamSimple;
             registerApiProvider({
                 api: config.api,
@@ -476,49 +680,27 @@ export class ModelRegistry {
                 streamSimple,
             }, `provider:${providerName}`);
         }
-        // Store API key for auth resolution
-        if (config.apiKey) {
-            this.customProviderApiKeys.set(providerName, config.apiKey);
-        }
+        this.storeProviderRequestConfig(providerName, config);
         if (config.models && config.models.length > 0) {
             // Full replacement: remove existing models for this provider
             this.models = this.models.filter((m) => m.provider !== providerName);
-            // Validate required fields
-            if (!config.baseUrl) {
-                throw new Error(`Provider ${providerName}: "baseUrl" is required when defining models.`);
-            }
-            if (!config.apiKey && !config.oauth) {
-                throw new Error(`Provider ${providerName}: "apiKey" or "oauth" is required when defining models.`);
-            }
             // Parse and add new models
             for (const modelDef of config.models) {
                 const api = modelDef.api || config.api;
-                if (!api) {
-                    throw new Error(`Provider ${providerName}, model ${modelDef.id}: no "api" specified.`);
-                }
-                // Merge headers
-                const providerHeaders = resolveHeaders(config.headers);
-                const modelHeaders = resolveHeaders(modelDef.headers);
-                let headers = providerHeaders || modelHeaders ? { ...providerHeaders, ...modelHeaders } : undefined;
-                // If authHeader is true, add Authorization header
-                if (config.authHeader && config.apiKey) {
-                    const resolvedKey = resolveConfigValue(config.apiKey);
-                    if (resolvedKey) {
-                        headers = { ...headers, Authorization: `Bearer ${resolvedKey}` };
-                    }
-                }
+                this.storeModelHeaders(providerName, modelDef.id, modelDef.headers);
                 this.models.push({
                     id: modelDef.id,
                     name: modelDef.name,
                     api: api,
                     provider: providerName,
-                    baseUrl: config.baseUrl,
+                    baseUrl: modelDef.baseUrl ?? config.baseUrl,
                     reasoning: modelDef.reasoning,
+                    thinkingLevelMap: modelDef.thinkingLevelMap,
                     input: modelDef.input,
                     cost: modelDef.cost,
                     contextWindow: modelDef.contextWindow,
                     maxTokens: modelDef.maxTokens,
-                    headers,
+                    headers: undefined,
                     compat: modelDef.compat,
                 });
             }
@@ -530,16 +712,14 @@ export class ModelRegistry {
                 }
             }
         }
-        else if (config.baseUrl) {
-            // Override-only: update baseUrl/headers for existing models
-            const resolvedHeaders = resolveHeaders(config.headers);
+        else if (config.baseUrl || config.headers) {
+            // Override-only: update baseUrl for existing models. Request headers are resolved per request.
             this.models = this.models.map((m) => {
                 if (m.provider !== providerName)
                     return m;
                 return {
                     ...m,
                     baseUrl: config.baseUrl ?? m.baseUrl,
-                    headers: resolvedHeaders ? { ...m.headers, ...resolvedHeaders } : m.headers,
                 };
             });
         }