@code-yeongyu/senpi 2026.7.14 → 2026.7.16-2

package/dist/core/model-registry.js

@@ -1,997 +1,123 @@
-/**
- * Model registry - manages built-in and custom models, provides API key resolution.
- */
-import { getModels, getProviders, registerApiProvider, resetApiProviders, } from "@earendil-works/pi-ai/compat";
-import { registerOAuthProvider, resetOAuthProviders } from "@earendil-works/pi-ai/oauth";
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { Type } from "typebox";
-import { Compile } from "typebox/compile";
+import { join } from "node:path";
 import { getAgentDir } from "../config.js";
-import { stripJsonComments } from "../utils/json.js";
-import { normalizePath } from "../utils/paths.js";
+import { AuthStorage } from "./auth-storage.js";
+import { ModelRuntime as DefaultModelRuntime } from "./model-runtime.js";
 import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "./provider-display-names.js";
-import { getConfigValueEnvVarNames, isCommandConfigValue, isConfigValueConfigured, 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({
-    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 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),
-    max: Type.Optional(ThinkingLevelMapValueSchema),
-});
-const ChatTemplateKwargScalarSchema = Type.Union([Type.String(), Type.Number(), Type.Boolean(), Type.Null()]);
-const ChatTemplateKwargVariableSchema = Type.Object({
-    $var: Type.Union([Type.Literal("thinking.enabled"), Type.Literal("thinking.effort")]),
-    omitWhenOff: Type.Optional(Type.Boolean()),
-});
-const ChatTemplateKwargSchema = Type.Union([ChatTemplateKwargScalarSchema, ChatTemplateKwargVariableSchema]);
-const OpenAICompletionsCompatSchema = Type.Object({
-    supportsStore: Type.Optional(Type.Boolean()),
-    supportsDeveloperRole: Type.Optional(Type.Boolean()),
-    supportsReasoningEffort: Type.Optional(Type.Boolean()),
-    supportsUsageInStreaming: Type.Optional(Type.Boolean()),
-    maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
-    requiresToolResultName: Type.Optional(Type.Boolean()),
-    requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
-    requiresThinkingAsText: Type.Optional(Type.Boolean()),
-    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("chat-template"),
-        Type.Literal("qwen-chat-template"),
-        Type.Literal("string-thinking"),
-        Type.Literal("ant-ling"),
-    ])),
-    chatTemplateKwargs: Type.Optional(Type.Record(Type.String(), ChatTemplateKwargSchema)),
-    cacheControlFormat: Type.Optional(Type.Literal("anthropic")),
-    openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
-    vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema),
-    supportsStrictMode: Type.Optional(Type.Boolean()),
-    toolCallFormat: Type.Optional(Type.Union([
-        Type.Literal("hermes"),
-        Type.Literal("gemma4"),
-        Type.Literal("gemma4-delimiter"),
-        Type.Literal("xml"),
-        Type.Literal("yaml-xml"),
-    ])),
-    supportsLongCacheRetention: Type.Optional(Type.Boolean()),
-});
-const OpenAIResponsesCompatSchema = Type.Object({
-    supportsDeveloperRole: Type.Optional(Type.Boolean()),
-    sendSessionIdHeader: Type.Optional(Type.Boolean()),
-    supportsLongCacheRetention: Type.Optional(Type.Boolean()),
-    supportsWebSocket: Type.Optional(Type.Boolean()),
-    supportsWebSearchPreview: Type.Optional(Type.Boolean()),
-    supportsToolSearch: Type.Optional(Type.Boolean()),
-});
-const AnthropicMessagesCompatSchema = Type.Object({
-    supportsEagerToolInputStreaming: Type.Optional(Type.Boolean()),
-    supportsLongCacheRetention: Type.Optional(Type.Boolean()),
-    supportsDisabledThinking: Type.Optional(Type.Boolean()),
-    sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
-    supportsCacheControlOnTools: Type.Optional(Type.Boolean()),
-    supportsToolChoice: Type.Optional(Type.Boolean()),
-    supportsForcedToolChoice: Type.Optional(Type.Boolean()),
-    forceAdaptiveThinking: Type.Optional(Type.Boolean()),
-    supportsToolReferences: Type.Optional(Type.Boolean()),
-});
-const ProviderCompatSchema = Type.Union([
-    OpenAICompletionsCompatSchema,
-    OpenAIResponsesCompatSchema,
-    AnthropicMessagesCompatSchema,
-]);
-const ModelCostRatesSchema = {
-    input: Type.Number(),
-    output: Type.Number(),
-    cacheRead: Type.Number(),
-    cacheWrite: Type.Number(),
-};
-const ModelCostTierSchema = Type.Object({
-    inputTokensAbove: Type.Number(),
-    ...ModelCostRatesSchema,
-});
-const ModelCostSchema = Type.Object({
-    ...ModelCostRatesSchema,
-    tiers: Type.Optional(Type.Array(ModelCostTierSchema)),
-});
-// Schema for custom model definition
-// Most fields are optional with sensible defaults for local models (Ollama, LM Studio, etc.)
-const ExtraBodySchema = Type.Record(Type.String(), Type.Unknown());
-const ServiceTierSchema = Type.Union([Type.Literal("auto"), Type.Literal("flex"), Type.Literal("priority")]);
-const CacheRetentionSchema = Type.Union([Type.Literal("none"), Type.Literal("short"), Type.Literal("long")]);
-const ModelDefinitionSchema = Type.Object({
-    id: Type.String({ minLength: 1 }),
-    name: Type.Optional(Type.String({ minLength: 1 })),
-    upstreamModelId: Type.Optional(Type.String({ minLength: 1 })),
-    serviceTier: Type.Optional(ServiceTierSchema),
-    promptPreset: Type.Optional(Type.String({ minLength: 1 })),
-    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"), Type.Literal("video")]))),
-    cost: Type.Optional(ModelCostSchema),
-    contextWindow: Type.Optional(Type.Number()),
-    maxTokens: Type.Optional(Type.Number()),
-    headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-    extraBody: Type.Optional(ExtraBodySchema),
-    cacheRetention: Type.Optional(CacheRetentionSchema),
-    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 })),
-    promptPreset: Type.Optional(Type.String({ minLength: 1 })),
-    reasoning: Type.Optional(Type.Boolean()),
-    thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
-    thinkingLevelMapMode: Type.Optional(Type.Union([Type.Literal("merge"), Type.Literal("replace")])),
-    input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image"), Type.Literal("video")]))),
-    cost: Type.Optional(Type.Object({
-        input: Type.Optional(Type.Number()),
-        output: Type.Optional(Type.Number()),
-        cacheRead: Type.Optional(Type.Number()),
-        cacheWrite: Type.Optional(Type.Number()),
-        tiers: Type.Optional(Type.Array(ModelCostTierSchema)),
-    })),
-    contextWindow: Type.Optional(Type.Number()),
-    maxTokens: Type.Optional(Type.Number()),
-    headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-    extraBody: Type.Optional(ExtraBodySchema),
-    cacheRetention: Type.Optional(CacheRetentionSchema),
-    compat: Type.Optional(ProviderCompatSchema),
-});
-const ProviderConfigSchema = Type.Object({
-    name: Type.Optional(Type.String({ minLength: 1 })),
-    disabled: Type.Optional(Type.Boolean()),
-    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())),
-    extraBody: Type.Optional(ExtraBodySchema),
-    cacheRetention: Type.Optional(CacheRetentionSchema),
-    compat: Type.Optional(ProviderCompatSchema),
-    authHeader: Type.Optional(Type.Boolean()),
-    whitelist: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-    blacklist: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-    models: Type.Optional(Type.Array(ModelDefinitionSchema)),
-    modelOverrides: Type.Optional(Type.Record(Type.String(), ModelOverrideSchema)),
-});
-const ModelsConfigSchema = Type.Object({
-    disabledProviders: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-    providers: Type.Record(Type.String(), ProviderConfigSchema),
-});
-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";
-}
-function emptyCustomModelsResult(error) {
-    return {
-        models: [],
-        overrides: new Map(),
-        modelOverrides: new Map(),
-        disabledProviders: new Set(),
-        modelWhitelists: new Map(),
-        modelBlacklists: new Map(),
-        error,
-    };
-}
-function mergeCompat(baseCompat, overrideCompat) {
-    if (!overrideCompat)
-        return baseCompat;
-    const base = baseCompat;
-    const override = overrideCompat;
-    const merged = { ...base, ...override };
-    const baseCompletions = base;
-    const overrideCompletions = override;
-    const mergedCompletions = merged;
-    if (baseCompletions?.openRouterRouting || overrideCompletions.openRouterRouting) {
-        mergedCompletions.openRouterRouting = {
-            ...baseCompletions?.openRouterRouting,
-            ...overrideCompletions.openRouterRouting,
-        };
-    }
-    if (baseCompletions?.vercelGatewayRouting || overrideCompletions.vercelGatewayRouting) {
-        mergedCompletions.vercelGatewayRouting = {
-            ...baseCompletions?.vercelGatewayRouting,
-            ...overrideCompletions.vercelGatewayRouting,
-        };
-    }
-    if (baseCompletions?.chatTemplateKwargs || overrideCompletions.chatTemplateKwargs) {
-        mergedCompletions.chatTemplateKwargs = {
-            ...baseCompletions?.chatTemplateKwargs,
-            ...overrideCompletions.chatTemplateKwargs,
-        };
-    }
-    return merged;
-}
-/**
- * Deep merge a model override into a model.
- * Handles nested objects (cost, compat) by merging rather than replacing.
- */
-function applyModelOverride(model, override) {
-    const modelWithConfigMetadata = model;
-    const result = { ...modelWithConfigMetadata };
-    // Simple field overrides
-    if (override.name !== undefined)
-        result.name = override.name;
-    if (override.promptPreset !== undefined)
-        result.promptPreset = override.promptPreset;
-    if (override.reasoning !== undefined)
-        result.reasoning = override.reasoning;
-    if (override.thinkingLevelMap !== undefined) {
-        result.thinkingLevelMap =
-            override.thinkingLevelMapMode === "replace"
-                ? { ...override.thinkingLevelMap }
-                : { ...modelWithConfigMetadata.thinkingLevelMap, ...override.thinkingLevelMap };
-    }
-    if (override.input !== undefined)
-        result.input = override.input;
-    if (override.contextWindow !== undefined)
-        result.contextWindow = override.contextWindow;
-    if (override.maxTokens !== undefined)
-        result.maxTokens = override.maxTokens;
-    if (override.cacheRetention !== undefined)
-        result.cacheRetention = override.cacheRetention;
-    // Merge cost (partial override)
-    if (override.cost) {
-        result.cost = {
-            input: override.cost.input ?? model.cost.input,
-            output: override.cost.output ?? model.cost.output,
-            cacheRead: override.cost.cacheRead ?? model.cost.cacheRead,
-            cacheWrite: override.cost.cacheWrite ?? model.cost.cacheWrite,
-            tiers: override.cost.tiers ?? model.cost.tiers,
-        };
-    }
-    // Deep merge compat
-    result.compat = mergeCompat(model.compat, override.compat);
-    return result;
-}
+export { clearApiKeyCache } from "./provider-composer.js";
 /**
- * Model registry - loads and manages models, resolves API keys via AuthStorage.
+ * Synchronous compatibility facade exposed to extensions.
+ * Coding-agent internals use ModelRuntime directly.
  */
 export class ModelRegistry {
-    constructor(authStorage, modelsJsonPath) {
-        this.models = [];
-        this.providerRequestConfigs = new Map();
-        this.modelRequestHeaders = new Map();
-        this.modelRequestExtraBody = new Map();
-        this.modelRequestUpstreamIds = new Map();
-        this.modelRequestServiceTiers = new Map();
-        this.configModelOverrides = new Map();
-        this.registeredProviders = new Map();
-        this.loadError = undefined;
+    constructor(runtime, authStorage = AuthStorage.inMemory()) {
+        this.runtime = runtime;
         this.authStorage = authStorage;
-        this.modelsJsonPath = modelsJsonPath ? normalizePath(modelsJsonPath) : undefined;
-        this.loadModels();
     }
     static create(authStorage, modelsJsonPath = join(getAgentDir(), "models.json")) {
-        return new ModelRegistry(authStorage, modelsJsonPath);
+        return new ModelRegistry(DefaultModelRuntime.createSync({ credentials: authStorage, modelsPath: modelsJsonPath }), authStorage);
     }
     static inMemory(authStorage) {
-        return new ModelRegistry(authStorage, undefined);
+        return new ModelRegistry(DefaultModelRuntime.createSync({ credentials: authStorage, modelsPath: null }), authStorage);
+    }
+    get modelRuntime() {
+        return this.runtime;
     }
-    /**
-     * Reload models from disk (built-in + custom from models.json).
-     */
+    /** Reload models.json asynchronously. Await before making synchronous registry reads. */
     refresh() {
-        this.providerRequestConfigs.clear();
-        this.modelRequestHeaders.clear();
-        this.modelRequestExtraBody.clear();
-        this.modelRequestUpstreamIds.clear();
-        this.modelRequestServiceTiers.clear();
-        this.loadError = undefined;
-        // Ensure dynamic API/OAuth registrations are rebuilt from current provider state.
-        resetApiProviders();
-        resetOAuthProviders();
-        this.loadModels();
-        for (const [providerName, config] of this.registeredProviders.entries()) {
-            this.applyProviderConfig(providerName, config);
-        }
+        return this.runtime.reloadConfig();
     }
-    /**
-     * Get any error from loading models.json (undefined if no error).
-     */
     getError() {
-        return this.loadError;
+        return this.runtime.getError();
     }
-    loadModels() {
-        // Load custom models and overrides from models.json
-        const { models: customModels, overrides, modelOverrides, disabledProviders, modelWhitelists, modelBlacklists, error, } = this.modelsJsonPath ? this.loadCustomModels(this.modelsJsonPath) : emptyCustomModelsResult();
-        this.configModelOverrides = modelOverrides;
-        if (error) {
-            this.loadError = error;
-            // Keep built-in models even if custom models failed to load
-        }
-        const builtInModels = this.loadBuiltInModels(overrides, modelOverrides, disabledProviders, modelWhitelists, modelBlacklists);
-        let combined = this.mergeCustomModels(builtInModels, customModels);
-        // Let OAuth providers modify their models (e.g., update baseUrl)
-        for (const oauthProvider of this.authStorage.getOAuthProviders()) {
-            const cred = this.authStorage.get(oauthProvider.id);
-            if (cred?.type === "oauth" && oauthProvider.modifyModels) {
-                combined = oauthProvider.modifyModels(combined, cred);
-            }
-        }
-        this.models = combined;
+    getAll() {
+        return [...this.runtime.getModels()];
     }
-    /** Load built-in models and apply provider/model overrides */
-    loadBuiltInModels(overrides, modelOverrides, disabledProviders, modelWhitelists, modelBlacklists) {
-        return getProviders().flatMap((provider) => {
-            if (disabledProviders.has(provider)) {
+    getAvailable() {
+        if (this.runtime.hasAvailabilitySnapshot()) {
+            return [...this.runtime.getAvailableSnapshot()];
+        }
+        return this.runtime.getProviders().flatMap((provider) => {
+            if (!this.authStorage.hasAuth(provider.id) && !this.runtime.getProviderAuthStatus(provider.id).configured) {
                 return [];
             }
-            const models = getModels(provider);
-            const providerOverride = overrides.get(provider);
-            const perModelOverrides = modelOverrides.get(provider);
-            const whitelist = modelWhitelists.get(provider);
-            const blacklist = modelBlacklists.get(provider);
-            return models.flatMap((m) => {
-                if (whitelist && !whitelist.has(m.id))
-                    return [];
-                if (blacklist?.has(m.id))
-                    return [];
-                let model = m;
-                // Apply provider-level baseUrl/headers/compat override
-                if (providerOverride) {
-                    model = {
-                        ...model,
-                        baseUrl: providerOverride.baseUrl ?? model.baseUrl,
-                        compat: mergeCompat(model.compat, providerOverride.compat),
-                        cacheRetention: model.cacheRetention ?? providerOverride.cacheRetention,
-                    };
-                }
-                // Apply per-model override
-                const modelOverride = perModelOverrides?.get(m.id);
-                if (modelOverride) {
-                    model = applyModelOverride(model, modelOverride);
-                }
-                return [model];
-            });
+            const models = this.runtime.getModels(provider.id);
+            return [...(provider.filterModels?.(models, this.authStorage.get(provider.id)) ?? models)];
         });
     }
-    getConfiguredModelOverride(providerName, modelId) {
-        return this.configModelOverrides.get(providerName)?.get(modelId);
-    }
-    applyConfiguredModelOverride(providerName, model) {
-        const modelOverride = this.getConfiguredModelOverride(providerName, model.id);
-        return modelOverride ? applyModelOverride(model, modelOverride) : model;
-    }
-    /** Merge custom models into built-in list by provider+id (custom wins on conflicts). */
-    mergeCustomModels(builtInModels, customModels) {
-        const merged = [...builtInModels];
-        for (const customModel of customModels) {
-            const existingIndex = merged.findIndex((m) => m.provider === customModel.provider && m.id === customModel.id);
-            if (existingIndex >= 0) {
-                merged[existingIndex] = customModel;
-            }
-            else {
-                merged.push(customModel);
-            }
-        }
-        return merged;
-    }
-    loadCustomModels(modelsJsonPath) {
-        if (!existsSync(modelsJsonPath)) {
-            return emptyCustomModelsResult();
-        }
-        try {
-            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();
-            const disabledProviders = new Set(config.disabledProviders ?? []);
-            const modelWhitelists = new Map();
-            const modelBlacklists = new Map();
-            for (const [providerName, providerConfig] of Object.entries(config.providers)) {
-                if (providerConfig.disabled) {
-                    disabledProviders.add(providerName);
-                }
-                if (providerConfig.whitelist) {
-                    modelWhitelists.set(providerName, new Set(providerConfig.whitelist));
-                }
-                if (providerConfig.blacklist) {
-                    modelBlacklists.set(providerName, new Set(providerConfig.blacklist));
-                }
-                if (providerConfig.baseUrl || providerConfig.compat || providerConfig.cacheRetention) {
-                    overrides.set(providerName, {
-                        baseUrl: providerConfig.baseUrl,
-                        compat: providerConfig.compat,
-                        cacheRetention: providerConfig.cacheRetention,
-                    });
-                }
-                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);
-                        this.storeModelExtraBody(providerName, modelId, modelOverride.extraBody);
-                    }
-                }
-            }
-            return {
-                models: this.parseModels(config, disabledProviders, modelWhitelists, modelBlacklists),
-                overrides,
-                modelOverrides,
-                disabledProviders,
-                modelWhitelists,
-                modelBlacklists,
-                error: undefined,
-            };
-        }
-        catch (error) {
-            if (error instanceof SyntaxError) {
-                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: ${modelsJsonPath}`);
-        }
-    }
-    validateConfig(config) {
-        const builtInProviders = new Set(getProviders());
-        for (const [providerName, providerConfig] of Object.entries(config.providers)) {
-            if (providerConfig.disabled)
-                continue;
-            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, headers, compat, modelOverrides, extraBody, or some combination.
-                if (!providerConfig.baseUrl &&
-                    !providerConfig.headers &&
-                    !providerConfig.compat &&
-                    !providerConfig.cacheRetention &&
-                    !hasModelOverrides &&
-                    !providerConfig.extraBody &&
-                    !providerConfig.whitelist &&
-                    !providerConfig.blacklist) {
-                    throw new Error(`Provider ${providerName}: must specify "baseUrl", "headers", "compat", "cacheRetention", "modelOverrides", "extraBody", or "models".`);
-                }
-            }
-            else if (!isBuiltIn) {
-                // Non-built-in providers with custom models require an endpoint.
-                // Auth can come from auth.json, --api-key, or provider request config.
-                if (!providerConfig.baseUrl) {
-                    throw new Error(`Provider ${providerName}: "baseUrl" 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 && !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)
-                if (modelDef.contextWindow !== undefined && modelDef.contextWindow <= 0)
-                    throw new Error(`Provider ${providerName}, model ${modelDef.id}: invalid contextWindow`);
-                if (modelDef.maxTokens !== undefined && modelDef.maxTokens <= 0)
-                    throw new Error(`Provider ${providerName}, model ${modelDef.id}: invalid maxTokens`);
-            }
-        }
-    }
-    parseModels(config, disabledProviders, modelWhitelists, modelBlacklists) {
-        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)) {
-            if (disabledProviders.has(providerName))
-                continue;
-            const modelDefs = providerConfig.models ?? [];
-            if (modelDefs.length === 0)
-                continue; // Override-only, no custom models
-            const builtInDefaults = getBuiltInDefaults(providerName);
-            const whitelist = modelWhitelists.get(providerName);
-            const blacklist = modelBlacklists.get(providerName);
-            for (const modelDef of modelDefs) {
-                if (whitelist && !whitelist.has(modelDef.id))
-                    continue;
-                if (blacklist?.has(modelDef.id))
-                    continue;
-                const api = modelDef.api ?? providerConfig.api ?? builtInDefaults?.api;
-                if (!api)
-                    continue;
-                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);
-                this.storeModelExtraBody(providerName, modelDef.id, modelDef.extraBody);
-                this.storeModelUpstreamId(providerName, modelDef.id, modelDef.upstreamModelId);
-                this.storeModelServiceTier(providerName, modelDef.id, modelDef.serviceTier);
-                const defaultCost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-                models.push({
-                    id: modelDef.id,
-                    name: modelDef.name ?? modelDef.id,
-                    promptPreset: modelDef.promptPreset,
-                    api: api,
-                    provider: providerName,
-                    baseUrl,
-                    reasoning: modelDef.reasoning ?? false,
-                    cacheRetention: modelDef.cacheRetention ?? providerConfig.cacheRetention,
-                    thinkingLevelMap: modelDef.thinkingLevelMap,
-                    input: (modelDef.input ?? ["text"]),
-                    cost: modelDef.cost ?? defaultCost,
-                    contextWindow: modelDef.contextWindow ?? 128000,
-                    maxTokens: modelDef.maxTokens ?? 16384,
-                    headers: undefined,
-                    compat,
-                });
-            }
-        }
-        return models;
-    }
-    /**
-     * Get all models (built-in + custom).
-     * If models.json had errors, returns only built-in models.
-     */
-    getAll() {
-        return this.models;
-    }
-    /**
-     * Get only models that have auth configured.
-     * This is a fast check that doesn't refresh OAuth tokens.
-     */
-    getAvailable() {
-        return this.models.filter((m) => this.hasConfiguredAuth(m));
-    }
-    /**
-     * Find a model by provider and ID.
-     */
     find(provider, modelId) {
-        return this.models.find((m) => m.provider === provider && m.id === modelId);
-    }
-    getUpstreamModelId(model) {
-        return this.modelRequestUpstreamIds.get(this.getModelRequestKey(model.provider, model.id));
+        return this.runtime.getModel(provider, modelId);
     }
