indusagi-coding-agent 0.1.37 → 0.1.39

package/dist/core/model-registry.js

@@ -1,103 +1,3 @@
-/**
- * Model Registry - Central management of AI models and provider configuration
- *
- * Purpose:
- * Manages all available AI models (built-in + custom), handles provider configuration,
- * and resolves API keys through multiple sources (env vars, commands, OAuth, auth storage).
- *
- * Architecture:
- * - Loads built-in models from indusagi/ai package
- * - Optionally loads custom models from models.json config file
- * - Supports provider overrides (baseUrl, headers, apiKey)
- * - Integrates with AuthStorage for credential management
- * - Supports dynamic provider registration from extensions
- *
- * Key Features:
- * - API key resolution from environment variables or shell commands
- * - Custom model definitions via models.json with full schema validation
- * - Provider override support (baseUrl, headers without replacing models)
- * - OAuth provider integration for subscription-based services
- * - Error handling with detailed validation messages
- * - Command result caching for performance
- *
- * Configuration Sources (in order of priority):
- * 1. models.json in agent directory (custom models + provider overrides)
- * 2. Built-in models from indusagi/ai
- * 3. OAuth providers via AuthStorage
- * 4. Environment variables for API keys
- *
- * API Key Resolution:
- * - Values starting with "!" are treated as shell commands
- * - Other values checked against environment variables first
- * - Falls back to literal value if env var not found
- * - Commands cached for process lifetime to avoid re-execution
- *
- * Built-in Providers Supported:
- * - OpenAI (gpt-4, gpt-4-turbo, gpt-3.5-turbo, etc.)
- * - Anthropic (claude-3-opus, claude-3-sonnet, claude-3-haiku, etc.)
- * - Google (gemini-pro, gemini-1.5, etc.)
- * - Mistral (mistral-large, mistral-medium, etc.)
- * - OpenRouter (routing to 200+ models)
- * - Custom providers via models.json
- *
- * Example models.json:
- * ```json
- * {
- *   "providers": {
- *     "custom-local": {
- *       "baseUrl": "http://localhost:8000/v1",
- *       "apiKey": "CUSTOM_API_KEY",
- *       "models": [{
- *         "id": "local-model",
- *         "name": "Local Model",
- *         "api": "openai",
- *         "reasoning": false,
- *         "input": ["text"],
- *         "cost": {"input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0},
- *         "contextWindow": 8192,
- *         "maxTokens": 4096
- *       }]
- *     }
- *   }
- * }
- * ```
- *
- * Usage:
- * ```typescript
- * const registry = new ModelRegistry(authStorage);
- *
- * // Get all available models
- * const allModels = registry.getAll();
- *
- * // Get only models with configured auth
- * const available = registry.getAvailable();
- *
- * // Find specific model
- * const model = registry.find("openai", "gpt-4");
- *
- * // Get API key for model
- * const apiKey = await registry.getApiKey(model);
- *
- * // Register custom provider from extension
- * registry.registerProvider("my-provider", {
- *   baseUrl: "https://api.example.com",
- *   apiKey: "EXAMPLE_API_KEY",
- *   models: [...]
- * });
- *
- * // Reload models from disk
- * registry.refresh();
- * ```
- *
- * Error Handling:
- * - Invalid models.json schema returns detailed error messages
- * - Validation failures include field name and error description
- * - Built-in models loaded even if custom models fail
- * - Use getError() to check for loading issues
- *
- * Based on model registry from indusagi-agent
- * Original: https://github.com/varunisrani/indusagi-ts/vendor/indusagi-agent/src/model-registry.ts
- */
 import { getModels, getProviders, registerApiProvider, registerOAuthProvider, } from "indusagi/ai";
 import { Type } from "@sinclair/typebox";
 import AjvModule from "ajv";
@@ -106,12 +6,10 @@ import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { getAgentDir } from "../config.js";
 const Ajv = AjvModule.default || AjvModule;
-// Schema for OpenRouter routing preferences
 const OpenRouterRoutingSchema = Type.Object({
     only: Type.Optional(Type.Array(Type.String())),
     order: Type.Optional(Type.Array(Type.String())),
 });
