@calliopelabs/cli 3.1.0 → 3.2.0

package/dist/model-detection.js

@@ -6,7 +6,65 @@
 import OpenAI from 'openai';
 import { select } from '@inquirer/prompts';
 import * as config from './config.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { cancellable, throwIfCancelled } from './cancellation.js';
+import { bindProcessCancellation, detachedProcess } from './process-cancellation.js';
+import { createHash } from 'node:crypto';
+import { ModelDiscoveryError, compatibleMetadata, anthropicMetadata, openRouterPricing, capability, positiveLimit, price, stringList, validateModels } from './models/index.js';
 const DEBUG = process.env.CALLIOPE_DEBUG === '1';
+const discoveryContext = new AsyncLocalStorage();
+function fetchModelMetadata(input, init) {
+    const signal = discoveryContext.getStore()?.signal;
+    throwIfCancelled(signal);
+    if (!signal)
+        return init === undefined ? fetch(input) : fetch(input, init);
+    return fetch(input, { ...init, signal: init?.signal ? AbortSignal.any([signal, init.signal]) : signal });
+}
+function discoveryTransportOptions() {
+    return discoveryContext.getStore()?.signal ? { fetch: fetchModelMetadata, maxRetries: 0 } : {};
+}
+/** Follow provider cursors only on the original endpoint, with fixed page/item caps. */
+async function modelPages(endpoint, kind, headers) {
+    const models = [], seen = new Set();
+    let cursor = '';
+    for (let page = 0; page < 20; page++) {
+        const url = new URL(endpoint);
+        if (cursor)
+            url.searchParams.set(kind === 'anthropic' ? 'after_id' : 'pageToken', cursor);
+        const response = await fetchModelMetadata(url.toString(), headers ? { headers } : undefined);
+        if (!response.ok)
+            throw new Error(`Model discovery HTTP ${response.status}`);
+        const data = await response.json();
+        const items = data[kind === 'anthropic' ? 'data' : 'models'];
+        if (!Array.isArray(items) || models.length + items.length > 10000)
+            throw new ModelDiscoveryError('Invalid model discovery page');
+        models.push(...items);
+        if (kind === 'anthropic' && data.has_more !== undefined && typeof data.has_more !== 'boolean')
+            throw new ModelDiscoveryError('Invalid discovery pagination');
+        if (kind === 'anthropic' && data.has_more && (typeof data.last_id !== 'string' || !data.last_id))
+            throw new ModelDiscoveryError('Missing discovery cursor');
+        const next = kind === 'anthropic' ? (data.has_more ? data.last_id : undefined) : data.nextPageToken;
+        if (next === undefined || next === null || next === '')
+            return models;
+        if (typeof next !== 'string' || next.length > 4096 || seen.has(next))
+            throw new ModelDiscoveryError('Invalid model discovery cursor');
+        seen.add(next);
+        cursor = next;
+    }
+    throw new ModelDiscoveryError('Model discovery page budget exceeded');
+}
+/** Scope transport cancellation to this discovery call, including concurrent probes. */
+export async function getAvailableModels(provider, options = {}) {
+    throwIfCancelled(options.signal);
+    return discoveryContext.run({ ...options, cleanups: [] }, async () => {
+        try {
+            return await cancellable(loadAvailableModels(provider, options), options.signal);
+        }
+        finally {
+            await Promise.allSettled(discoveryContext.getStore().cleanups);
+        }
+    });
+}
 function logModelDetectionWarning(message, error, options = {}) {
     if (options.quiet || !DEBUG) {
         return;
@@ -25,7 +83,10 @@ const PROVIDER_BASE_URLS = {
     fireworks: 'https://api.fireworks.ai/inference/v1',
     mistral: 'https://api.mistral.ai/v1',
     ai21: 'https://api.ai21.com/studio/v1',
-    huggingface: 'https://api-inference.huggingface.co/v1',
+    huggingface: 'https://router.huggingface.co/v1',
+    deepseek: 'https://api.deepseek.com',
+    xai: 'https://api.x.ai/v1',
+    cerebras: 'https://api.cerebras.ai/v1',
     // Bedrock uses a configurable gateway URL, not a fixed URL
 };
 /**
@@ -57,6 +118,7 @@ const INCOMPATIBLE_MODEL_PATTERNS = {
         /^text-embedding/, // Text embedding
         /^aqa/, // Attributed QA (not chat)
         /embedding$/, // Any model ending in embedding
+        /computer-use/i, // Requires the dedicated Computer Use tool contract
     ],
     groq: [
         /^whisper/, // Speech-to-text
@@ -114,6 +176,48 @@ function isCompatibleModel(modelId, provider) {
 // Model cache to avoid repeated API calls
 const modelCache = new Map();
 const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+const previousDiscovery = new Map();
+/** Stale negative capability evidence still blocks an unverified fallback. */
+export function getPreviousDiscoveredModels(provider) {
+    const previous = previousDiscovery.get(provider);
+    return previous?.target === modelCacheTarget(provider) ? structuredClone(previous.models) : undefined;
+}
+function modelCacheTarget(provider) {
+    const profile = provider === 'bedrock' ? config.getProviderCred(provider) : { profile: undefined, region: undefined };
+    return createHash('sha256').update(JSON.stringify([provider, config.getBaseUrl(provider), config.getApiKey(provider), profile.profile, profile.region])).digest('hex');
+}
+export function getDiscoveredModels(provider) {
+    const cached = modelCache.get(provider);
+    if (!cached || cached.target !== modelCacheTarget(provider) || Date.now() - cached.timestamp >= CACHE_DURATION || cached.models.some(model => model.evidence?.source !== 'live'))
+        return undefined;
+    return structuredClone(cached.models);
+}
+/** Anthropic explicitly supports resolving aliases through Models.retrieve. */
+export async function resolveModelAlias(provider, alias, signal) {
+    if (provider !== 'anthropic')
+        return undefined;
+    throwIfCancelled(signal);
+    const key = config.getApiKey(provider);
+    if (!key)
+        return undefined;
+    const target = modelCacheTarget(provider);
+    const response = await cancellable(fetch(`${(config.getBaseUrl('anthropic') || 'https://api.anthropic.com').replace(/\/v1\/?$/, '').replace(/\/$/, '')}/v1/models/${encodeURIComponent(alias)}`, {
+        headers: { 'x-api-key': key, 'anthropic-version': '2023-06-01' }, signal,
+    }), signal);
+    if (!response.ok)
+        return undefined;
+    const body = await cancellable(response.json(), signal);
+    const model = { id: body.id, name: body.display_name, aliases: [alias], ...anthropicMetadata(body), evidence: { source: 'live', at: new Date().toISOString() } };
+    validateModels([model]);
+    throwIfCancelled(signal);
+    const cached = modelCache.get(provider);
+    if (cached?.target === target && modelCacheTarget(provider) === target) {
+        model.aliases = [...new Set([...(cached.models.find(item => item.id === model.id)?.aliases ?? []), alias])];
+        cached.models = [...cached.models.filter(item => item.id !== model.id), model];
+        previousDiscovery.set(provider, { models: structuredClone(cached.models), target });
+    }
+    return model;
+}
 /**
  * Get available models for a provider with interactive selection
  */
@@ -158,8 +262,8 @@ function formatModelChoice(model) {
         display += ` (${formatContextLength(model.contextLength)})`;
     }
     if (model.pricing) {
-        const inputPrice = model.pricing.input ? `$${model.pricing.input.toFixed(2)}/1M` : '';
-        const outputPrice = model.pricing.output ? `$${model.pricing.output.toFixed(2)}/1M` : '';
+        const inputPrice = model.pricing.input !== undefined ? `$${model.pricing.input.toFixed(2)}/1M` : '';
+        const outputPrice = model.pricing.output !== undefined ? `$${model.pricing.output.toFixed(2)}/1M` : '';
         if (inputPrice || outputPrice) {
             display += ` - ${inputPrice}${inputPrice && outputPrice ? '/' : ''}${outputPrice}`;
         }
@@ -183,11 +287,15 @@ function formatContextLength(tokens) {
 /**
  * Get available models for a provider
  */
-export async function getAvailableModels(provider, options = {}) {
+async function loadAvailableModels(provider, options) {
     // Check cache first
     const cached = modelCache.get(provider);
-    if (cached && Date.now() - cached.timestamp < CACHE_DURATION) {
-        return cached.models;
+    const target = modelCacheTarget(provider);
+    // Strict callers require current wire evidence; a cached emergency fallback
+    // must never masquerade as successful live discovery.
+    if (cached?.target === target && Date.now() - cached.timestamp < CACHE_DURATION &&
+        (!options.throwOnError || (options.cache === 'live' && cached.models.every(model => model.evidence?.source === 'live')))) {
+        return structuredClone(cached.models);
     }
     let models = [];
     try {
@@ -222,6 +330,9 @@ export async function getAvailableModels(provider, options = {}) {
             case 'ai21':
             case 'huggingface':
             case 'fireworks':
+            case 'deepseek':
+            case 'xai':
+            case 'cerebras':
                 models = await getOpenAICompatibleModels(provider);
                 break;
             case 'bedrock':
@@ -233,8 +344,16 @@ export async function getAvailableModels(provider, options = {}) {
             default:
                 throw new Error(`Model detection not implemented for ${provider}`);
         }
+        throwIfCancelled(options.signal);
         // Cache the results
-        modelCache.set(provider, { models, timestamp: Date.now() });
+        const timestamp = Date.now();
+        models = validateModels(models).map(model => ({ ...model, evidence: model.evidence ?? { source: 'live', at: new Date(timestamp).toISOString() } }));
+        // Endpoint/credential changes during discovery cannot populate a new target's cache.
+        if (modelCacheTarget(provider) === target) {
+            modelCache.set(provider, { models: structuredClone(models), timestamp, target });
+            if (models.every(model => model.evidence?.source === 'live'))
+                previousDiscovery.set(provider, { models: structuredClone(models), target });
+        }
     }
     catch (error) {
         logModelDetectionWarning(`Failed to fetch models for ${provider}:`, error, options);
@@ -251,37 +370,28 @@ async function getAnthropicModels(options = {}) {
     if (!apiKey)
         throw new Error('Anthropic API key not configured');
     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(`Anthropic API error: ${response.status}`);
-        }
-        const data = await response.json();
-        return data.data
+        const models = await modelPages(`${(config.getBaseUrl('anthropic') || 'https://api.anthropic.com').replace(/\/v1\/?$/, '').replace(/\/$/, '')}/v1/models`, 'anthropic', { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' });
+        return models
             .filter(model => model.id.startsWith('claude'))
             .map(model => ({
             id: model.id,
             name: model.display_name || formatModelName(model.id),
             description: getAnthropicModelDescription(model.id),
-            // The /v1/models list endpoint does not return the context window;
-            // derive it per model family rather than hardcoding a single value.
-            contextLength: getModelContextLimit('anthropic', model.id),
+            ...anthropicMetadata(model),
         }))
             .sort((a, b) => b.id.localeCompare(a.id)); // Newest first
     }
     catch (error) {
         // Emergency fallback when the API is unreachable. Keep these as the current
         // shipping models — discovery is the source of truth; this is the offline net.
+        if (options.throwOnError)
+            throw error;
         logModelDetectionWarning('Failed to fetch Anthropic models, using fallback list', error, options);
         return [
             { id: 'claude-opus-4-8', name: 'Claude Opus 4.8', description: 'Most capable model', contextLength: 1000000 },
             { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6', description: 'Balanced intelligence and speed', contextLength: 1000000 },
             { id: 'claude-haiku-4-5', name: 'Claude Haiku 4.5', description: 'Fast and affordable', contextLength: 200000 },
-        ];
+        ].map(model => ({ ...model, evidence: { source: 'emergency', at: new Date().toISOString() } }));
     }
 }
 function formatModelName(modelId) {
@@ -311,12 +421,8 @@ async function getGoogleModels(options = {}) {
         throw new Error('Google API key not configured');
     try {
         // Use REST API directly for model listing
-        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
-        if (!response.ok) {
-            throw new Error(`Google API error: ${response.status}`);
-        }
-        const data = await response.json();
-        return data.models
+        const models = await modelPages(`${(config.getBaseUrl('google') || 'https://generativelanguage.googleapis.com').replace(/\/v1beta\/?$/, '').replace(/\/$/, '')}/v1beta/models?key=${encodeURIComponent(apiKey)}`, 'google');
+        return models
             .filter(model => {
             const modelId = model.name.replace('models/', '');
             return model.name.includes('gemini') && isCompatibleModel(modelId, 'google');
@@ -325,12 +431,16 @@ async function getGoogleModels(options = {}) {
             id: model.name.replace('models/', ''),
             name: model.displayName || model.name.replace('models/', ''),
             description: model.description || 'Google Gemini model',
-            contextLength: model.inputTokenLimit || 1048576,
+            contextLength: positiveLimit(model.inputTokenLimit),
+            maxOutputTokens: positiveLimit(model.outputTokenLimit),
+            capabilities: { chat: stringList(model.supportedGenerationMethods)?.includes('generateContent'), thinking: capability(model.thinking) },
         }))
             .sort((a, b) => b.id.localeCompare(a.id)); // Newest first
     }
     catch (error) {
         // Fallback to known models if API fails
+        if (options.throwOnError)
+            throw error;
         logModelDetectionWarning('Failed to fetch Google models, using fallback list', error, options);
         return [
             { id: 'gemini-2.5-pro-preview-06-05', name: 'Gemini 2.5 Pro', description: 'Most capable', contextLength: 1048576 },
@@ -338,7 +448,7 @@ async function getGoogleModels(options = {}) {
             { id: 'gemini-2.0-flash', name: 'Gemini 2.0 Flash', description: 'Multimodal', contextLength: 1048576 },
             { id: 'gemini-1.5-pro-latest', name: 'Gemini 1.5 Pro', description: 'Complex reasoning', contextLength: 2097152 },
             { id: 'gemini-1.5-flash-latest', name: 'Gemini 1.5 Flash', description: 'Fast and versatile', contextLength: 1048576 },
-        ];
+        ].map(model => ({ ...model, evidence: { source: 'emergency', at: new Date().toISOString() } }));
     }
 }
 /**
@@ -348,7 +458,7 @@ async function getOpenAIModels() {
     const apiKey = config.getApiKey('openai');
     if (!apiKey)
         throw new Error('OpenAI API key not configured');
-    const client = new OpenAI({ apiKey });
+    const client = new OpenAI({ apiKey, baseURL: config.getBaseUrl('openai'), ...discoveryTransportOptions() });
     const response = await client.models.list();
     // Filter for chat-compatible models (GPT and reasoning models)
     return response.data
@@ -361,6 +471,7 @@ async function getOpenAIModels() {
         id: model.id,
         name: model.id,
         description: getOpenAIModelDescription(model.id),
+        ...compatibleMetadata(model),
     }))
         .sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -371,7 +482,7 @@ async function getOpenRouterModels() {
     const apiKey = config.getApiKey('openrouter');
     if (!apiKey)
         throw new Error('OpenRouter API key not configured');
-    const response = await fetch('https://openrouter.ai/api/v1/models', {
+    const response = await fetchModelMetadata(`${(config.getBaseUrl('openrouter') || 'https://openrouter.ai/api/v1').replace(/\/+$/, '')}/models`, {
         headers: {
             'Authorization': `Bearer ${apiKey}`,
             'HTTP-Referer': 'https://calliope.ai',
@@ -409,11 +520,11 @@ async function getOpenRouterModels() {
         id: model.id,
         name: model.name,
         description: model.description,
-        contextLength: model.context_length,
-        pricing: {
-            input: parseFloat(model.pricing?.prompt || '0') * 1000000, // Convert to per 1M tokens
-            output: parseFloat(model.pricing?.completion || '0') * 1000000
-        }
+        contextLength: positiveLimit(model.context_length),
+        maxOutputTokens: positiveLimit(model.top_provider?.max_completion_tokens),
+        capabilities: { chat: true, tools: model.supported_parameters ? model.supported_parameters.includes('tools') : undefined,
+            vision: model.architecture?.input_modalities ? model.architecture.input_modalities.includes('image') : undefined },
+        pricing: openRouterPricing(model.pricing)
     }));
 }
 /**
@@ -424,7 +535,7 @@ async function getTogetherModels() {
     if (!apiKey)
         throw new Error('Together API key not configured');
     // Together's API returns a raw array, not wrapped in { data: [...] } like OpenAI
-    const response = await fetch('https://api.together.xyz/v1/models', {
+    const response = await fetchModelMetadata(`${(config.getBaseUrl('together') || 'https://api.together.xyz/v1').replace(/\/+$/, '')}/models`, {
         headers: {
             'Authorization': `Bearer ${apiKey}`,
         }
@@ -440,10 +551,11 @@ async function getTogetherModels() {
         id: model.id,
         name: model.display_name || model.id,
         description: getTogetherModelDescription(model.id),
-        contextLength: model.context_length,
+        ...compatibleMetadata(model),
+        contextLength: positiveLimit(model.context_length),
         pricing: model.pricing ? {
-            input: model.pricing.input,
-            output: model.pricing.output,
+            input: price(model.pricing.input),
+            output: price(model.pricing.output),
         } : undefined,
     }))
         .sort((a, b) => a.name.localeCompare(b.name));
@@ -456,8 +568,9 @@ async function getGroqModels() {
     if (!apiKey)
         throw new Error('Groq API key not configured');
     const client = new OpenAI({
+        ...discoveryTransportOptions(),
         apiKey,
-        baseURL: 'https://api.groq.com/openai/v1'
+        baseURL: config.getBaseUrl('groq') || 'https://api.groq.com/openai/v1'
     });
     const response = await client.models.list();
     return response.data
@@ -466,6 +579,7 @@ async function getGroqModels() {
         id: model.id,
         name: model.id,
         description: 'High-speed inference model',
+        ...compatibleMetadata(model),
     }));
 }
 /**
@@ -476,8 +590,9 @@ async function getMistralModels() {
     if (!apiKey)
         throw new Error('Mistral API key not configured');
     const client = new OpenAI({
+        ...discoveryTransportOptions(),
         apiKey,
-        baseURL: 'https://api.mistral.ai/v1'
+        baseURL: config.getBaseUrl('mistral') || 'https://api.mistral.ai/v1'
     });
     const response = await client.models.list();
     return response.data
@@ -486,6 +601,7 @@ async function getMistralModels() {
         id: model.id,
         name: model.id,
         description: getMistralModelDescription(model.id),
+        ...compatibleMetadata(model),
     }));
 }
 /**
@@ -498,7 +614,7 @@ async function getOllamaModels() {
         baseUrl = baseUrl.slice(0, -3);
     }
     try {
-        const response = await fetch(`${baseUrl}/api/tags`);
+        const response = await fetchModelMetadata(`${baseUrl}/api/tags`);
         if (!response.ok) {
             throw new Error(`Ollama API error: ${response.status}`);
         }
@@ -508,26 +624,30 @@ async function getOllamaModels() {
         const results = [];
         for (const model of models) {
             let contextLength;
+            let capabilities;
             try {
-                const showResp = await fetch(`${baseUrl}/api/show`, {
+                const showResp = await fetchModelMetadata(`${baseUrl}/api/show`, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
                     body: JSON.stringify({ name: model.name }),
                 });
                 if (showResp.ok) {
                     const showData = await showResp.json();
+                    const supported = stringList(showData.capabilities);
+                    if (supported)
+                        capabilities = { chat: supported.includes('completion'), tools: supported.includes('tools'), vision: supported.includes('vision'), thinking: supported.includes('thinking') };
                     // Check model_info for context length keys
                     if (showData.model_info) {
                         const ctxKey = Object.keys(showData.model_info).find(k => k.includes('context_length') || k.includes('context_window'));
                         if (ctxKey && typeof showData.model_info[ctxKey] === 'number') {
-                            contextLength = showData.model_info[ctxKey];
+                            contextLength = positiveLimit(showData.model_info[ctxKey]);
                         }
                     }
                     // Also check Modelfile parameters for num_ctx override
                     if (showData.parameters) {
                         const numCtxMatch = showData.parameters.match(/num_ctx\s+(\d+)/);
                         if (numCtxMatch) {
-                            contextLength = parseInt(numCtxMatch[1], 10);
+                            contextLength = positiveLimit(parseInt(numCtxMatch[1], 10));
                         }
                     }
                 }
@@ -537,14 +657,20 @@ async function getOllamaModels() {
             }
             results.push({
                 id: model.name,
+                capabilities,
                 name: model.name,
                 description: `Size: ${formatSize(model.size)}${model.details?.parameter_size ? ` (${model.details.parameter_size})` : ''}`,
                 contextLength,
+                // Ollama does not expose a separate output limit. Bound generation by
+                // the live context window so execution admission can remain fail-closed.
+                maxOutputTokens: contextLength === undefined ? undefined : Math.min(contextLength, 8192),
             });
         }
         return results;
     }
     catch (error) {
+        if (error instanceof ModelDiscoveryError || error instanceof SyntaxError || error instanceof TypeError)
+            throw error;
         throw new Error(`Failed to connect to Ollama at ${baseUrl}. Is Ollama running? Try: ollama serve`);
     }
 }
@@ -584,7 +710,7 @@ async function getLiteLLMModels() {
         baseUrl = baseUrl.slice(0, -3);
     }
     try {
-        const response = await fetch(`${baseUrl}/v1/models`);
+        const response = await fetchModelMetadata(`${baseUrl}/v1/models`);
         if (!response.ok) {
             throw new Error(`LiteLLM API error: ${response.status}`);
         }
@@ -595,9 +721,12 @@ async function getLiteLLMModels() {
             id: model.id,
             name: model.id,
             description: 'Proxied via LiteLLM',
+            ...compatibleMetadata(model),
         }));
     }
     catch (error) {
+        if (error instanceof ModelDiscoveryError || error instanceof SyntaxError || error instanceof TypeError)
+            throw error;
         throw new Error(`Failed to connect to LiteLLM at ${baseUrl}`);
     }
 }
@@ -614,7 +743,7 @@ async function getBedrockModels() {
         if (apiKey) {
             headers['Authorization'] = `Bearer ${apiKey}`;
         }
-        const response = await fetch(modelsUrl, { headers });
+        const response = await fetchModelMetadata(modelsUrl, { headers });
         if (response.ok) {
             const data = await response.json();
             return data.data
@@ -623,7 +752,7 @@ async function getBedrockModels() {
                 id: model.id,
                 name: model.id,
                 description: getBedrockModelDescription(model.id),
-                contextLength: getBedrockContextLength(model.id),
+                ...compatibleMetadata(model),
             }));
         }
         throw new Error(`Bedrock gateway ${baseUrl} returned ${response.status}. Check BEDROCK_BASE_URL / BEDROCK_API_KEY.`);
@@ -639,12 +768,44 @@ async function getBedrockModels() {
 async function resolveAwsCredentialsViaCli(profile) {
     try {
         const { execFileSync } = await import('child_process');
+        const signal = discoveryContext.getStore()?.signal;
+        const read = async (format) => {
+            const args = ['configure', 'export-credentials', '--profile', profile, '--format', format];
+            if (!signal)
+                return execFileSync('aws', args, { encoding: 'utf-8', timeout: 10000, stdio: ['ignore', 'pipe', 'pipe'] });
+            throwIfCancelled(signal);
+            const { spawn } = await import('node:child_process');
+            throwIfCancelled(signal);
+            return new Promise((resolve, reject) => {
+                const capacity = new AbortController();
+                const combined = AbortSignal.any([signal, AbortSignal.timeout(10000), capacity.signal]);
+                const child = spawn('aws', args, { stdio: ['ignore', 'pipe', 'pipe'], detached: detachedProcess });
+                const cleanup = bindProcessCancellation(child, combined);
+                discoveryContext.getStore()?.cleanups.push(cleanup);
+                const chunks = [];
+                let size = 0;
+                child.stdout.on('data', (chunk) => {
+                    size += chunk.length;
+                    if (size > 1024 * 1024)
+                        capacity.abort();
+                    else
+                        chunks.push(chunk);
+                });
+                child.stderr.resume();
+                child.once('error', () => { void cleanup.then(() => reject(new Error('AWS profile credential resolution failed'))); });
+                child.once('close', code => {
+                    void cleanup.then(() => code === 0 && !combined.aborted
+                        ? resolve(Buffer.concat(chunks).toString('utf8')) : reject(new Error('AWS profile credential resolution failed')));
+                });
+            });
+        };
         let output = '';
         try {
-            output = execFileSync('aws', ['configure', 'export-credentials', '--profile', profile, '--format', 'env-no-export'], { encoding: 'utf-8', timeout: 10_000, stdio: ['ignore', 'pipe', 'pipe'] });
+            output = await read('env-no-export');
         }
         catch {
-            output = execFileSync('aws', ['configure', 'export-credentials', '--profile', profile, '--format', 'env'], { encoding: 'utf-8', timeout: 10_000, stdio: ['ignore', 'pipe', 'pipe'] });
+            throwIfCancelled(signal);
+            output = await read('env');
         }
         const envs = {};
         for (const rawLine of output.split(/\r?\n/)) {
@@ -764,7 +925,7 @@ async function discoverBedrockModelsNative() {
         const signingKey = hmacFn(kService, 'aws4_request');
         const signature = createHmac('sha256', signingKey).update(stringToSign).digest('hex');
         headers['Authorization'] = `AWS4-HMAC-SHA256 Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
-        return fetch(url, { headers });
+        return fetchModelMetadata(url, { headers });
     };
     // 1. ListFoundationModels (direct on-demand access).
     // Dropped the byInferenceType=ON_DEMAND filter — newer Claude models are only
@@ -781,49 +942,55 @@ async function discoverBedrockModelsNative() {
                 '(2) IAM role missing bedrock:ListFoundationModels; (3) SSO token expired — run `aws sso login`.'));
     }
     const foundationData = await foundationResp.json();
-    const foundationModels = (foundationData.modelSummaries || [])
+    if (!Array.isArray(foundationData.modelSummaries))
+        throw new ModelDiscoveryError('Invalid Bedrock foundation discovery');
+    const foundationModels = foundationData.modelSummaries
         .filter(m => m.inputModalities?.includes('TEXT') && m.outputModalities?.includes('TEXT'))
-        .filter(m => bedrockSupportsConverseTools(m.modelId))
         .map(m => ({
         id: m.modelId,
         name: m.modelName || m.modelId,
         description: `${m.providerName || 'Unknown'} — ${getBedrockModelDescription(m.modelId)}`,
-        contextLength: getBedrockContextLength(m.modelId),
+        capabilities: { streaming: capability(m.responseStreamingSupported), vision: stringList(m.inputModalities)?.includes('IMAGE') },
     }));
     // 2. ListInferenceProfiles — cross-region profile IDs (e.g. us.anthropic.claude-sonnet-4-5-*).
     // Many modern models are ONLY reachable via these, not direct foundation-model IDs.
     // Failures here are non-fatal (older accounts / regions may not support it).
-    let profileModels = [];
-    try {
-        const profileResp = await signedGet('/inference-profiles', '');
-        if (profileResp.ok) {
-            const profileData = await profileResp.json();
-            profileModels = (profileData.inferenceProfileSummaries || [])
-                .filter(p => p.status !== 'INACTIVE')
-                .filter(p => bedrockSupportsConverseTools(p.inferenceProfileId))
-                .map(p => ({
-                id: p.inferenceProfileId,
-                name: p.inferenceProfileName || p.inferenceProfileId,
-                description: `Inference profile — ${getBedrockModelDescription(p.inferenceProfileId)}`,
-                contextLength: getBedrockContextLength(p.inferenceProfileId),
-            }));
+    const profileModels = [], coveredBaseIds = new Set();
+    const seen = new Set();
+    let nextToken = '';
+    for (let page = 0; page < 20; page++) {
+        const profileResp = await signedGet('/inference-profiles', nextToken ? `nextToken=${encodeURIComponent(nextToken)}` : '');
+        if (!profileResp.ok)
+            break; // Profiles are optional; foundation evidence remains usable.
+        const data = await profileResp.json();
+        if (!Array.isArray(data.inferenceProfileSummaries) || profileModels.length + data.inferenceProfileSummaries.length > 10000)
+            throw new ModelDiscoveryError('Invalid Bedrock profile discovery');
+        for (const profile of data.inferenceProfileSummaries) {
+            if (profile.status === 'INACTIVE')
+                continue;
+            const baseIds = profile.models?.map(model => model.modelArn.split(':foundation-model/')[1]).filter((id) => !!id) ?? [];
+            const bases = baseIds.map(id => foundationModels.find(model => model.id === id));
+            // Only profile-provided ARNs establish a relationship to foundation models.
+            // Inherit a capability only when every regional model reports the same value.
+            const shared = (key) => {
+                const values = bases.map(model => model?.capabilities?.[key]);
+                return values.length && values.every(value => value === values[0]) ? values[0] : undefined;
+            };
+            for (const id of baseIds)
+                coveredBaseIds.add(id);
+            profileModels.push({ id: profile.inferenceProfileId, name: profile.inferenceProfileName || profile.inferenceProfileId,
+                description: 'Bedrock inference profile', capabilities: { streaming: shared('streaming'), vision: shared('vision') } });
         }
+        if (data.nextToken == null || data.nextToken === '')
+            break;
+        if (typeof data.nextToken !== 'string' || data.nextToken.length > 2048 || seen.has(data.nextToken))
+            throw new ModelDiscoveryError('Invalid Bedrock discovery cursor');
+        seen.add(data.nextToken);
+        nextToken = data.nextToken;
+        if (page === 19)
+            throw new ModelDiscoveryError('Bedrock discovery page budget exceeded');
     }
-    catch {
-        // Non-fatal — foundation models alone is still useful.
-    }
-    // Merge. For every inference profile, strip the region prefix (e.g. `us.`,
-    // `eu.`, `apac.`, `jp.`) to get the base foundation-model ID it wraps, and
-    // drop that base from the foundation list — because newer Claude 4.x / Haiku
-    // 4.5 models can ONLY be invoked via their inference profile on on-demand
-    // throughput. Showing both would let users pick the invokable-broken raw ID.
-    const coveredBaseIds = new Set();
-    for (const p of profileModels) {
-        const base = p.id.replace(/^[a-z]{2,5}\./, '');
-        if (base !== p.id)
-            coveredBaseIds.add(base);
-    }
-    const filteredFoundation = foundationModels.filter(m => !coveredBaseIds.has(m.id));
+    const filteredFoundation = foundationModels.filter(model => !coveredBaseIds.has(model.id));
     const merged = new Map();
     for (const m of filteredFoundation)
         merged.set(m.id, m);
@@ -831,38 +998,6 @@ async function discoverBedrockModelsNative() {
         merged.set(m.id, m);
     return Array.from(merged.values()).sort((a, b) => a.id.localeCompare(b.id));
 }
-/**
- * Bedrock Converse API tool-calling support. Maintained as a local allowlist
- * because AWS doesn't expose per-model tool capability via the list APIs.
- * See: https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-supported-models-features.html
- * Matches both raw foundation model IDs (e.g. anthropic.claude-3-5-sonnet-*)
- * and cross-region inference profile IDs (e.g. us.anthropic.claude-sonnet-4-5-*).
- */
-function bedrockSupportsConverseTools(modelId) {
-    const id = modelId.toLowerCase();
-    // Anthropic Claude 3, 3.5, 3.7, 4, 4.5 (all support tools). Excludes Claude 2.x / Instant.
-    if (/anthropic\.claude-(3|opus-4|sonnet-4|haiku-4|3-5|3-7)/.test(id))
-        return true;
-    // Amazon Nova (Pro / Lite / Micro support Converse tools; Nova Canvas/Reel are image models — excluded)
-    if (/amazon\.nova-(pro|lite|micro|premier)/.test(id))
-        return true;
-    // Cohere Command R / R+ support tools (older Command models do not)
-    if (/cohere\.command-r/.test(id))
-        return true;
-    // Mistral Large (2402, 2407), Pixtral Large, Mistral Small, Nemo
-    if (/mistral\.(mistral-large|pixtral|mistral-small|mistral-nemo)/.test(id))
-        return true;
-    // Meta Llama 3.1+ supports tools via Converse (3.0 and earlier do not)
-    if (/meta\.llama(3-1|3-2|3-3|4)/.test(id))
-        return true;
-    // AI21 Jamba 1.5 supports tools
-    if (/ai21\.jamba-1-5/.test(id))
-        return true;
-    // DeepSeek R1 supports tools
-    if (/deepseek\.r1/.test(id))
-        return true;
-    return false;
-}
 function getBedrockModelDescription(modelId) {
     if (modelId.includes('claude') && modelId.includes('opus'))
         return 'Most capable Claude model on Bedrock';
@@ -880,21 +1015,6 @@ function getBedrockModelDescription(modelId) {
         return 'Cohere model on Bedrock';
     return 'AWS Bedrock model';
 }
-function getBedrockContextLength(modelId) {
-    if (modelId.includes('claude'))
-        return 200000;
-    if (modelId.includes('llama3-1') || modelId.includes('llama3.1'))
-        return 128000;
-    if (modelId.includes('mistral-large'))
-        return 128000;
-    if (modelId.includes('command-r'))
-        return 128000;
-    if (modelId.includes('titan-text-premier'))
-        return 32000;
-    if (modelId.includes('titan-text-express'))
-        return 8192;
-    return 32000;
-}
 /**
  * Get models from a generic OpenAI-compatible server (e.g. LM Studio, Jan, LocalAI, vLLM)
  */
@@ -903,15 +1023,17 @@ async function getOpenAICompatModels() {
     if (!baseUrl.endsWith('/v1'))
         baseUrl = `${baseUrl}/v1`;
     const apiKey = config.getApiKey('openai-compat') || 'openai-compat';
-    const response = await fetch(`${baseUrl}/models`, {
+    const response = await fetchModelMetadata(`${baseUrl}/models`, {
         headers: { 'Authorization': `Bearer ${apiKey}` },
     });
     if (!response.ok) {
         throw new Error(`OpenAI-compat server error: ${response.status}`);
     }
     const data = await response.json();
-    const models = data.data ?? [];
-    return models.map(m => ({ id: m.id, name: m.id, description: 'OpenAI-compatible server' }));
+    if (!Array.isArray(data.data))
+        throw new ModelDiscoveryError('Invalid model discovery response');
+    const models = data.data;
+    return models.map(m => ({ id: m.id, name: m.id, description: 'OpenAI-compatible server', ...compatibleMetadata(m) }));
 }
 /**
  * Get models for OpenAI-compatible providers
@@ -920,17 +1042,27 @@ async function getOpenAICompatibleModels(provider) {
     const apiKey = config.getApiKey(provider);
     if (!apiKey)
         throw new Error(`${provider} API key not configured`);
-    const baseURL = PROVIDER_BASE_URLS[provider];
+    const baseURL = config.getBaseUrl(provider) || PROVIDER_BASE_URLS[provider];
     if (!baseURL)
         throw new Error(`Unknown provider: ${provider}`);
-    const client = new OpenAI({ apiKey, baseURL });
+    // Cerebras exposes richer limits, pricing and capability metadata on its
+    // public catalog; the OpenAI-compatible /v1/models endpoint only returns
+    // identifiers, which makes bounded tool execution impossible to quote.
+    if (provider === 'cerebras') {
+        const publicUrl = `${new URL(baseURL).origin}/public/v1/models`;
+        const metadataResponse = await fetchModelMetadata(publicUrl, { headers: { Authorization: `Bearer ${apiKey}` } });
+        if (metadataResponse.ok) {
+            const payload = await metadataResponse.json();
+            if (!Array.isArray(payload.data))
+                throw new ModelDiscoveryError('Invalid Cerebras model discovery response');
+            return payload.data
+                .filter(model => { const id = typeof model === 'object' && model !== null ? model.id : undefined; return typeof id === 'string' && isCompatibleModel(id, provider); })
+                .map(model => { const id = model.id; return { id, name: id, ...compatibleMetadata(model) }; });
+        }
+    }
+    const client = new OpenAI({ apiKey, baseURL, ...discoveryTransportOptions() });
     const response = await client.models.list();
-    return response.data
-        .filter(model => isCompatibleModel(model.id, provider))
-        .map(model => ({
-        id: model.id,
-        name: model.id,
-    }));
+    return response.data.filter(model => isCompatibleModel(model.id, provider)).map(model => ({ id: model.id, name: model.id, ...compatibleMetadata(model) }));
 }
 /**
  * Helper functions for model descriptions
@@ -989,36 +1121,42 @@ function formatSize(bytes) {
 export function clearModelCache(provider) {
     if (provider) {
         modelCache.delete(provider);
+        previousDiscovery.delete(provider);
     }
     else {
         modelCache.clear();
+        previousDiscovery.clear();
     }
 }
 /**
  * Pre-warm model cache for configured providers
  * Runs in background, doesn't block startup
  */
-export async function preWarmModelCache() {
+export async function preWarmModelCache(parentSignal) {
     const configuredProviders = config.getConfiguredProviders();
+    const deadline = AbortSignal.timeout(30000);
+    const signal = parentSignal ? AbortSignal.any([parentSignal, deadline]) : deadline;
     // Fetch models for all configured providers in parallel
-    await Promise.allSettled(configuredProviders.map(provider => getAvailableModels(provider, { quiet: true })));
+    await Promise.allSettled(configuredProviders.map(provider => getAvailableModels(provider, { quiet: true, signal })));
 }
 /**
  * Get model info from cache by ID
  */
 export function getModelInfo(provider, modelId) {
     const cached = modelCache.get(provider);
-    if (!cached)
+    if (!cached || cached.target !== modelCacheTarget(provider) || Date.now() - cached.timestamp >= CACHE_DURATION)
         return undefined;
     // Exact match first.
-    const exact = cached.models.find(m => m.id === modelId);
+    const exact = cached.models.find(m => m.id === modelId || m.aliases?.includes(modelId));
     if (exact)
-        return exact;
+        return structuredClone(exact);
+    if (cached.models.every(model => model.evidence?.source === 'live'))
+        return undefined;
     // Otherwise only accept an UNAMBIGUOUS prefix relationship. Loose substring
     // matching wrongly resolved e.g. `gpt-4` -> `gpt-4o` or `claude-opus-4` ->
     // `claude-opus-4-8`, returning a different model's context/pricing.
     const related = cached.models.filter(m => m.id.startsWith(modelId) || modelId.startsWith(m.id));
-    return related.length === 1 ? related[0] : undefined;
+    return related.length === 1 ? structuredClone(related[0]) : undefined;
 }
 /**
  * Default context limits by model family (fallback when API doesn't provide it)