cowork-os 0.3.21

package/dist/electron/electron/agent/llm/provider-factory.js

@@ -0,0 +1,880 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMProviderFactory = void 0;
+const electron_1 = require("electron");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const pi_ai_1 = require("@mariozechner/pi-ai");
+const types_1 = require("./types");
+const anthropic_provider_1 = require("./anthropic-provider");
+const bedrock_provider_1 = require("./bedrock-provider");
+const ollama_provider_1 = require("./ollama-provider");
+const gemini_provider_1 = require("./gemini-provider");
+const openrouter_provider_1 = require("./openrouter-provider");
+const openai_provider_1 = require("./openai-provider");
+const SecureSettingsRepository_1 = require("../../database/SecureSettingsRepository");
+const LEGACY_SETTINGS_FILE = 'llm-settings.json';
+const MASKED_VALUE = '***configured***';
+const ENCRYPTED_PREFIX = 'encrypted:';
+// ============ Legacy Encryption Functions (for migration only) ============
+// These functions are only used to decrypt settings from legacy JSON files
+// during migration to the encrypted database. New settings use full-object
+// encryption via SecureSettingsRepository.
+/**
+ * @deprecated Used only for migration from legacy JSON files
+ * Encrypt a secret using OS keychain via safeStorage
+ */
+function encryptSecret(value) {
+    if (!value || !value.trim())
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed === MASKED_VALUE)
+        return undefined;
+    try {
+        if (electron_1.safeStorage.isEncryptionAvailable()) {
+            const encrypted = electron_1.safeStorage.encryptString(trimmed);
+            return ENCRYPTED_PREFIX + encrypted.toString('base64');
+        }
+    }
+    catch (error) {
+        console.warn('Failed to encrypt secret, storing masked:', error);
+    }
+    // Fallback to masked value if encryption fails
+    return MASKED_VALUE;
+}
+/**
+ * @deprecated Used only for migration from legacy JSON files
+ * Decrypt a secret that was encrypted with safeStorage
+ */
+function decryptSecret(value) {
+    if (!value)
+        return undefined;
+    if (value === MASKED_VALUE)
+        return undefined;
+    if (value.startsWith(ENCRYPTED_PREFIX)) {
+        try {
+            const isAvailable = electron_1.safeStorage.isEncryptionAvailable();
+            if (isAvailable) {
+                const encrypted = Buffer.from(value.slice(ENCRYPTED_PREFIX.length), 'base64');
+                const decrypted = electron_1.safeStorage.decryptString(encrypted);
+                return decrypted;
+            }
+            else {
+                console.error('[LLM Settings] safeStorage encryption not available - cannot decrypt secrets');
+                console.error('[LLM Settings] You may need to re-enter your API credentials in Settings');
+            }
+        }
+        catch (error) {
+            // This can happen after app updates when the code signature changes
+            // The macOS Keychain ties encryption to the app's signature
+            console.error('[LLM Settings] Failed to decrypt secret - this can happen after app updates');
+            console.error('[LLM Settings] Error:', error.message || error);
+            console.error('[LLM Settings] Please re-enter your API credentials in Settings');
+        }
+    }
+    // If not encrypted and not masked, return as-is (for backwards compatibility)
+    if (value !== MASKED_VALUE && !value.startsWith(ENCRYPTED_PREFIX)) {
+        return value.trim() || undefined;
+    }
+    return undefined;
+}
+/**
+ * Normalize a secret value, filtering out masked/encrypted values
+ */
+function normalizeSecret(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === MASKED_VALUE || trimmed.startsWith(ENCRYPTED_PREFIX))
+        return undefined;
+    return trimmed;
+}
+/**
+ * @deprecated Used only for migration from legacy JSON files
+ * Decrypt all secrets in legacy settings
+ */
+function sanitizeSettings(settings) {
+    const sanitized = { ...settings };
+    // Decrypt secrets when loading from disk
+    if (sanitized.anthropic) {
+        sanitized.anthropic = {
+            ...sanitized.anthropic,
+            apiKey: decryptSecret(sanitized.anthropic.apiKey),
+        };
+    }
+    if (sanitized.bedrock) {
+        sanitized.bedrock = {
+            ...sanitized.bedrock,
+            secretAccessKey: decryptSecret(sanitized.bedrock.secretAccessKey),
+        };
+    }
+    if (sanitized.ollama) {
+        sanitized.ollama = {
+            ...sanitized.ollama,
+            apiKey: decryptSecret(sanitized.ollama.apiKey),
+        };
+    }
+    if (sanitized.gemini) {
+        sanitized.gemini = {
+            ...sanitized.gemini,
+            apiKey: decryptSecret(sanitized.gemini.apiKey),
+        };
+    }
+    if (sanitized.openrouter) {
+        sanitized.openrouter = {
+            ...sanitized.openrouter,
+            apiKey: decryptSecret(sanitized.openrouter.apiKey),
+        };
+    }
+    if (sanitized.openai) {
+        const decryptedAccessToken = decryptSecret(sanitized.openai.accessToken);
+        const decryptedRefreshToken = decryptSecret(sanitized.openai.refreshToken);
+        // Log OAuth token status for debugging
+        if (sanitized.openai.authMethod === 'oauth') {
+            console.log('[LLM Settings] Loading OpenAI OAuth settings:');
+            console.log('[LLM Settings]   authMethod:', sanitized.openai.authMethod);
+            console.log('[LLM Settings]   hasAccessToken:', !!sanitized.openai.accessToken);
+            console.log('[LLM Settings]   decryptedAccessToken:', !!decryptedAccessToken);
+            console.log('[LLM Settings]   hasRefreshToken:', !!sanitized.openai.refreshToken);
+            console.log('[LLM Settings]   decryptedRefreshToken:', !!decryptedRefreshToken);
+        }
+        sanitized.openai = {
+            ...sanitized.openai,
+            apiKey: decryptSecret(sanitized.openai.apiKey),
+            accessToken: decryptedAccessToken,
+            refreshToken: decryptedRefreshToken,
+        };
+    }
+    return sanitized;
+}
+const DEFAULT_SETTINGS = {
+    providerType: 'anthropic',
+    modelKey: types_1.DEFAULT_MODEL,
+};
+/**
+ * Factory for creating LLM providers
+ */
+class LLMProviderFactory {
+    /**
+     * Initialize the factory
+     */
+    static initialize() {
+        const userDataPath = electron_1.app.getPath('userData');
+        this.legacySettingsPath = path.join(userDataPath, LEGACY_SETTINGS_FILE);
+        // Migrate from legacy JSON file to encrypted database
+        this.migrateFromLegacyFile();
+    }
+    /**
+     * Migrate settings from legacy JSON file to encrypted database
+     */
+    static migrateFromLegacyFile() {
+        if (this.migrationCompleted)
+            return;
+        try {
+            // Check if SecureSettingsRepository is initialized
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                console.log('[LLMProviderFactory] SecureSettingsRepository not yet initialized, skipping migration');
+                return;
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            // Check if already migrated to database
+            if (repository.exists('llm')) {
+                this.migrationCompleted = true;
+                return;
+            }
+            // Check if legacy file exists
+            if (!fs.existsSync(this.legacySettingsPath)) {
+                console.log('[LLMProviderFactory] No legacy settings file found');
+                this.migrationCompleted = true;
+                return;
+            }
+            console.log('[LLMProviderFactory] Migrating settings from legacy JSON file to encrypted database...');
+            // Create backup before migration
+            const backupPath = this.legacySettingsPath + '.migration-backup';
+            fs.copyFileSync(this.legacySettingsPath, backupPath);
+            try {
+                // Read and decrypt legacy settings
+                const data = fs.readFileSync(this.legacySettingsPath, 'utf-8');
+                const legacySettings = { ...DEFAULT_SETTINGS, ...JSON.parse(data) };
+                const decryptedSettings = sanitizeSettings(legacySettings);
+                // Save to encrypted database
+                repository.save('llm', decryptedSettings);
+                console.log('[LLMProviderFactory] Settings migrated to encrypted database');
+                // Migration successful - delete backup and original
+                fs.unlinkSync(backupPath);
+                fs.unlinkSync(this.legacySettingsPath);
+                console.log('[LLMProviderFactory] Migration complete, cleaned up legacy files');
+                this.migrationCompleted = true;
+            }
+            catch (migrationError) {
+                console.error('[LLMProviderFactory] Migration failed, backup preserved at:', backupPath);
+                throw migrationError;
+            }
+        }
+        catch (error) {
+            console.error('[LLMProviderFactory] Migration failed:', error);
+        }
+    }
+    /**
+     * Get the path to legacy settings file (for testing)
+     */
+    static getSettingsPath() {
+        return this.legacySettingsPath;
+    }
+    /**
+     * Load settings from encrypted database
+     */
+    static loadSettings() {
+        if (this.cachedSettings) {
+            return this.cachedSettings;
+        }
+        let settings = { ...DEFAULT_SETTINGS };
+        let settingsExist = false;
+        try {
+            // Try to load from encrypted database
+            if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+                const stored = repository.load('llm');
+                if (stored) {
+                    settings = { ...DEFAULT_SETTINGS, ...stored };
+                    settingsExist = true;
+                }
+            }
+        }
+        catch (error) {
+            console.error('[LLMProviderFactory] Failed to load settings from database:', error);
+        }
+        // Auto-detect provider if no settings exist
+        if (!settingsExist) {
+            const detectedProvider = this.detectProviderFromSettings(settings);
+            if (detectedProvider) {
+                settings.providerType = detectedProvider;
+                console.log(`[LLMProviderFactory] Auto-detected LLM provider: ${detectedProvider}`);
+            }
+        }
+        this.cachedSettings = settings;
+        return settings;
+    }
+    /**
+     * Detect which provider to use based on saved settings
+     * Note: Environment variables are no longer used for security reasons.
+     * All configuration should be done through the Settings UI.
+     */
+    static detectProviderFromSettings(settings) {
+        // Check if any provider has credentials configured in settings
+        if (settings.anthropic?.apiKey) {
+            return 'anthropic';
+        }
+        if (settings.gemini?.apiKey) {
+            return 'gemini';
+        }
+        if (settings.openrouter?.apiKey) {
+            return 'openrouter';
+        }
+        if (settings.openai?.apiKey || settings.openai?.accessToken) {
+            return 'openai';
+        }
+        if (settings.bedrock?.accessKeyId || settings.bedrock?.profile) {
+            return 'bedrock';
+        }
+        if (settings.ollama?.baseUrl || settings.ollama?.model) {
+            return 'ollama';
+        }
+        // No valid credentials detected - user needs to configure via Settings
+        return null;
+    }
+    /**
+     * Save settings to encrypted database
+     */
+    static saveSettings(settings) {
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                throw new Error('SecureSettingsRepository not initialized');
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            // Save entire settings object to encrypted database
+            // No need for per-field encryption - the entire object is encrypted
+            repository.save('llm', settings);
+            this.cachedSettings = settings;
+            console.log('[LLMProviderFactory] Settings saved to encrypted database');
+        }
+        catch (error) {
+            console.error('[LLMProviderFactory] Failed to save settings:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clear cached settings
+     */
+    static clearCache() {
+        this.cachedSettings = null;
+    }
+    /**
+     * Create a provider based on current settings
+     * Note: All credentials must be configured via the Settings UI.
+     * Environment variables are no longer used for security reasons.
+     */
+    static createProvider(overrideConfig) {
+        const settings = this.loadSettings();
+        const providerType = overrideConfig?.type || settings.providerType;
+        const config = {
+            type: providerType,
+            model: this.getModelId(settings.modelKey, providerType, settings.ollama?.model, settings.gemini?.model, settings.openrouter?.model, settings.openai?.model),
+            // Anthropic config - from settings only
+            anthropicApiKey: normalizeSecret(overrideConfig?.anthropicApiKey) || settings.anthropic?.apiKey,
+            // Bedrock config - from settings only
+            awsRegion: overrideConfig?.awsRegion || settings.bedrock?.region || 'us-east-1',
+            awsAccessKeyId: overrideConfig?.awsAccessKeyId || settings.bedrock?.accessKeyId,
+            awsSecretAccessKey: normalizeSecret(overrideConfig?.awsSecretAccessKey) || settings.bedrock?.secretAccessKey,
+            awsSessionToken: overrideConfig?.awsSessionToken || settings.bedrock?.sessionToken,
+            awsProfile: overrideConfig?.awsProfile || settings.bedrock?.profile,
+            // Ollama config - from settings only
+            ollamaBaseUrl: overrideConfig?.ollamaBaseUrl || settings.ollama?.baseUrl || 'http://localhost:11434',
+            ollamaApiKey: normalizeSecret(overrideConfig?.ollamaApiKey) || settings.ollama?.apiKey,
+            // Gemini config - from settings only
+            geminiApiKey: normalizeSecret(overrideConfig?.geminiApiKey) || settings.gemini?.apiKey,
+            // OpenRouter config - from settings only
+            openrouterApiKey: normalizeSecret(overrideConfig?.openrouterApiKey) || settings.openrouter?.apiKey,
+            // OpenAI config - from settings only
+            openaiApiKey: normalizeSecret(overrideConfig?.openaiApiKey) || settings.openai?.apiKey,
+            openaiAccessToken: normalizeSecret(overrideConfig?.openaiAccessToken) || settings.openai?.accessToken,
+            openaiRefreshToken: settings.openai?.refreshToken,
+            openaiTokenExpiresAt: settings.openai?.tokenExpiresAt,
+        };
+        return this.createProviderFromConfig(config);
+    }
+    /**
+     * Create a provider from explicit config
+     */
+    static createProviderFromConfig(config) {
+        switch (config.type) {
+            case 'anthropic':
+                return new anthropic_provider_1.AnthropicProvider(config);
+            case 'bedrock':
+                return new bedrock_provider_1.BedrockProvider(config);
+            case 'ollama':
+                return new ollama_provider_1.OllamaProvider(config);
+            case 'gemini':
+                return new gemini_provider_1.GeminiProvider(config);
+            case 'openrouter':
+                return new openrouter_provider_1.OpenRouterProvider(config);
+            case 'openai':
+                return new openai_provider_1.OpenAIProvider(config);
+            default:
+                throw new Error(`Unknown provider type: ${config.type}`);
+        }
+    }
+    /**
+     * Get the model ID for a provider
+     */
+    static getModelId(modelKey, providerType, ollamaModel, geminiModel, openrouterModel, openaiModel) {
+        // For Ollama, use the specific Ollama model if provided
+        if (providerType === 'ollama') {
+            return ollamaModel || 'gpt-oss:20b';
+        }
+        // For Gemini, use the specific Gemini model if provided or default
+        if (providerType === 'gemini') {
+            return geminiModel || 'gemini-2.0-flash';
+        }
+        // For OpenRouter, use the specific model if provided or default
+        if (providerType === 'openrouter') {
+            return openrouterModel || 'anthropic/claude-3.5-sonnet';
+        }
+        // For OpenAI, use the specific model if provided or default
+        if (providerType === 'openai') {
+            return openaiModel || 'gpt-4o-mini';
+        }
+        // For other providers, look up in MODELS
+        const model = types_1.MODELS[modelKey];
+        if (!model) {
+            throw new Error(`Unknown model: ${modelKey}`);
+        }
+        return model[providerType];
+    }
+    /**
+     * Get display name for a model
+     */
+    static getModelDisplayName(modelKey) {
+        return types_1.MODELS[modelKey]?.displayName || modelKey;
+    }
+    /**
+     * Get all available models
+     */
+    static getAvailableModels() {
+        return Object.entries(types_1.MODELS).map(([key, value]) => ({
+            key: key,
+            displayName: value.displayName,
+        }));
+    }
+    /**
+     * Get available providers based on saved settings configuration
+     * Note: Environment variables are no longer checked for security reasons.
+     */
+    static getAvailableProviders() {
+        const settings = this.loadSettings();
+        return [
+            {
+                type: 'anthropic',
+                name: 'Anthropic API',
+                configured: !!settings.anthropic?.apiKey,
+            },
+            {
+                type: 'gemini',
+                name: 'Google Gemini',
+                configured: !!settings.gemini?.apiKey,
+            },
+            {
+                type: 'openrouter',
+                name: 'OpenRouter',
+                configured: !!settings.openrouter?.apiKey,
+            },
+            {
+                type: 'openai',
+                name: 'OpenAI',
+                configured: !!(settings.openai?.apiKey || settings.openai?.accessToken),
+            },
+            {
+                type: 'bedrock',
+                name: 'AWS Bedrock',
+                configured: !!(settings.bedrock?.accessKeyId || settings.bedrock?.profile),
+            },
+            {
+                type: 'ollama',
+                name: 'Ollama (Local)',
+                configured: !!(settings.ollama?.baseUrl || settings.ollama?.model),
+            },
+        ];
+    }
+    /**
+     * Get current configuration status
+     */
+    static getConfigStatus() {
+        const settings = this.loadSettings();
+        return {
+            currentProvider: settings.providerType,
+            currentModel: settings.modelKey,
+            providers: this.getAvailableProviders(),
+            models: this.getAvailableModels(),
+        };
+    }
+    /**
+     * Get the currently selected provider type
+     */
+    static getSelectedProvider() {
+        const settings = this.loadSettings();
+        return settings.providerType;
+    }
+    /**
+     * Get the currently selected model key
+     */
+    static getSelectedModel() {
+        const settings = this.loadSettings();
+        return settings.modelKey;
+    }
+    /**
+     * Get the current LLM settings
+     */
+    static getSettings() {
+        return this.loadSettings();
+    }
+    /**
+     * Test a provider configuration
+     */
+    static async testProvider(config) {
+        try {
+            const provider = this.createProviderFromConfig(config);
+            return await provider.testConnection();
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to create provider',
+            };
+        }
+    }
+    /**
+     * Fetch available Bedrock models from AWS
+     */
+    static async getBedrockModels(config) {
+        const settings = this.loadSettings();
+        const region = config?.region || settings.bedrock?.region || 'us-east-1';
+        const accessKeyId = config?.accessKeyId || settings.bedrock?.accessKeyId;
+        const secretAccessKey = config?.secretAccessKey || settings.bedrock?.secretAccessKey;
+        const profile = config?.profile || settings.bedrock?.profile;
+        // Default Claude models available on Bedrock
+        const defaultModels = Object.entries(types_1.MODELS).map(([key, value]) => ({
+            id: value.bedrock,
+            name: value.displayName,
+            provider: 'Anthropic',
+            description: key.includes('opus') ? 'Most capable for complex tasks' :
+                key.includes('sonnet') ? 'Balanced performance and speed' :
+                    'Fast and efficient',
+        }));
+        try {
+            // Import BedrockClient for listing models (different from runtime client)
+            const { BedrockClient, ListFoundationModelsCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-bedrock')));
+            const { fromIni } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/credential-provider-ini')));
+            const clientConfig = { region };
+            if (accessKeyId && secretAccessKey) {
+                clientConfig.credentials = {
+                    accessKeyId,
+                    secretAccessKey,
+                };
+            }
+            else if (profile) {
+                clientConfig.credentials = fromIni({ profile });
+            }
+            const client = new BedrockClient(clientConfig);
+            const command = new ListFoundationModelsCommand({
+                byOutputModality: 'TEXT',
+            });
+            const response = await client.send(command);
+            const models = response.modelSummaries || [];
+            // Filter for Claude models and format the response
+            const claudeModels = models
+                .filter((m) => m.providerName === 'Anthropic' && m.modelId?.includes('claude'))
+                .map((m) => ({
+                id: m.modelId || '',
+                name: m.modelName || m.modelId || '',
+                provider: m.providerName || 'Anthropic',
+                description: m.modelId?.includes('opus') ? 'Most capable for complex tasks' :
+                    m.modelId?.includes('sonnet') ? 'Balanced performance and speed' :
+                        m.modelId?.includes('haiku') ? 'Fast and efficient' :
+                            'Claude model',
+            }))
+                .filter((m) => m.id);
+            return claudeModels.length > 0 ? claudeModels : defaultModels;
+        }
+        catch (error) {
+            console.error('Failed to fetch Bedrock models:', error);
+            // Return default models on error
+            return defaultModels;
+        }
+    }
+    /**
+     * Fetch available Ollama models from the server
+     */
+    static async getOllamaModels(baseUrl) {
+        const settings = this.loadSettings();
+        const url = baseUrl || settings.ollama?.baseUrl || 'http://localhost:11434';
+        try {
+            console.log(`[ProviderFactory] Fetching Ollama models from ${url}...`);
+            const provider = new ollama_provider_1.OllamaProvider({
+                type: 'ollama',
+                model: '',
+                ollamaBaseUrl: url,
+                ollamaApiKey: settings.ollama?.apiKey,
+            });
+            const models = await provider.getAvailableModels();
+            console.log(`[ProviderFactory] Fetched ${models.length} models from Ollama`);
+            return models;
+        }
+        catch (error) {
+            console.error('Failed to fetch Ollama models:', error);
+            return [];
+        }
+    }
+    /**
+     * Fetch available Gemini models from the API
+     */
+    static async getGeminiModels(apiKey) {
+        const settings = this.loadSettings();
+        // Normalize empty strings to undefined
+        const normalizedApiKey = apiKey?.trim() || undefined;
+        const settingsKey = settings.gemini?.apiKey;
+        const key = normalizedApiKey || settingsKey;
+        const defaultModels = [
+            { name: 'gemini-2.5-pro-preview-05-06', displayName: 'Gemini 2.5 Pro', description: 'Most capable model for complex tasks' },
+            { name: 'gemini-2.5-flash-preview-05-20', displayName: 'Gemini 2.5 Flash', description: 'Fast and efficient for most tasks' },
+            { name: 'gemini-2.0-flash', displayName: 'Gemini 2.0 Flash', description: 'Balanced speed and capability' },
+            { name: 'gemini-2.0-flash-lite', displayName: 'Gemini 2.0 Flash Lite', description: 'Fastest and most cost-effective' },
+            { name: 'gemini-1.5-pro', displayName: 'Gemini 1.5 Pro', description: 'Previous generation pro model' },
+            { name: 'gemini-1.5-flash', displayName: 'Gemini 1.5 Flash', description: 'Previous generation flash model' },
+        ];
+        if (!key) {
+            // Return default models if no API key
+            return defaultModels;
+        }
+        try {
+            const provider = new gemini_provider_1.GeminiProvider({
+                type: 'gemini',
+                model: '',
+                geminiApiKey: key,
+            });
+            return await provider.getAvailableModels();
+        }
+        catch (error) {
+            console.error('Failed to fetch Gemini models:', error);
+            // Return default models on error instead of empty array
+            return defaultModels;
+        }
+    }
+    /**
+     * Fetch available OpenRouter models from the API
+     */
+    static async getOpenRouterModels(apiKey) {
+        const settings = this.loadSettings();
+        // Normalize empty strings to undefined
+        const normalizedApiKey = apiKey?.trim() || undefined;
+        const key = normalizedApiKey || settings.openrouter?.apiKey;
+        const defaultModels = [
+            { id: 'anthropic/claude-3.5-sonnet', name: 'Claude 3.5 Sonnet', context_length: 200000 },
+            { id: 'anthropic/claude-3-opus', name: 'Claude 3 Opus', context_length: 200000 },
+            { id: 'openai/gpt-4o', name: 'GPT-4o', context_length: 128000 },
+            { id: 'openai/gpt-4o-mini', name: 'GPT-4o Mini', context_length: 128000 },
+            { id: 'google/gemini-pro-1.5', name: 'Gemini Pro 1.5', context_length: 1000000 },
+            { id: 'meta-llama/llama-3.1-405b-instruct', name: 'Llama 3.1 405B', context_length: 131072 },
+        ];
+        if (!key) {
+            // Return default models if no API key
+            return defaultModels;
+        }
+        try {
+            const provider = new openrouter_provider_1.OpenRouterProvider({
+                type: 'openrouter',
+                model: '',
+                openrouterApiKey: key,
+            });
+            return await provider.getAvailableModels();
+        }
+        catch (error) {
+            console.error('Failed to fetch OpenRouter models:', error);
+            // Return default models on error instead of empty array
+            return defaultModels;
+        }
+    }
+    /**
+     * Fetch available OpenAI models
+     * For API key auth: uses the models.list API via OpenAI SDK
+     * For OAuth auth: uses pi-ai SDK's model list for openai-codex provider
+     */
+    static async getOpenAIModels(apiKey) {
+        const settings = this.loadSettings();
+        // Normalize empty strings to undefined
+        const normalizedApiKey = apiKey?.trim() || undefined;
+        const key = normalizedApiKey || settings.openai?.apiKey;
+        // Check for OAuth access token if no API key
+        const accessToken = settings.openai?.accessToken;
+        const refreshToken = settings.openai?.refreshToken;
+        const defaultModels = [
+            { id: 'gpt-4o', name: 'GPT-4o', description: 'Most capable model for complex tasks' },
+            { id: 'gpt-4o-mini', name: 'GPT-4o Mini', description: 'Fast and affordable for most tasks' },
+            { id: 'gpt-4-turbo', name: 'GPT-4 Turbo', description: 'Previous generation flagship' },
+            { id: 'gpt-3.5-turbo', name: 'GPT-3.5 Turbo', description: 'Fast and cost-effective' },
+            { id: 'o1', name: 'o1', description: 'Advanced reasoning model' },
+            { id: 'o1-mini', name: 'o1 Mini', description: 'Fast reasoning model' },
+        ];
+        // For OAuth users, use pi-ai SDK's model list directly
+        if (accessToken && refreshToken && !key) {
+            console.log('[OpenAI] Using OAuth - fetching models from pi-ai SDK...');
+            try {
+                const piAiModels = (0, pi_ai_1.getModels)('openai-codex');
+                const models = piAiModels.map((m) => ({
+                    id: m.id,
+                    name: m.name || this.formatOpenAIModelName(m.id),
+                    description: this.getOpenAIModelDescription(m.id),
+                }));
+                // Sort by priority (ChatGPT internal models)
+                models.sort((a, b) => {
+                    const priority = (id) => {
+                        if (id.includes('5.1-codex-mini'))
+                            return 0;
+                        if (id.includes('5.1-codex-max'))
+                            return 1;
+                        if (id === 'gpt-5.1')
+                            return 2;
+                        if (id.includes('5.2-codex'))
+                            return 3;
+                        if (id === 'gpt-5.2')
+                            return 4;
+                        return 5;
+                    };
+                    return priority(a.id) - priority(b.id);
+                });
+                console.log(`[OpenAI] Found ${models.length} models via pi-ai SDK`);
+                return models;
+            }
+            catch (error) {
+                console.error('[OpenAI] Failed to get models from pi-ai SDK:', error);
+                // Return ChatGPT-specific defaults for OAuth users
+                return [
+                    { id: 'gpt-5.1-codex-mini', name: 'GPT-5.1 Codex Mini', description: 'Fast and efficient for most tasks' },
+                    { id: 'gpt-5.1-codex-max', name: 'GPT-5.1 Codex Max', description: 'Maximum capability for complex tasks' },
+                    { id: 'gpt-5.1', name: 'GPT-5.1', description: 'Balanced performance and capability' },
+                    { id: 'gpt-5.2-codex', name: 'GPT-5.2 Codex', description: 'Advanced reasoning model' },
+                    { id: 'gpt-5.2', name: 'GPT-5.2', description: 'Most advanced reasoning' },
+                ];
+            }
+        }
+        if (!key) {
+            // Return default models if no authentication
+            return defaultModels;
+        }
+        try {
+            // For API key, use the OpenAI provider
+            const provider = new openai_provider_1.OpenAIProvider({
+                type: 'openai',
+                model: '',
+                openaiApiKey: key,
+            });
+            return await provider.getAvailableModels();
+        }
+        catch (error) {
+            console.error('Failed to fetch OpenAI models:', error);
+            // Return default models on error instead of empty array
+            return defaultModels;
+        }
+    }
+    /**
+     * Format OpenAI model ID to display name
+     */
+    static formatOpenAIModelName(modelId) {
+        // Public API models
+        if (modelId === 'gpt-4o')
+            return 'GPT-4o';
+        if (modelId === 'gpt-4o-mini')
+            return 'GPT-4o Mini';
+        if (modelId.includes('gpt-4o-'))
+            return `GPT-4o (${modelId.replace('gpt-4o-', '')})`;
+        if (modelId === 'gpt-4-turbo')
+            return 'GPT-4 Turbo';
+        if (modelId === 'gpt-4')
+            return 'GPT-4';
+        if (modelId === 'gpt-3.5-turbo')
+            return 'GPT-3.5 Turbo';
+        if (modelId === 'o1')
+            return 'o1';
+        if (modelId === 'o1-mini')
+            return 'o1 Mini';
+        if (modelId === 'o1-preview')
+            return 'o1 Preview';
+        if (modelId === 'o3-mini')
+            return 'o3 Mini';
+        // ChatGPT internal models
+        if (modelId === 'gpt-5.1')
+            return 'GPT-5.1';
+        if (modelId === 'gpt-5.1-codex-mini')
+            return 'GPT-5.1 Codex Mini';
+        if (modelId === 'gpt-5.1-codex-max')
+            return 'GPT-5.1 Codex Max';
+        if (modelId === 'gpt-5.2')
+            return 'GPT-5.2';
+        if (modelId === 'gpt-5.2-codex')
+            return 'GPT-5.2 Codex';
+        return modelId;
+    }
+    /**
+     * Get OpenAI model description
+     */
+    static getOpenAIModelDescription(modelId) {
+        // Public API models
+        if (modelId.includes('gpt-4o') && !modelId.includes('mini'))
+            return 'Most capable model for complex tasks';
+        if (modelId.includes('gpt-4o-mini'))
+            return 'Fast and affordable for most tasks';
+        if (modelId.includes('gpt-4-turbo'))
+            return 'Previous generation flagship';
+        if (modelId.includes('gpt-4'))
+            return 'High capability model';
+        if (modelId.includes('gpt-3.5'))
+            return 'Fast and cost-effective';
+        if (modelId === 'o1' || modelId === 'o1-preview')
+            return 'Advanced reasoning model';
+        if (modelId === 'o1-mini')
+            return 'Fast reasoning model';
+        if (modelId.includes('o3'))
+            return 'Next generation reasoning';
+        // ChatGPT internal models
+        if (modelId === 'gpt-5.1')
+            return 'Balanced performance and capability';
+        if (modelId === 'gpt-5.1-codex-mini')
+            return 'Fast and efficient for most tasks';
+        if (modelId === 'gpt-5.1-codex-max')
+            return 'Maximum capability for complex tasks';
+        if (modelId === 'gpt-5.2')
+            return 'Most advanced reasoning';
+        if (modelId === 'gpt-5.2-codex')
+            return 'Advanced reasoning model';
+        return 'OpenAI model';
+    }
+    /**
+     * Save cached models for a provider
+     */
+    static saveCachedModels(providerType, models) {
+        const settings = this.loadSettings();
+        switch (providerType) {
+            case 'gemini':
+                settings.cachedGeminiModels = models;
+                break;
+            case 'openrouter':
+                settings.cachedOpenRouterModels = models;
+                break;
+            case 'ollama':
+                settings.cachedOllamaModels = models;
+                break;
+            case 'bedrock':
+                settings.cachedBedrockModels = models;
+                break;
+            case 'openai':
+                settings.cachedOpenAIModels = models;
+                break;
+        }
+        this.saveSettings(settings);
+    }
+    /**
+     * Get cached models for a provider
+     */
+    static getCachedModels(providerType) {
+        const settings = this.loadSettings();
+        switch (providerType) {
+            case 'gemini':
+                return settings.cachedGeminiModels;
+            case 'openrouter':
+                return settings.cachedOpenRouterModels;
+            case 'ollama':
+                return settings.cachedOllamaModels;
+            case 'bedrock':
+                return settings.cachedBedrockModels;
+            case 'openai':
+                return settings.cachedOpenAIModels;
+            default:
+                return undefined;
+        }
+    }
+}
+exports.LLMProviderFactory = LLMProviderFactory;
+LLMProviderFactory.cachedSettings = null;
+LLMProviderFactory.migrationCompleted = false;