-// Schema for OpenAI compatibility settings
 const OpenAICompletionsCompatSchema = Type.Object({
     supportsStore: Type.Optional(Type.Boolean()),
     supportsDeveloperRole: Type.Optional(Type.Boolean()),
@@ -125,11 +23,8 @@ const OpenAICompletionsCompatSchema = Type.Object({
     thinkingFormat: Type.Optional(Type.Union([Type.Literal("openai"), Type.Literal("zai")])),
     openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
 });
-const OpenAIResponsesCompatSchema = Type.Object({
-// Reserved for future use
-});
+const OpenAIResponsesCompatSchema = Type.Object({});
 const OpenAICompatSchema = Type.Union([OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema]);
-// Schema for custom model definition
 const ModelDefinitionSchema = Type.Object({
     id: Type.String({ minLength: 1 }),
     name: Type.String({ minLength: 1 }),
@@ -158,49 +53,39 @@ const ProviderConfigSchema = Type.Object({
 const ModelsConfigSchema = Type.Object({
     providers: Type.Record(Type.String(), ProviderConfigSchema),
 });
+const commandResultCache = new Map();
 function emptyCustomModelsResult(error) {
     return { models: [], replacedProviders: new Set(), overrides: new Map(), error };
 }
-// Cache for shell command results (persists for process lifetime)
-const commandResultCache = new Map();
-/**
- * Resolve a config value (API key, header value, etc.) to an actual value.
- * - If starts with "!", executes the rest as a shell command and uses stdout (cached)
- * - Otherwise checks environment variable first, then treats as literal (not cached)
- */
-function resolveConfigValue(config) {
-    if (config.startsWith("!")) {
-        return executeCommand(config);
-    }
-    const envValue = process.env[config];
-    return envValue || config;
-}
 function executeCommand(commandConfig) {
     if (commandResultCache.has(commandConfig)) {
         return commandResultCache.get(commandConfig);
     }
     const command = commandConfig.slice(1);
-    let result;
+    let output;
     try {
-        const output = execSync(command, {
+        output = execSync(command, {
             encoding: "utf-8",
             timeout: 10000,
             stdio: ["ignore", "pipe", "ignore"],
-        });
-        result = output.trim() || undefined;
+        }).trim() || undefined;
     }
     catch {
-        result = undefined;
+        output = undefined;
     }
-    commandResultCache.set(commandConfig, result);
-    return result;
+    commandResultCache.set(commandConfig, output);
+    return output;
+}
+function resolveConfigValue(config) {
+    if (config.startsWith("!")) {
+        return executeCommand(config);
+    }
+    return process.env[config] || config;
 }
-/**
- * Resolve all header values using the same resolution logic as API keys.
- */
 function resolveHeaders(headers) {
-    if (!headers)
+    if (!headers) {
         return undefined;
+    }
     const resolved = {};
     for (const [key, value] of Object.entries(headers)) {
         const resolvedValue = resolveConfigValue(value);
@@ -210,13 +95,165 @@ function resolveHeaders(headers) {
     }
     return Object.keys(resolved).length > 0 ? resolved : undefined;
 }
-/** Clear the config value command cache. Exported for testing. */
+function validateSchema(config, filePath) {
+    const ajv = new Ajv();
+    const validate = ajv.compile(ModelsConfigSchema);
+    if (validate(config)) {
+        return undefined;
+    }
+    const errors = validate.errors?.map((error) => `  - ${error.instancePath || "root"}: ${error.message}`).join("\n") ||
+        "Unknown schema error";
+    return `Invalid models.json schema:\n${errors}\n\nFile: ${filePath}`;
+}
+function validateModelsConfig(config) {
+    for (const [providerName, providerConfig] of Object.entries(config.providers)) {
+        const models = providerConfig.models ?? [];
+        if (models.length === 0) {
+            if (!providerConfig.baseUrl) {
+                throw new Error(`Provider ${providerName}: must specify either "baseUrl" (for override) or "models" (for replacement).`);
+            }
+            continue;
+        }
+        if (!providerConfig.baseUrl) {
+            throw new Error(`Provider ${providerName}: "baseUrl" is required when defining custom models.`);
+        }
+        if (!providerConfig.apiKey) {
+            throw new Error(`Provider ${providerName}: "apiKey" is required when defining custom models.`);
+        }
+        for (const modelDef of models) {
+            if (!providerConfig.api && !modelDef.api) {
+                throw new Error(`Provider ${providerName}, model ${modelDef.id}: no "api" specified. Set at provider or model level.`);
+            }
+            if (modelDef.contextWindow <= 0) {
+                throw new Error(`Provider ${providerName}, model ${modelDef.id}: invalid contextWindow`);
+            }
+            if (modelDef.maxTokens <= 0) {
+                throw new Error(`Provider ${providerName}, model ${modelDef.id}: invalid maxTokens`);
+            }
+        }
+    }
+}
+function loadCustomModelsConfig(filePath) {
+    if (!existsSync(filePath)) {
+        return {};
+    }
+    try {
+        const config = JSON.parse(readFileSync(filePath, "utf-8"));
+        const schemaError = validateSchema(config, filePath);
+        if (schemaError) {
+            return { error: schemaError };
+        }
+        validateModelsConfig(config);
+        return { config };
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            return { error: `Failed to parse models.json: ${error.message}\n\nFile: ${filePath}` };
+        }
+        return { error: `Failed to load models.json: ${error instanceof Error ? error.message : error}\n\nFile: ${filePath}` };
+    }
+}
+function resolveProviderHeaders(providerHeaders, modelHeaders, providerApiKey, authHeader) {
+    const resolvedProviderHeaders = resolveHeaders(providerHeaders);
+    const resolvedModelHeaders = resolveHeaders(modelHeaders);
+    let headers = resolvedProviderHeaders || resolvedModelHeaders
+        ? { ...resolvedProviderHeaders, ...resolvedModelHeaders }
+        : undefined;
+    if (authHeader && providerApiKey) {
+        const resolvedKey = resolveConfigValue(providerApiKey);
+        if (resolvedKey) {
+            headers = { ...headers, Authorization: `Bearer ${resolvedKey}` };
+        }
+    }
+    return headers;
+}
+function buildCustomModels(config, apiKeyRegistry) {
+    const models = [];
+    for (const [providerName, providerConfig] of Object.entries(config.providers)) {
+        const providerModels = providerConfig.models ?? [];
+        if (providerModels.length === 0) {
+            continue;
+        }
+        if (providerConfig.apiKey) {
+            apiKeyRegistry.set(providerName, providerConfig.apiKey);
+        }
+        for (const modelDef of providerModels) {
+            const api = modelDef.api || providerConfig.api;
+            if (!api) {
+                continue;
+            }
+            models.push({
+                id: modelDef.id,
+                name: modelDef.name,
+                api: api,
+                provider: providerName,
+                baseUrl: providerConfig.baseUrl,
+                reasoning: modelDef.reasoning,
+                input: modelDef.input,
+                cost: modelDef.cost,
+                contextWindow: modelDef.contextWindow,
+                maxTokens: modelDef.maxTokens,
+                headers: resolveProviderHeaders(providerConfig.headers, modelDef.headers, providerConfig.apiKey, providerConfig.authHeader),
+                compat: modelDef.compat,
+            });
+        }
+    }
+    return models;
+}
+function collectProviderOverrides(config, apiKeyRegistry) {
+    const replacedProviders = new Set();
+    const overrides = new Map();
+    for (const [providerName, providerConfig] of Object.entries(config.providers)) {
+        if (providerConfig.models && providerConfig.models.length > 0) {
+            replacedProviders.add(providerName);
+            continue;
+        }
+        overrides.set(providerName, {
+            baseUrl: providerConfig.baseUrl,
+            headers: providerConfig.headers,
+            apiKey: providerConfig.apiKey,
+        });
+        if (providerConfig.apiKey) {
+            apiKeyRegistry.set(providerName, providerConfig.apiKey);
+        }
+    }
+    return { replacedProviders, overrides };
+}
+function applyProviderOverrides(models, overrides) {
+    return models.map((model) => {
+        const override = overrides.get(model.provider);
+        if (!override) {
+            return model;
+        }
+        const resolvedHeaders = resolveHeaders(override.headers);
+        return {
+            ...model,
+            baseUrl: override.baseUrl ?? model.baseUrl,
+            headers: resolvedHeaders ? { ...model.headers, ...resolvedHeaders } : model.headers,
+        };
+    });
+}
+function loadBuiltInModels(replacedProviders, overrides) {
+    const builtIns = getProviders()
+        .filter((provider) => !replacedProviders.has(provider))
+        .flatMap((provider) => getModels(provider));
+    return applyProviderOverrides(builtIns, overrides);
+}
+function loadCustomModels(filePath, apiKeyRegistry) {
+    const loaded = loadCustomModelsConfig(filePath);
+    if (!loaded.config) {
+        return emptyCustomModelsResult(loaded.error);
+    }
+    const { replacedProviders, overrides } = collectProviderOverrides(loaded.config, apiKeyRegistry);
+    return {
+        models: buildCustomModels(loaded.config, apiKeyRegistry),
+        replacedProviders,
+        overrides,
+    };
+}
 export function clearApiKeyCache() {
     commandResultCache.clear();
 }
-/**
- * Model registry - loads and manages models, resolves API keys via AuthStorage.
- */
 export class ModelRegistry {
     constructor(authStorage, modelsJsonPath = join(getAgentDir(), "models.json")) {
         this.authStorage = authStorage;
@@ -224,21 +261,12 @@ export class ModelRegistry {
         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;
+            const configured = this.customProviderApiKeys.get(provider);
+            return configured ? resolveConfigValue(configured) : undefined;
         });
-        // Load models
         this.loadModels();
     }
-    /**
-     * Reload models from disk (built-in + custom from models.json).
-     */
     refresh() {
         this.customProviderApiKeys.clear();
         this.loadError = undefined;
@@ -247,294 +275,58 @@ export class ModelRegistry {
             this.applyProviderConfig(providerName, config);
         }
     }
-    /**
-     * Get any error from loading models.json (undefined if no error).
-     */
     getError() {
         return this.loadError;
     }
     loadModels() {
-        // Load custom models from models.json first (to know which providers to skip/override)
-        const { models: customModels, replacedProviders, overrides, error, } = this.modelsJsonPath ? this.loadCustomModels(this.modelsJsonPath) : emptyCustomModelsResult();
-        if (error) {
-            this.loadError = error;
-            // Keep built-in models even if custom models failed to load
+        const custom = this.modelsJsonPath ? loadCustomModels(this.modelsJsonPath, this.customProviderApiKeys) : emptyCustomModelsResult();
+        if (custom.error) {
+            this.loadError = custom.error;
         }
-        const builtInModels = this.loadBuiltInModels(replacedProviders, overrides);
-        let combined = [...builtInModels, ...customModels];
-        // Let OAuth providers modify their models (e.g., update baseUrl)
+        let combined = [...loadBuiltInModels(custom.replacedProviders, custom.overrides), ...custom.models];
         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);
+            const credential = this.authStorage.get(oauthProvider.id);
+            if (credential?.type === "oauth" && oauthProvider.modifyModels) {
+                combined = oauthProvider.modifyModels(combined, credential);
             }
         }
         this.models = combined;
     }
-    /** Load built-in models, skipping replaced providers and applying overrides */
-    loadBuiltInModels(replacedProviders, overrides) {
-        return getProviders()
-            .filter((provider) => !replacedProviders.has(provider))
-            .flatMap((provider) => {
-            const models = getModels(provider);
-            const override = overrides.get(provider);
-            if (!override)
-                return models;
-            // Apply baseUrl/headers override to all models of this provider
-            const resolvedHeaders = resolveHeaders(override.headers);
-            return models.map((m) => ({
-                ...m,
-                baseUrl: override.baseUrl ?? m.baseUrl,
-                headers: resolvedHeaders ? { ...m.headers, ...resolvedHeaders } : m.headers,
-            }));
-        });
-    }
-    loadCustomModels(modelsJsonPath) {
-        if (!existsSync(modelsJsonPath)) {
-            return emptyCustomModelsResult();
-        }
-        try {
-            const content = readFileSync(modelsJsonPath, "utf-8");
-            const config = JSON.parse(content);
-            // Validate schema
-            const ajv = new Ajv();
-            const validate = ajv.compile(ModelsConfigSchema);
-            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: ${modelsJsonPath}`);
-            }
-            // Additional validation
-            this.validateConfig(config);
-            // Separate providers into "full replacement" (has models) vs "override-only" (no models)
-            const replacedProviders = new Set();
-            const overrides = new Map();
-            for (const [providerName, providerConfig] of Object.entries(config.providers)) {
-                if (providerConfig.models && providerConfig.models.length > 0) {
-                    // Has custom models -> full replacement
-                    replacedProviders.add(providerName);
-                }
-                else {
-                    // No models -> just override baseUrl/headers on built-in
-                    overrides.set(providerName, {
-                        baseUrl: providerConfig.baseUrl,
-                        headers: providerConfig.headers,
-                        apiKey: providerConfig.apiKey,
-                    });
-                    // Store API key for fallback resolver
-                    if (providerConfig.apiKey) {
-                        this.customProviderApiKeys.set(providerName, providerConfig.apiKey);
-                    }
-                }
-            }
-            return { models: this.parseModels(config), replacedProviders, overrides, 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) {
-        for (const [providerName, providerConfig] of Object.entries(config.providers)) {
-            const hasProviderApi = !!providerConfig.api;
-            const models = providerConfig.models ?? [];
-            if (models.length === 0) {
-                // Override-only config: just needs baseUrl (to override built-in)
-                if (!providerConfig.baseUrl) {
-                    throw new Error(`Provider ${providerName}: must specify either "baseUrl" (for override) or "models" (for replacement).`);
-                }
-            }
-            else {
-                // Full replacement: needs baseUrl and apiKey
-                if (!providerConfig.baseUrl) {
-                    throw new Error(`Provider ${providerName}: "baseUrl" is required when defining custom models.`);
-                }
-                if (!providerConfig.apiKey) {
-                    throw new Error(`Provider ${providerName}: "apiKey" is required when defining custom models.`);
-                }
-            }
-            for (const modelDef of models) {
-                const hasModelApi = !!modelDef.api;
-                if (!hasProviderApi && !hasModelApi) {
-                    throw new Error(`Provider ${providerName}, model ${modelDef.id}: no "api" specified. Set at provider or model level.`);
-                }
-                if (!modelDef.id)
-                    throw new Error(`Provider ${providerName}: model missing "id"`);
-                if (!modelDef.name)
-                    throw new Error(`Provider ${providerName}: model missing "name"`);
-                if (modelDef.contextWindow <= 0)
-                    throw new Error(`Provider ${providerName}, model ${modelDef.id}: invalid contextWindow`);
-                if (modelDef.maxTokens <= 0)
-                    throw new Error(`Provider ${providerName}, model ${modelDef.id}: invalid maxTokens`);
-            }
-        }
-    }
-    parseModels(config) {
-        const models = [];
-        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);
-            }
-            for (const modelDef of modelDefs) {
-                const api = modelDef.api || providerConfig.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}` };
-                    }
-                }
-                // baseUrl is validated to exist for providers with models
-                models.push({
-                    id: modelDef.id,
-                    name: modelDef.name,
-                    api: api,
-                    provider: providerName,
-                    baseUrl: providerConfig.baseUrl,
-                    reasoning: modelDef.reasoning,
-                    input: modelDef.input,
-                    cost: modelDef.cost,
-                    contextWindow: modelDef.contextWindow,
-                    maxTokens: modelDef.maxTokens,
-                    headers,
-                    compat: modelDef.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.authStorage.hasAuth(m.provider));
-    }
-    /**
-     * Find a model by provider and ID.
-     */
-    find(provider, modelId) {
-        return this.models.find((m) => m.provider === provider && m.id === modelId);
-    }
-    /**
-     * Get API key for a model.
-     * @param model - The model to get API key for
-     * @param accountId - Optional account ID for multi-account providers
-     */
-    async getApiKey(model, accountId) {
-        return this.authStorage.getApiKey(model.provider, accountId);
-    }
-    /**
-     * Get API key for a provider.
-     * @param provider - The provider ID
-     * @param accountId - Optional account ID for multi-account providers
-     */
-    async getApiKeyForProvider(provider, accountId) {
-        return this.authStorage.getApiKey(provider, accountId);
-    }
-    /**
-     * Get all accounts for a provider.
-     */
-    getAccounts(provider) {
-        return this.authStorage.getAccounts(provider);
-    }
-    /**
-     * Get default account for a provider.
-     */
-    getDefaultAccount(provider) {
-        return this.authStorage.getDefaultAccount(provider);
-    }
-    /**
-     * Check if a model is using OAuth credentials (subscription).
-     */
-    isUsingOAuth(model) {
-        const cred = this.authStorage.get(model.provider);
-        return cred?.type === "oauth";
-    }
-    /**
-     * 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) {
+    registerExtensionProvider(providerName, config) {
         this.registeredProviders.set(providerName, config);
         this.applyProviderConfig(providerName, config);
     }
     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);
+            registerOAuthProvider({ ...config.oauth, id: providerName });
         }
         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,
-                stream: (model, context, options) => streamSimple(model, context, options),
-                streamSimple,
+                stream: (model, context, options) => config.streamSimple(model, context, options),
+                streamSimple: config.streamSimple,
             });
         }
-        // Store API key for auth resolution
         if (config.apiKey) {
             this.customProviderApiKeys.set(providerName, config.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);
-            // 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) {
+            this.models = this.models.filter((model) => model.provider !== providerName);
+            const replacementModels = config.models.map((modelDef) => {
                 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.models.push({
+                return {
                     id: modelDef.id,
                     name: modelDef.name,
                     api: api,
@@ -545,24 +337,53 @@ export class ModelRegistry {
                     cost: modelDef.cost,
                     contextWindow: modelDef.contextWindow,
                     maxTokens: modelDef.maxTokens,
-                    headers,
+                    headers: resolveProviderHeaders(config.headers, modelDef.headers, config.apiKey, config.authHeader),
                     compat: modelDef.compat,
-                });
-            }
+                };
+            });
+            this.models.push(...replacementModels);
+            return;
         }
-        else if (config.baseUrl) {
-            // Override-only: update baseUrl/headers for existing models
+        if (config.baseUrl) {
             const resolvedHeaders = resolveHeaders(config.headers);
-            this.models = this.models.map((m) => {
-                if (m.provider !== providerName)
-                    return m;
+            this.models = this.models.map((model) => {
+                if (model.provider !== providerName) {
+                    return model;
+                }
                 return {
-                    ...m,
-                    baseUrl: config.baseUrl ?? m.baseUrl,
-                    headers: resolvedHeaders ? { ...m.headers, ...resolvedHeaders } : m.headers,
+                    ...model,
+                    baseUrl: config.baseUrl ?? model.baseUrl,
+                    headers: resolvedHeaders ? { ...model.headers, ...resolvedHeaders } : model.headers,
                 };
             });
         }
     }
+    getAll() {
+        return this.models;
+    }
+    getAvailable() {
+        return this.models.filter((model) => this.authStorage.hasAuth(model.provider));
+    }
+    find(provider, modelId) {
+        return this.models.find((model) => model.provider === provider && model.id === modelId);
+    }
+    async getApiKey(model, accountId) {
+        return this.authStorage.getApiKey(model.provider, accountId);
+    }
+    async getApiKeyForProvider(provider, accountId) {
+        return this.authStorage.getApiKey(provider, accountId);
+    }
+    getAccounts(provider) {
+        return this.authStorage.getAccounts(provider);
+    }
+    getDefaultAccount(provider) {
+        return this.authStorage.getDefaultAccount(provider);
+    }
+    isUsingOAuth(model) {
+        return this.authStorage.get(model.provider)?.type === "oauth";
+    }
+    registerProvider(providerName, config) {
+        this.registerExtensionProvider(providerName, config);
+    }
 }
 //# sourceMappingURL=model-registry.js.map