erosolar-cli 1.7.439 → 1.7.440

package/dist/core/modelDiscovery.js

@@ -0,0 +1,780 @@
+/**
+ * Model discovery system for auto-detecting new models from providers.
+ *
+ * This module queries provider APIs to discover available models and caches
+ * them for use alongside the static model schema. It never modifies the
+ * static schema - discoveries are stored separately and merged at runtime.
+ */
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { safeErrorMessage } from './secretStore.js';
+/**
+ * Discovered model cache file location
+ */
+const CACHE_DIR = join(homedir(), '.erosolar');
+const CACHE_FILE = join(CACHE_DIR, 'discovered-models.json');
+/**
+ * Cache expiration time (24 hours)
+ */
+const CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1000;
+/**
+ * Get cached discovered models
+ */
+export function getCachedDiscoveredModels() {
+    try {
+        if (!existsSync(CACHE_FILE)) {
+            return [];
+        }
+        const raw = readFileSync(CACHE_FILE, 'utf-8');
+        const cache = JSON.parse(raw);
+        // Check if cache is expired
+        const lastUpdated = new Date(cache.lastUpdated).getTime();
+        const now = Date.now();
+        if (now - lastUpdated > CACHE_EXPIRATION_MS) {
+            return [];
+        }
+        return cache.models;
+    }
+    catch (error) {
+        console.warn('Failed to read discovered models cache:', safeErrorMessage(error));
+        return [];
+    }
+}
+/**
+ * Save discovered models to cache
+ */
+async function saveDiscoveredModels(models) {
+    try {
+        await mkdir(CACHE_DIR, { recursive: true });
+        const cache = {
+            version: '1.0.0',
+            lastUpdated: new Date().toISOString(),
+            models,
+        };
+        writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf-8');
+    }
+    catch (error) {
+        console.warn('Failed to save discovered models cache:', safeErrorMessage(error));
+    }
+}
+/**
+ * Discover models from OpenAI
+ */
+async function discoverOpenAIModels(apiKey) {
+    const provider = 'openai';
+    try {
+        const response = await fetch('https://api.openai.com/v1/models', {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`API returned ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        // Filter for GPT models only and create ModelConfig objects
+        const models = data.data
+            .filter(model => model.id.startsWith('gpt-') ||
+            model.id.startsWith('o1-') ||
+            model.id.startsWith('o3-'))
+            .map(model => ({
+            id: model.id,
+            label: model.id,
+            provider,
+            description: `OpenAI ${model.id} (auto-discovered)`,
+            capabilities: ['chat', 'tools', 'streaming'],
+        }));
+        return {
+            provider,
+            success: true,
+            models,
+        };
+    }
+    catch (error) {
+        return {
+            provider,
+            success: false,
+            models: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Discover models from Anthropic
+ */
+async function discoverAnthropicModels(apiKey) {
+    const provider = 'anthropic';
+    try {
+        const response = await fetch('https://api.anthropic.com/v1/models', {
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`API returned ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        const models = data.data
+            .filter(model => model.type === 'model')
+            .map(model => ({
+            id: model.id,
+            label: model.display_name || model.id,
+            provider,
+            description: `Anthropic ${model.display_name || model.id} (auto-discovered)`,
+            capabilities: ['chat', 'reasoning', 'tools', 'streaming'],
+        }));
+        return {
+            provider,
+            success: true,
+            models,
+        };
+    }
+    catch (error) {
+        return {
+            provider,
+            success: false,
+            models: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Discover models from Google Gemini
+ * Note: Google's models API often requires special permissions.
+ * Falls back to known models if API access fails.
+ */
+async function discoverGoogleModels(apiKey) {
+    const provider = 'google';
+    // Known Google Gemini models (fallback if API doesn't work) - Updated Nov 2025
+    const knownModels = [
+        { id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro', provider, description: 'Most capable Gemini model with advanced reasoning', capabilities: ['chat', 'reasoning', 'tools', 'streaming', 'multimodal'] },
+        { id: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash', provider, description: 'Fast Gemini 2.5 with reasoning', capabilities: ['chat', 'reasoning', 'tools', 'streaming', 'multimodal'] },
+        { id: 'gemini-2.5-flash-lite', label: 'Gemini 2.5 Flash Lite', provider, description: 'Fast, low-cost Gemini 2.5', capabilities: ['chat', 'tools', 'streaming', 'multimodal'] },
+        { id: 'gemini-2.0-flash', label: 'Gemini 2.0 Flash', provider, description: 'Gemini 2.0 with native tool use', capabilities: ['chat', 'tools', 'streaming', 'multimodal'] },
+    ];
+    try {
+        // SECURITY: Use x-goog-api-key header instead of URL query parameter
+        // to prevent API key leakage in logs, error messages, and browser history
+        const response = await fetch('https://generativelanguage.googleapis.com/v1beta/models', {
+            headers: {
+                'x-goog-api-key': apiKey,
+            },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            // API access restricted - return known models with warning
+            return {
+                provider,
+                success: true, // Consider it success with fallback
+                models: knownModels,
+            };
+        }
+        const data = await response.json();
+        const models = data.models
+            .filter(model => model.name.includes('gemini') &&
+            model.supportedGenerationMethods?.includes('generateContent'))
+            .map(model => {
+            const id = model.name.replace('models/', '');
+            return {
+                id,
+                label: id,
+                provider,
+                description: `${model.displayName} (auto-discovered)`,
+                capabilities: ['chat', 'reasoning', 'tools', 'streaming', 'multimodal'],
+            };
+        });
+        return {
+            provider,
+            success: true,
+            models: models.length > 0 ? models : knownModels,
+        };
+    }
+    catch {
+        // Network error or timeout - return known models
+        return {
+            provider,
+            success: true,
+            models: knownModels,
+        };
+    }
+}
+/**
+ * Discover models from DeepSeek (OpenAI-compatible)
+ */
+async function discoverDeepSeekModels(apiKey) {
+    const provider = 'deepseek';
+    try {
+        const response = await fetch('https://api.deepseek.com/v1/models', {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`API returned ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        const models = data.data.map(model => ({
+            id: model.id,
+            label: model.id,
+            provider,
+            description: `DeepSeek ${model.id} (auto-discovered)`,
+            capabilities: ['chat', 'reasoning', 'tools', 'streaming'],
+        }));
+        return {
+            provider,
+            success: true,
+            models,
+        };
+    }
+    catch (error) {
+        return {
+            provider,
+            success: false,
+            models: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Discover models from xAI (OpenAI-compatible)
+ */
+async function discoverXAIModels(apiKey) {
+    const provider = 'xai';
+    try {
+        const response = await fetch('https://api.x.ai/v1/models', {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`API returned ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        const models = data.data.map(model => ({
+            id: model.id,
+            label: model.id,
+            provider,
+            description: `xAI ${model.id} (auto-discovered)`,
+            capabilities: ['chat', 'reasoning', 'tools', 'streaming'],
+        }));
+        return {
+            provider,
+            success: true,
+            models,
+        };
+    }
+    catch (error) {
+        return {
+            provider,
+            success: false,
+            models: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Discover models from Ollama (local)
+ */
+async function discoverOllamaModels() {
+    const provider = 'ollama';
+    const baseURL = process.env['OLLAMA_BASE_URL'] || 'http://localhost:11434';
+    try {
+        const response = await fetch(`${baseURL}/api/tags`, {
+            signal: AbortSignal.timeout(2000), // 2 second timeout
+        });
+        if (!response.ok) {
+            throw new Error(`API returned ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        const models = (data.models || []).map(model => ({
+            id: model.name,
+            label: model.name,
+            provider,
+            description: `Local Ollama model: ${model.name} (auto-discovered)`,
+            capabilities: ['chat', 'tools', 'streaming'],
+        }));
+        return {
+            provider,
+            success: true,
+            models,
+        };
+    }
+    catch (error) {
+        return {
+            provider,
+            success: false,
+            models: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Discover models from all configured providers
+ *
+ * PERF: Uses Promise.allSettled for parallel discovery - all providers queried
+ * simultaneously. No single slow/failed provider blocks the others.
+ */
+export async function discoverAllModels() {
+    const errors = [];
+    let totalModelsDiscovered = 0;
+    // Discover from each provider if API key is available
+    const providers = [
+        { id: 'openai', envVar: 'OPENAI_API_KEY', discover: discoverOpenAIModels },
+        { id: 'anthropic', envVar: 'ANTHROPIC_API_KEY', discover: discoverAnthropicModels },
+        { id: 'google', envVar: 'GEMINI_API_KEY', discover: discoverGoogleModels },
+        { id: 'deepseek', envVar: 'DEEPSEEK_API_KEY', discover: discoverDeepSeekModels },
+        { id: 'xai', envVar: 'XAI_API_KEY', discover: discoverXAIModels },
+    ];
+    // PERF: Build discovery promises in parallel
+    const discoveryPromises = providers.map(async (provider) => {
+        const apiKey = process.env[provider.envVar];
+        if (!apiKey) {
+            return {
+                provider: provider.id,
+                success: false,
+                models: [],
+                error: `API key not configured (${provider.envVar})`,
+            };
+        }
+        try {
+            return await provider.discover(apiKey);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                provider: provider.id,
+                success: false,
+                models: [],
+                error: errorMessage,
+            };
+        }
+    });
+    // Add Ollama discovery (no API key required)
+    discoveryPromises.push(discoverOllamaModels().catch(() => ({
+        provider: 'ollama',
+        success: false,
+        models: [],
+        error: 'Connection failed',
+    })));
+    // PERF: Execute ALL provider discoveries in parallel using Promise.allSettled
+    // This ensures one slow/failed provider doesn't block others
+    const settledResults = await Promise.allSettled(discoveryPromises);
+    // Process results
+    const results = settledResults.map((settled, index) => {
+        if (settled.status === 'fulfilled') {
+            return settled.value;
+        }
+        // Promise rejected (shouldn't happen with our error handling, but be safe)
+        const providerId = index < providers.length
+            ? providers[index].id
+            : 'ollama';
+        return {
+            provider: providerId,
+            success: false,
+            models: [],
+            error: settled.reason instanceof Error ? settled.reason.message : String(settled.reason),
+        };
+    });
+    // Collect errors and count models
+    for (const result of results) {
+        if (result.success) {
+            totalModelsDiscovered += result.models.length;
+        }
+        else if (result.error) {
+            // Don't add Ollama connection errors (it's often not running)
+            if (result.provider === 'ollama' &&
+                (result.error.includes('ECONNREFUSED') ||
+                    result.error.includes('fetch failed') ||
+                    result.error.includes('Connection failed'))) {
+                continue;
+            }
+            errors.push(`${result.provider}: ${result.error}`);
+        }
+    }
+    // Collect all discovered models
+    const allModels = results
+        .filter(r => r.success)
+        .flatMap(r => r.models);
+    // Save to cache
+    if (allModels.length > 0) {
+        await saveDiscoveredModels(allModels);
+    }
+    return {
+        success: errors.length === 0,
+        timestamp: new Date().toISOString(),
+        results,
+        totalModelsDiscovered,
+        errors,
+    };
+}
+/**
+ * Clear the discovered models cache
+ */
+export function clearDiscoveredModelsCache() {
+    try {
+        if (existsSync(CACHE_FILE)) {
+            writeFileSync(CACHE_FILE, JSON.stringify({ version: '1.0.0', lastUpdated: new Date().toISOString(), models: [] }, null, 2), 'utf-8');
+        }
+    }
+    catch (error) {
+        console.warn('Failed to clear discovered models cache:', safeErrorMessage(error));
+    }
+}
+/**
+ * Supported providers with their environment variable requirements
+ */
+const PROVIDER_CONFIGS = [
+    { id: 'anthropic', name: 'Anthropic', envVar: 'ANTHROPIC_API_KEY', defaultLatestModel: 'claude-opus-4-5-20251101' },
+    { id: 'openai', name: 'OpenAI', envVar: 'OPENAI_API_KEY', defaultLatestModel: 'gpt-5.1-codex' },
+    { id: 'google', name: 'Google', envVar: 'GEMINI_API_KEY', altEnvVars: ['GOOGLE_API_KEY'], defaultLatestModel: 'gemini-2.5-pro' },
+    { id: 'deepseek', name: 'DeepSeek', envVar: 'DEEPSEEK_API_KEY', defaultLatestModel: 'deepseek-reasoner' },
+    { id: 'xai', name: 'xAI', envVar: 'XAI_API_KEY', defaultLatestModel: 'grok-4-1-fast-reasoning' },
+    { id: 'ollama', name: 'Ollama', envVar: 'OLLAMA_BASE_URL', defaultLatestModel: 'llama3.3:70b' },
+];
+/**
+ * Model priority rankings for selecting the "best" model
+ */
+const MODEL_PRIORITIES = {
+    openai: {
+        'gpt-5.1-codex': 100,
+        'gpt-5.1-codex-mini': 98,
+        'gpt-5.1': 96,
+        'gpt-5-pro': 94,
+        'gpt-5-mini': 92,
+        'gpt-5-nano': 90,
+    },
+    anthropic: {
+        'claude-opus-4-5': 100,
+        'claude-opus-4-5-20251101': 100,
+        'claude-sonnet-4-5': 98,
+        'claude-sonnet-4-5-20250929': 98,
+        'claude-opus-4-20250514': 95,
+        'claude-opus-4': 95,
+        'claude-sonnet-4': 92,
+        'claude-3-5-sonnet-20241022': 88,
+        'claude-3-5-haiku-20241022': 85,
+        'claude-3-opus-20240229': 80,
+        'claude-3-sonnet-20240229': 75,
+        'claude-3-haiku-20240307': 70,
+    },
+    google: {
+        'gemini-3.0-pro': 100,
+        'gemini-3.0-flash': 98,
+        'gemini-2.5-pro': 95,
+        'gemini-2.5-flash': 93,
+        'gemini-2.0-flash': 90,
+        'gemini-2.0': 88,
+        'gemini-1.5-pro': 80,
+        'gemini-1.5-flash': 75,
+        'gemini-1.0': 50,
+    },
+    deepseek: {
+        'deepseek-reasoner': 100,
+        'deepseek-chat': 90,
+        'deepseek-coder': 85,
+    },
+    xai: {
+        'grok-4-1-fast-reasoning': 100,
+        'grok-4-1-fast-non-reasoning': 98,
+        'grok-4-fast-reasoning': 95,
+        'grok-4-fast-non-reasoning': 93,
+        'grok-4': 90,
+        'grok-code-fast-1': 88,
+        'grok-3': 85,
+        'grok-3-mini': 80,
+        'grok-2-vision-1212': 75,
+        'grok-2-1212': 70,
+        'grok-beta': 60,
+    },
+};
+/**
+ * Get model priority for sorting
+ */
+function getModelPriority(provider, modelId) {
+    const priorities = MODEL_PRIORITIES[provider];
+    if (!priorities)
+        return 0;
+    // Check for exact match first
+    if (priorities[modelId] !== undefined) {
+        return priorities[modelId];
+    }
+    // Check for prefix match
+    for (const [prefix, priority] of Object.entries(priorities)) {
+        if (modelId.startsWith(prefix)) {
+            return priority;
+        }
+    }
+    return 0;
+}
+/**
+ * Sort models by priority (best first)
+ */
+export function sortModelsByPriority(provider, models) {
+    return [...models].sort((a, b) => {
+        const priorityA = getModelPriority(provider, a);
+        const priorityB = getModelPriority(provider, b);
+        return priorityB - priorityA;
+    });
+}
+/**
+ * Get the best/latest model for a provider
+ */
+export function getBestModel(provider, models) {
+    if (models.length === 0) {
+        const config = PROVIDER_CONFIGS.find(p => p.id === provider);
+        return config?.defaultLatestModel || '';
+    }
+    const sorted = sortModelsByPriority(provider, models);
+    return sorted[0] ?? models[0] ?? '';
+}
+/**
+ * Check if a provider is configured (has API key or is accessible)
+ */
+export function isProviderConfigured(providerId) {
+    const config = PROVIDER_CONFIGS.find(p => p.id === providerId);
+    if (!config)
+        return false;
+    // Ollama is special - it's available if the server is running (no API key needed)
+    if (providerId === 'ollama') {
+        // We'll check this via actual connection, return true for now
+        // The actual check happens in getConfiguredProviders
+        return true;
+    }
+    // Check main env var
+    if (process.env[config.envVar]) {
+        return true;
+    }
+    // Check alternative env vars
+    if (config.altEnvVars) {
+        for (const altVar of config.altEnvVars) {
+            if (process.env[altVar]) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Get all providers with their configuration status
+ */
+export function getProvidersStatus() {
+    return PROVIDER_CONFIGS.map(config => {
+        let configured = false;
+        if (config.id === 'ollama') {
+            // For Ollama, we can't check synchronously if it's running
+            // Mark as potentially available
+            configured = !!process.env['OLLAMA_BASE_URL'] || true; // Always show Ollama as option
+        }
+        else {
+            configured = !!process.env[config.envVar];
+            if (!configured && config.altEnvVars) {
+                configured = config.altEnvVars.some(v => !!process.env[v]);
+            }
+        }
+        return {
+            id: config.id,
+            name: config.name,
+            envVar: config.envVar,
+            configured,
+            latestModel: config.defaultLatestModel,
+        };
+    });
+}
+/**
+ * Get list of configured providers (with valid API keys)
+ */
+export function getConfiguredProviders() {
+    return getProvidersStatus().filter(p => p.configured);
+}
+/**
+ * Get list of unconfigured providers
+ */
+export function getUnconfiguredProviders() {
+    return getProvidersStatus().filter(p => !p.configured);
+}
+/**
+ * Get the first available provider (for auto-selection)
+ */
+export function getFirstAvailableProvider() {
+    const configured = getConfiguredProviders();
+    // Prefer in this order: anthropic, openai, google, deepseek, xai, ollama
+    const preferenceOrder = ['anthropic', 'openai', 'google', 'deepseek', 'xai', 'ollama'];
+    for (const providerId of preferenceOrder) {
+        const provider = configured.find(p => p.id === providerId);
+        if (provider && provider.id !== 'ollama') {
+            return provider;
+        }
+    }
+    // Fall back to Ollama if nothing else is configured
+    return configured.find(p => p.id === 'ollama') || null;
+}
+/**
+ * Get latest model for a provider from cache or defaults
+ */
+export function getLatestModelForProvider(providerId) {
+    // Check cache first
+    const cached = getCachedDiscoveredModels();
+    const providerModels = cached.filter(m => m.provider === providerId);
+    if (providerModels.length > 0) {
+        const modelIds = providerModels.map(m => m.id);
+        return getBestModel(providerId, modelIds);
+    }
+    // Fall back to default
+    const config = PROVIDER_CONFIGS.find(p => p.id === providerId);
+    return config?.defaultLatestModel || '';
+}
+/**
+ * Quick API check for a single provider - returns best model or null
+ */
+async function quickFetchProviderModels(providerId, apiKey, timeoutMs = 3000) {
+    try {
+        switch (providerId) {
+            case 'openai': {
+                const response = await fetch('https://api.openai.com/v1/models', {
+                    headers: { 'Authorization': `Bearer ${apiKey}` },
+                    signal: AbortSignal.timeout(timeoutMs),
+                });
+                if (!response.ok)
+                    return [];
+                const data = await response.json();
+                return data.data
+                    .filter(m => m.id.startsWith('gpt-') || m.id.startsWith('o1-') || m.id.startsWith('o3-'))
+                    .map(m => m.id);
+            }
+            case 'anthropic': {
+                const response = await fetch('https://api.anthropic.com/v1/models', {
+                    headers: {
+                        'x-api-key': apiKey,
+                        'anthropic-version': '2023-06-01',
+                    },
+                    signal: AbortSignal.timeout(timeoutMs),
+                });
+                if (!response.ok)
+                    return [];
+                const data = await response.json();
+                return data.data.filter(m => m.type === 'model').map(m => m.id);
+            }
+            case 'google': {
+                // SECURITY: Use x-goog-api-key header instead of URL query parameter
+                const response = await fetch('https://generativelanguage.googleapis.com/v1beta/models', {
+                    headers: {
+                        'x-goog-api-key': apiKey,
+                    },
+                    signal: AbortSignal.timeout(timeoutMs),
+                });
+                if (!response.ok)
+                    return [];
+                const data = await response.json();
+                return data.models
+                    .filter(m => m.name.includes('gemini') && m.supportedGenerationMethods?.includes('generateContent'))
+                    .map(m => m.name.replace('models/', ''));
+            }
+            case 'deepseek': {
+                const response = await fetch('https://api.deepseek.com/v1/models', {
+                    headers: { 'Authorization': `Bearer ${apiKey}` },
+                    signal: AbortSignal.timeout(timeoutMs),
+                });
+                if (!response.ok)
+                    return [];
+                const data = await response.json();
+                return data.data.map(m => m.id);
+            }
+            case 'xai': {
+                const response = await fetch('https://api.x.ai/v1/models', {
+                    headers: { 'Authorization': `Bearer ${apiKey}` },
+                    signal: AbortSignal.timeout(timeoutMs),
+                });
+                if (!response.ok)
+                    return [];
+                const data = await response.json();
+                return data.data.map(m => m.id);
+            }
+            default:
+                return [];
+        }
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Quickly check if providers are available by querying their APIs
+ * Returns actual latest models from each provider
+ */
+export async function quickCheckProviders() {
+    const checks = [];
+    for (const config of PROVIDER_CONFIGS) {
+        // Handle Ollama separately (no API key needed)
+        if (config.id === 'ollama') {
+            checks.push((async () => {
+                try {
+                    const baseURL = process.env['OLLAMA_BASE_URL'] || 'http://localhost:11434';
+                    const response = await fetch(`${baseURL}/api/tags`, {
+                        signal: AbortSignal.timeout(1500),
+                    });
+                    if (response.ok) {
+                        const data = await response.json();
+                        const models = data.models?.map(m => m.name) || [];
+                        return {
+                            provider: 'ollama',
+                            available: models.length > 0,
+                            latestModel: models[0] || config.defaultLatestModel,
+                        };
+                    }
+                }
+                catch { /* ignore */ }
+                return {
+                    provider: 'ollama',
+                    available: false,
+                    latestModel: config.defaultLatestModel,
+                    error: 'Not running',
+                };
+            })());
+            continue;
+        }
+        // Check for API key
+        let apiKey = process.env[config.envVar];
+        if (!apiKey && config.altEnvVars) {
+            for (const altVar of config.altEnvVars) {
+                if (process.env[altVar]) {
+                    apiKey = process.env[altVar];
+                    break;
+                }
+            }
+        }
+        if (!apiKey) {
+            checks.push(Promise.resolve({
+                provider: config.id,
+                available: false,
+                latestModel: config.defaultLatestModel,
+                error: `${config.envVar} not set`,
+            }));
+            continue;
+        }
+        // Query the API for actual models
+        checks.push((async () => {
+            const models = await quickFetchProviderModels(config.id, apiKey, 3000);
+            if (models.length > 0) {
+                const bestModel = getBestModel(config.id, models);
+                return {
+                    provider: config.id,
+                    available: true,
+                    latestModel: bestModel,
+                };
+            }
+            // API call failed or returned no models - still mark available if key exists
+            return {
+                provider: config.id,
+                available: true,
+                latestModel: config.defaultLatestModel,
+                error: 'Could not fetch models',
+            };
+        })());
+    }
+    // Run all checks in parallel for speed
+    return Promise.all(checks);
+}
+//# sourceMappingURL=modelDiscovery.js.map