-    /**
-     * Get API key for a model.
-     */
     hasConfiguredAuth(model) {
-        const providerApiKey = this.providerRequestConfigs.get(model.provider)?.apiKey;
-        return (this.authStorage.hasAuth(model.provider) ||
-            (providerApiKey !== undefined && isConfigValueConfigured(providerApiKey)));
+        return this.authStorage.hasAuth(model.provider) || this.runtime.getProviderAuthStatus(model.provider).configured;
     }
-    getModelRequestKey(provider, modelId) {
-        return `${provider}:${modelId}`;
-    }
-    storeProviderRequestConfig(providerName, config, preservedApiKey) {
-        const apiKey = config.apiKey ?? preservedApiKey;
-        if (!apiKey && !config.headers && !config.extraBody && config.authHeader !== true) {
-            this.providerRequestConfigs.delete(providerName);
-            return;
-        }
-        this.providerRequestConfigs.set(providerName, {
-            apiKey,
-            headers: config.headers,
-            extraBody: config.extraBody,
-            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);
-    }
-    storeModelExtraBody(providerName, modelId, extraBody) {
-        const key = this.getModelRequestKey(providerName, modelId);
-        if (!extraBody || Object.keys(extraBody).length === 0) {
-            this.modelRequestExtraBody.delete(key);
-            return;
-        }
-        this.modelRequestExtraBody.set(key, extraBody);
-    }
-    storeModelUpstreamId(providerName, modelId, upstreamModelId) {
-        const key = this.getModelRequestKey(providerName, modelId);
-        if (!upstreamModelId) {
-            this.modelRequestUpstreamIds.delete(key);
-            return;
-        }
-        this.modelRequestUpstreamIds.set(key, upstreamModelId);
-    }
-    storeModelServiceTier(providerName, modelId, serviceTier) {
-        const key = this.getModelRequestKey(providerName, modelId);
-        if (!serviceTier) {
-            this.modelRequestServiceTiers.delete(key);
-            return;
-        }
-        this.modelRequestServiceTiers.set(key, serviceTier);
-    }
-    clearModelRequestConfigForProvider(providerName) {
-        const prefix = `${providerName}:`;
-        for (const key of this.modelRequestHeaders.keys()) {
-            if (key.startsWith(prefix)) {
-                this.modelRequestHeaders.delete(key);
-            }
-        }
-        for (const key of this.modelRequestExtraBody.keys()) {
-            if (key.startsWith(prefix)) {
-                this.modelRequestExtraBody.delete(key);
-            }
-        }
-        for (const key of this.modelRequestUpstreamIds.keys()) {
-            if (key.startsWith(prefix)) {
-                this.modelRequestUpstreamIds.delete(key);
-            }
-        }
-        for (const key of this.modelRequestServiceTiers.keys()) {
-            if (key.startsWith(prefix)) {
-                this.modelRequestServiceTiers.delete(key);
-            }
-        }
+    getUpstreamModelId(model) {
+        return this.runtime.getCompatibilityRequestConfig(model).upstreamModelId;
     }
-    /**
-     * Get API key and request headers for a model.
-     */
     async getApiKeyAndHeaders(model) {
         try {
-            const providerConfig = this.providerRequestConfigs.get(model.provider);
-            const providerEnv = this.authStorage.getProviderEnv(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}"`, providerEnv)
-                    : undefined);
-            const modelRequestKey = this.getModelRequestKey(model.provider, model.id);
-            const providerHeaders = resolveHeadersOrThrow(providerConfig?.headers, `provider "${model.provider}"`, providerEnv);
-            const modelHeaders = resolveHeadersOrThrow(this.modelRequestHeaders.get(modelRequestKey), `model "${model.provider}/${model.id}"`, providerEnv);
-            let headers = model.headers || providerHeaders || modelHeaders
-                ? { ...model.headers, ...providerHeaders, ...modelHeaders }
-                : undefined;
-            if (providerConfig?.authHeader) {
-                if (!apiKey) {
+            const resolution = await this.runtime.getAuth(model);
+            const compatibility = this.runtime.getCompatibilityRequestConfig(model, resolution?.env);
+            if (!resolution) {
+                if (compatibility.authHeader) {
                     return { ok: false, error: `No API key found for "${model.provider}"` };
                 }
-                headers = { ...headers, Authorization: `Bearer ${apiKey}` };
-            }
-            const providerExtraBody = providerConfig?.extraBody;
-            const modelExtraBody = this.modelRequestExtraBody.get(modelRequestKey);
-            const extraBody = providerExtraBody || modelExtraBody ? { ...providerExtraBody, ...modelExtraBody } : undefined;
-            const upstreamModelId = this.modelRequestUpstreamIds.get(modelRequestKey);
-            const serviceTier = this.modelRequestServiceTiers.get(modelRequestKey);
-            const resolved = { ok: true };
-            if (apiKey !== undefined) {
-                resolved.apiKey = apiKey;
-            }
-            if (headers && Object.keys(headers).length > 0) {
-                resolved.headers = headers;
-            }
-            if (extraBody && Object.keys(extraBody).length > 0) {
-                resolved.extraBody = extraBody;
-            }
-            if (upstreamModelId !== undefined) {
-                resolved.upstreamModelId = upstreamModelId;
-            }
-            if (serviceTier !== undefined) {
-                resolved.serviceTier = serviceTier;
-            }
-            if (providerEnv && Object.keys(providerEnv).length > 0) {
-                resolved.env = providerEnv;
+                const headers = compatibility.headers
+                    ? Object.fromEntries(Object.entries(compatibility.headers).filter((entry) => entry[1] !== null))
+                    : undefined;
+                return { ok: true, headers, extraBody: compatibility.extraBody };
             }
-            return resolved;
+            const headers = resolution.auth.headers
+                ? Object.fromEntries(Object.entries(resolution.auth.headers).filter((entry) => entry[1] !== null))
+                : undefined;
+            return {
+                ok: true,
+                apiKey: resolution.auth.apiKey,
+                headers,
+                extraBody: compatibility.extraBody,
+                upstreamModelId: compatibility.upstreamModelId,
+                serviceTier: compatibility.serviceTier,
+                env: resolution.env,
+            };
         }
         catch (error) {
+            const cause = error instanceof Error ? error.cause : undefined;
+            const message = cause instanceof Error ? cause.message : error instanceof Error ? error.message : String(error);
             return {
                 ok: false,
-                error: error instanceof Error ? error.message : String(error),
+                error: message === "authHeader requires a resolved API key"
+                    ? `No API key found for "${model.provider}"`
+                    : message,
             };
         }
     }
-    /**
-     * 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 (isCommandConfigValue(providerApiKey)) {
-            return { configured: true, source: "models_json_command" };
-        }
-        const envVarNames = getConfigValueEnvVarNames(providerApiKey);
-        if (envVarNames.length > 0) {
-            return isConfigValueConfigured(providerApiKey)
-                ? { configured: true, source: "environment", label: envVarNames.join(", ") }
-                : { configured: false };
-        }
-        return { configured: true, source: "models_json_key" };
+        return this.runtime.getProviderAuthStatus(provider);
     }
-    /**
-     * 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);
+        return this.runtime.getProvider(provider)?.name ?? BUILT_IN_PROVIDER_DISPLAY_NAMES[provider] ?? provider;
     }
-    /**
-     * Get API key for a provider.
-     */
     async getApiKeyForProvider(provider) {
-        const apiKey = await this.authStorage.getApiKey(provider);
-        if (apiKey !== undefined) {
-            return apiKey;
+        try {
+            return (await this.runtime.getAuth(provider))?.auth.apiKey;
+        }
+        catch {
+            return undefined;
         }
-        const providerApiKey = this.providerRequestConfigs.get(provider)?.apiKey;
-        return providerApiKey
-            ? resolveConfigValueUncached(providerApiKey, this.authStorage.getProviderEnv(provider))
-            : undefined;
     }
-    /**
-     * Check if a model is using OAuth credentials (subscription).
-     */
     isUsingOAuth(model) {
-        const cred = this.authStorage.get(model.provider);
-        return cred?.type === "oauth";
+        return this.authStorage.get(model.provider)?.type === "oauth" || this.runtime.isUsingOAuth(model.provider);
     }
-    /**
-     * Register a provider dynamically (from extensions).
-     *
-     * If provider has models: replaces all existing models for this provider.
-     * If provider has only baseUrl/headers: overrides existing models' URLs.
-     * If provider has oauth: registers OAuth provider for /login support.
-     */
     registerProvider(providerName, config) {
-        this.validateProviderConfig(providerName, config);
-        this.applyProviderConfig(providerName, config);
-        this.upsertRegisteredProvider(providerName, config);
+        this.runtime.registerProvider(providerName, config);
     }
-    /**
-     * Unregister a previously registered provider.
-     *
-     * Removes the provider from the registry and reloads models from disk so that
-     * built-in models overridden by this provider are restored to their original state.
-     * Also resets dynamic OAuth and API stream registrations before reapplying
-     * remaining dynamic providers.
-     * Has no effect if the provider was never registered.
-     */
     unregisterProvider(providerName) {
-        if (!this.registeredProviders.has(providerName))
-            return;
-        this.registeredProviders.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;
-        }
-        const next = { ...existing };
-        if (config.name !== undefined)
-            next.name = config.name;
-        if (config.baseUrl !== undefined)
-            next.baseUrl = config.baseUrl;
-        if (config.apiKey !== undefined)
-            next.apiKey = config.apiKey;
-        if (config.api !== undefined)
-            next.api = config.api;
-        if (config.streamSimple !== undefined)
-            next.streamSimple = config.streamSimple;
-        if (config.oauth !== undefined)
-            next.oauth = config.oauth;
-        if (config.models !== undefined)
-            next.models = config.models;
-        if (config.headers !== undefined) {
-            next.headers = config.headers;
-        }
-        else {
-            delete next.headers;
-        }
-        if (config.extraBody !== undefined) {
-            next.extraBody = config.extraBody;
-        }
-        else {
-            delete next.extraBody;
-        }
-        if (config.cacheRetention !== undefined) {
-            next.cacheRetention = config.cacheRetention;
-        }
-        else {
-            delete next.cacheRetention;
-        }
-        if (config.authHeader !== undefined) {
-            next.authHeader = config.authHeader;
-        }
-        else {
-            delete next.authHeader;
-        }
-        this.registeredProviders.set(providerName, next);
+        this.runtime.unregisterProvider(providerName);
     }
-    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.`);
-            }
-        }
+    getRegisteredProviderConfig(providerName) {
+        return this.runtime.getRegisteredProviderConfig(providerName);
     }
-    applyProviderConfig(providerName, config) {
-        // Register OAuth provider if provided
-        if (config.oauth) {
-            // Ensure the OAuth provider ID matches the provider name
-            const oauthProvider = {
-                ...config.oauth,
-                id: providerName,
-            };
-            registerOAuthProvider(oauthProvider);
-        }
-        if (config.streamSimple) {
-            const streamSimple = config.streamSimple;
-            registerApiProvider({
-                api: config.api,
-                stream: (model, context, options) => streamSimple(model, context, options),
-                streamSimple,
-            }, `provider:${providerName}`);
-        }
-        this.storeProviderRequestConfig(providerName, config, this.registeredProviders.get(providerName)?.apiKey);
-        if (config.models && config.models.length > 0) {
-            // Full replacement: remove existing models for this provider
-            this.models = this.models.filter((m) => m.provider !== providerName);
-            this.clearModelRequestConfigForProvider(providerName);
-            // Parse and add new models
-            for (const modelDef of config.models) {
-                const api = modelDef.api || config.api;
-                const modelOverride = this.getConfiguredModelOverride(providerName, modelDef.id);
-                const headers = modelDef.headers || modelOverride?.headers
-                    ? { ...modelDef.headers, ...modelOverride?.headers }
-                    : undefined;
-                const extraBody = modelDef.extraBody || modelOverride?.extraBody
-                    ? { ...modelDef.extraBody, ...modelOverride?.extraBody }
-                    : undefined;
-                this.storeModelHeaders(providerName, modelDef.id, headers);
-                this.storeModelExtraBody(providerName, modelDef.id, extraBody);
-                this.storeModelUpstreamId(providerName, modelDef.id, modelDef.upstreamModelId);
-                this.storeModelServiceTier(providerName, modelDef.id, modelDef.serviceTier);
-                const model = this.applyConfiguredModelOverride(providerName, {
-                    id: modelDef.id,
-                    name: modelDef.name,
-                    api: api,
-                    provider: providerName,
-                    baseUrl: modelDef.baseUrl ?? config.baseUrl,
-                    reasoning: modelDef.reasoning,
-                    cacheRetention: modelDef.cacheRetention ?? config.cacheRetention,
-                    thinkingLevelMap: modelDef.thinkingLevelMap,
-                    input: modelDef.input,
-                    cost: modelDef.cost,
-                    contextWindow: modelDef.contextWindow,
-                    maxTokens: modelDef.maxTokens,
-                    headers: undefined,
-                    compat: modelDef.compat,
-                });
-                this.models.push(model);
-            }
-            // Apply OAuth modifyModels if credentials exist (e.g., to update baseUrl)
-            if (config.oauth?.modifyModels) {
-                const cred = this.authStorage.get(providerName);
-                if (cred?.type === "oauth") {
-                    this.models = config.oauth.modifyModels(this.models, cred);
-                }
-            }
-        }
-        else if (config.baseUrl || config.headers || config.extraBody || config.cacheRetention) {
-            // Override-only: update baseUrl for existing models. Request headers and extraBody are resolved per request.
-            this.models = this.models.map((m) => {
-                if (m.provider !== providerName)
-                    return m;
-                return {
-                    ...m,
-                    baseUrl: config.baseUrl ?? m.baseUrl,
-                    cacheRetention: m.cacheRetention ?? config.cacheRetention,
-                };
-            });
-        }
+    getRegisteredProviderIds() {
+        return this.runtime.getRegisteredProviderIds();
     }
 }
 //# sourceMappingURL=model-registry.js.map