mixdog 0.7.8 → 0.7.11

package/src/agent/orchestrator/providers/model-catalog.mjs

@@ -22,6 +22,30 @@ const CATALOG_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/mode
 const CATALOG_CACHE_FILE = 'litellm-catalog.json';
 const CATALOG_TTL_MS = 24 * 60 * 60_000;
 
+// Second auto pricing source: models.dev publishes per-PROVIDER model
+// catalogs (cost in $/M) for 140+ providers — including ones LiteLLM does not
+// track yet (e.g. opencode-go). Because it is keyed provider→model, a
+// provider-scoped lookup is collision-free: deepseek-v4-pro under `deepseek`
+// and under `opencode-go` resolve to their own distinct rates. Same 24h TTL
+// + disk cache shape as the LiteLLM catalog above.
+const MODELSDEV_URL = 'https://models.dev/api.json';
+const MODELSDEV_CACHE_FILE = 'modelsdev-catalog.json';
+
+// mixdog provider id → models.dev provider id. Identity for ids that already
+// match (opencode-go / deepseek / xai / nvidia / openai / anthropic / groq /
+// mistral); only the OAuth aliases and gemini→google need remapping.
+const _MODELSDEV_PROVIDER_ALIAS = {
+    'anthropic-oauth': 'anthropic',
+    'openai-oauth': 'openai',
+    'grok-oauth': 'xai',
+    'gemini': 'google',
+};
+function _modelsDevProviderId(provider) {
+    if (!provider) return null;
+    const p = String(provider).toLowerCase();
+    return _MODELSDEV_PROVIDER_ALIAS[p] || p;
+}
+
 // Provider prefix variants used for catalog key lookup. Named constants so
 // all three lookup sites (getModelMetadataSync, getModelMetadata, enrichModels)
 // stay in sync. A provider needing a new prefix adds it here.
@@ -138,6 +162,85 @@ function warmFromDiskSync() {
     } catch { /* disk cache unavailable — stay cold, async warm will fill later */ }
 }
 
+// ── models.dev catalog (second auto pricing source) ─────────────────────────
+let _mdCache = null;
+let _mdCacheAt = 0;
+let _mdLoadPromise = null;
+function mdCachePath() {
+    return join(getPluginData(), MODELSDEV_CACHE_FILE);
+}
+async function _loadModelsDevImpl() {
+    try {
+        if (existsSync(mdCachePath())) {
+            const raw = JSON.parse(readFileSync(mdCachePath(), 'utf-8'));
+            if (raw?.fetchedAt && (Date.now() - raw.fetchedAt) < CATALOG_TTL_MS && raw.data) {
+                _mdCache = raw.data;
+                _mdCacheAt = raw.fetchedAt;
+                return _mdCache;
+            }
+        }
+    } catch { /* fall through to remote */ }
+    try {
+        const res = await fetch(MODELSDEV_URL, { signal: AbortSignal.timeout(10_000) });
+        if (!res.ok) throw new Error('HTTP ' + res.status);
+        const data = await res.json();
+        try {
+            writeFileSync(mdCachePath(), JSON.stringify({ fetchedAt: Date.now(), data }));
+        } catch { /* cache is best-effort */ }
+        _mdCache = data;
+        _mdCacheAt = Date.now();
+        return data;
+    } catch (err) {
+        process.stderr.write(`[model-catalog] models.dev fetch failed: ${err.message}\n`);
+        return _mdCache || {};
+    }
+}
+export async function loadModelsDevCatalog() {
+    if (_mdCache && (Date.now() - _mdCacheAt) < CATALOG_TTL_MS) return _mdCache;
+    if (_mdLoadPromise) return _mdLoadPromise;
+    _mdLoadPromise = _loadModelsDevImpl().finally(() => { _mdLoadPromise = null; });
+    return _mdLoadPromise;
+}
+function warmModelsDevFromDiskSync() {
+    if (_mdCache) return;
+    try {
+        const raw = JSON.parse(readFileSync(mdCachePath(), 'utf-8'));
+        if (raw?.data) {
+            _mdCache = raw.data;
+            _mdCacheAt = raw.fetchedAt || Date.now();
+        }
+    } catch { /* cold — async loadModelsDevCatalog will fill later */ }
+}
+// Adapt a models.dev model row (cost in $/M) to the LiteLLM-shaped row that
+// _normalize() consumes ($/token). Only fields present are emitted.
+function _modelsDevRowToOverride(row) {
+    const c = (row && row.cost) || {};
+    const out = {
+        max_input_tokens: row?.limit?.context,
+        max_output_tokens: row?.limit?.output,
+        mode: 'chat',
+        supports_function_calling: row?.tool_call === true,
+        supports_vision: Array.isArray(row?.modalities?.input) && row.modalities.input.includes('image'),
+        supports_prompt_caching: c.cache_read != null,
+    };
+    if (c.input != null) out.input_cost_per_token = c.input / 1_000_000;
+    if (c.output != null) out.output_cost_per_token = c.output / 1_000_000;
+    if (c.cache_read != null) out.cache_read_input_token_cost = c.cache_read / 1_000_000;
+    if (c.cache_write != null) out.cache_creation_input_token_cost = c.cache_write / 1_000_000;
+    return out;
+}
+function _modelsDevMetadataSync(id, provider) {
+    const pid = _modelsDevProviderId(provider);
+    if (!pid) return null;
+    if (!_mdCache) {
+        warmModelsDevFromDiskSync();
+        if (!_mdCache) { void loadModelsDevCatalog(); return null; }
+    }
+    const row = _mdCache?.[pid]?.models?.[id];
+    if (!row || !row.cost) return null;
+    return _normalize(_modelsDevRowToOverride(row));
+}
+
 /**
  * Sync lookup. Warm order:
  *   1. in-memory cache (hot path),
@@ -149,19 +252,37 @@ function warmFromDiskSync() {
  * subsequent calls hit memory. TTL is intentionally ignored here — stale
  * catalog beats no catalog, and the async path refreshes on schedule.
  */
-export function getModelMetadataSync(id) {
+export function getModelMetadataSync(id, provider) {
     if (!id) return null;
-    if (PRICING_OVERRIDES[id]) return _normalize(PRICING_OVERRIDES[id]);
+    const mappedProvider = provider ? _modelsDevProviderId(provider) : null;
+    // 1. Manual overrides — authoritative + offline. Provider-guarded: when a
+    //    provider hint is given, an override is only honoured if it belongs to
+    //    that provider, so a model id shared across providers (e.g.
+    //    deepseek-v4-pro under `deepseek` vs `opencode-go`) never leaks the
+    //    wrong provider's rate. Bare-id callers keep the legacy behaviour.
+    const ov = PRICING_OVERRIDES[id];
+    if (ov && (!mappedProvider || _modelsDevProviderId(ov.litellm_provider) === mappedProvider)) {
+        return _normalize(ov);
+    }
+    // 2. LiteLLM community catalog (broad mainstream coverage).
     if (!_memCache) warmFromDiskSync();
-    if (!_memCache) return null;
-    const catalog = _memCache;
-    if (catalog[id]) return _normalize(catalog[id]);
-    for (const prefix of _CATALOG_SIMPLE_PREFIXES) {
-        if (catalog[prefix + id]) return _normalize(catalog[prefix + id]);
+    if (_memCache) {
+        const catalog = _memCache;
+        if (catalog[id]) return _normalize(catalog[id]);
+        for (const prefix of _CATALOG_SIMPLE_PREFIXES) {
+            if (catalog[prefix + id]) return _normalize(catalog[prefix + id]);
+        }
+        for (const prefix of _CATALOG_BEDROCK_PREFIXES) {
+            const v1 = catalog[prefix + id + '-v1:0'];
+            if (v1) return _normalize(v1);
+        }
     }
-    for (const prefix of _CATALOG_BEDROCK_PREFIXES) {
-        const v1 = catalog[prefix + id + '-v1:0'];
-        if (v1) return _normalize(v1);
+    // 3. models.dev — provider-scoped gap filler (collision-free, auto 24h).
+    //    Placed LAST so it never shadows the authoritative sources above; it
+    //    only prices what LiteLLM/overrides do not cover (e.g. opencode-go).
+    if (mappedProvider) {
+        const md = _modelsDevMetadataSync(id, provider);
+        if (md) return md;
     }
     return null;
 }
@@ -209,8 +330,11 @@ export async function enrichModels(models) {
         if (!meta) return m;
         return {
             ...m,
-            contextWindow: meta.contextWindow || m.contextWindow || null,
-            outputTokens: meta.outputTokens || m.outputTokens || null,
+            // Provider-native limits are authoritative for request sizing.
+            // External catalogs are pricing/metadata fillers and may describe
+            // a public API SKU rather than the OAuth/backend route in use.
+            contextWindow: m.contextWindow || meta.contextWindow || null,
+            outputTokens: m.outputTokens || meta.outputTokens || null,
             inputCostPerM: meta.inputCostPerM,
             outputCostPerM: meta.outputCostPerM,
             cacheReadCostPerM: meta.cacheReadCostPerM,
@@ -231,11 +355,20 @@ export async function enrichModels(models) {
 export async function refreshCatalog() {
     _memCache = null;
     _memCacheAt = 0;
+    _mdCache = null;
+    _mdCacheAt = 0;
     try {
         if (existsSync(cachePath())) {
             const fs = await import('fs');
             fs.unlinkSync(cachePath());
         }
     } catch { /* ignore */ }
-    return loadCatalog();
+    try {
+        if (existsSync(mdCachePath())) {
+            const fs = await import('fs');
+            fs.unlinkSync(mdCachePath());
+        }
+    } catch { /* ignore */ }
+    const [litellm] = await Promise.all([loadCatalog(), loadModelsDevCatalog()]);
+    return litellm;
 }

package/src/agent/orchestrator/providers/openai-compat-stream.mjs

@@ -0,0 +1,366 @@
+import {
+    PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+    PROVIDER_SSE_IDLE_TIMEOUT_MS,
+    PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
+    createTimeoutSignal,
+    providerTimeoutError,
+} from '../stall-policy.mjs';
+import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
+
+function truncatedCompatStreamError(label, detail) {
+    return Object.assign(
+        new Error(`${label} SSE stream truncated${detail ? `: ${detail}` : ''}`),
+        { name: 'TruncatedStreamError', code: 'TRUNCATED_STREAM', truncatedStream: true },
+    );
+}
+
+/** Completed tool_call.arguments must be valid JSON; empty/missing → {}. */
+export function parseCompletedToolCallArgumentsJson(raw, label) {
+    const text = typeof raw === 'string' ? raw : (raw == null ? '' : String(raw));
+    const src = text === '' ? '{}' : text;
+    try {
+        return JSON.parse(src);
+    } catch {
+        throw truncatedCompatStreamError(label, 'invalid tool_call arguments JSON');
+    }
+}
+
+function firstByteCompatStreamError(label) {
+    const err = providerTimeoutError(`${label} first byte`, PROVIDER_FIRST_BYTE_TIMEOUT_MS);
+    err.firstByteTimeout = true;
+    return err;
+}
+
+async function nextAsyncWithWatchdog(iterator, { signal, idleMs, idleEnabled, idleLabel } = {}) {
+    let idleTimer = null;
+    let idleReject = null;
+    let idleTimedOut = false;
+    const armIdle = () => {
+        if (!idleEnabled || !(idleMs > 0)) return;
+        if (idleTimer) clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+            idleTimedOut = true;
+            const e = providerTimeoutError(idleLabel || 'compat SSE idle', idleMs);
+            e.code = 'ETIMEDOUT';
+            if (idleReject) {
+                const r = idleReject;
+                idleReject = null;
+                r(e);
+            }
+        }, idleMs);
+        if (typeof idleTimer.unref === 'function') idleTimer.unref();
+    };
+    armIdle();
+    try {
+        const result = await new Promise((resolve, reject) => {
+            idleReject = reject;
+            if (signal?.aborted) {
+                const reason = signal.reason;
+                reject(reason instanceof Error ? reason : new Error('compat stream aborted'));
+                return;
+            }
+            let onAbort = null;
+            if (signal) {
+                onAbort = () => {
+                    const reason = signal.reason;
+                    reject(reason instanceof Error ? reason : new Error('compat stream aborted'));
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+            }
+            iterator.next().then(
+                (value) => {
+                    if (idleTimer) clearTimeout(idleTimer);
+                    if (signal && onAbort) {
+                        try { signal.removeEventListener('abort', onAbort); } catch {}
+                    }
+                    resolve(value);
+                },
+                (err) => {
+                    if (idleTimer) clearTimeout(idleTimer);
+                    if (signal && onAbort) {
+                        try { signal.removeEventListener('abort', onAbort); } catch {}
+                    }
+                    reject(err);
+                },
+            );
+        });
+        return result;
+    } catch (err) {
+        if (idleTimer) clearTimeout(idleTimer);
+        if (idleTimedOut) throw providerTimeoutError(idleLabel || 'compat SSE idle', idleMs);
+        throw err;
+    }
+}
+
+function mergeToolCallDelta(accByIndex, deltaCalls) {
+    for (const tc of deltaCalls || []) {
+        const idx = Number.isFinite(Number(tc?.index)) ? Number(tc.index) : 0;
+        const prev = accByIndex.get(idx) || {
+            id: '',
+            type: 'function',
+            function: { name: '', arguments: '' },
+        };
+        if (tc.id) prev.id = tc.id;
+        if (tc.type) prev.type = tc.type;
+        if (tc.function?.name && !prev.function.name) prev.function.name = tc.function.name;
+        if (tc.function?.arguments) prev.function.arguments += tc.function.arguments;
+        accByIndex.set(idx, prev);
+    }
+}
+
+export function toolCallsFromStreamAcc(accByIndex, parseToolCalls, label) {
+    if (!accByIndex.size) return undefined;
+    const choice = {
+        message: {
+            tool_calls: [...accByIndex.entries()]
+                .sort((a, b) => a[0] - b[0])
+                .map(([, v]) => v),
+        },
+    };
+    return parseToolCalls(choice, label);
+}
+
+export async function consumeCompatChatCompletionStream(stream, { signal, label, onStreamDelta, parseToolCalls } = {}) {
+    const iterator = stream[Symbol.asyncIterator]();
+    const firstByteTimeout = createTimeoutSignal(signal, PROVIDER_FIRST_BYTE_TIMEOUT_MS, `${label} first byte`);
+    const idleEnabled = PROVIDER_SSE_IDLE_WATCHDOG_ENABLED;
+    const idleMs = PROVIDER_SSE_IDLE_TIMEOUT_MS;
+    let sawFirstEvent = false;
+    let content = '';
+    let reasoningContent = '';
+    let model = '';
+    let responseId = '';
+    let stopReason = null;
+    let rawUsage = null;
+    const toolAcc = new Map();
+    try {
+        while (true) {
+            const { value: chunk, done } = await nextAsyncWithWatchdog(iterator, {
+                // Until the first SSE chunk, bound the pending read to the
+                // first-byte timer (createTimeoutSignal already chains parent).
+                signal: sawFirstEvent ? signal : firstByteTimeout.signal,
+                idleMs,
+                idleEnabled: sawFirstEvent && idleEnabled,
+                idleLabel: `${label} SSE idle`,
+            });
+            if (done) break;
+            if (!sawFirstEvent) {
+                sawFirstEvent = true;
+                firstByteTimeout.cleanup();
+            }
+            try { onStreamDelta?.(); } catch {}
+            if (chunk?.id) responseId = chunk.id;
+            if (chunk?.model) model = chunk.model;
+            const choice = chunk?.choices?.[0];
+            if (choice?.delta?.content) content += choice.delta.content;
+            if (typeof choice?.delta?.reasoning_content === 'string') {
+                reasoningContent += choice.delta.reasoning_content;
+            }
+            mergeToolCallDelta(toolAcc, choice?.delta?.tool_calls);
+            if (choice?.finish_reason) stopReason = choice.finish_reason;
+            if (chunk?.usage) rawUsage = chunk.usage;
+        }
+    } finally {
+        firstByteTimeout.cleanup();
+    }
+    if (!sawFirstEvent) {
+        if (firstByteTimeout.signal?.aborted) throw firstByteCompatStreamError(label);
+        throw firstByteCompatStreamError(label);
+    }
+    if (!stopReason) {
+        throw truncatedCompatStreamError(label, 'no finish_reason');
+    }
+    const message = {
+        content: content || null,
+        ...(reasoningContent ? { reasoning_content: reasoningContent } : {}),
+    };
+    const rawToolCalls = [...toolAcc.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([, v]) => v)
+        .filter(tc => tc.id || tc.function?.name);
+    if (rawToolCalls.length) message.tool_calls = rawToolCalls;
+    const response = {
+        id: responseId || null,
+        model: model || null,
+        choices: [{ message, finish_reason: stopReason }],
+        usage: rawUsage || undefined,
+    };
+    return {
+        response,
+        model,
+        content,
+        toolCalls: toolCallsFromStreamAcc(toolAcc, parseToolCalls, label),
+        stopReason,
+        reasoningContent: reasoningContent || null,
+        rawUsage,
+    };
+}
+
+function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesToolCalls, responseOutputText, onStreamDelta }) {
+    if (!event || typeof event.type !== 'string') return;
+    switch (event.type) {
+        case 'response.created':
+            if (event.response?.model) state.model = event.response.model;
+            if (event.response?.id) state.responseId = event.response.id;
+            break;
+        case 'response.output_text.delta':
+            state.content += event.delta || '';
+            state.sawOutput = true;
+            try { onStreamDelta?.(); } catch {}
+            break;
+        case 'response.output_item.added':
+            if (event.item?.type === 'function_call') {
+                state.pendingCalls.set(event.item.id || '', {
+                    name: event.item.name || '',
+                    callId: event.item.call_id || '',
+                });
+            }
+            try { onStreamDelta?.(); } catch {}
+            break;
+        case 'response.function_call_arguments.delta':
+            try { onStreamDelta?.(); } catch {}
+            break;
+        case 'response.function_call_arguments.done': {
+            const itemId = event.item_id || '';
+            const pending = state.pendingCalls.get(itemId);
+            const call = {
+                id: pending?.callId || event.call_id || '',
+                name: pending?.name || event.name || '',
+                arguments: parseCompletedToolCallArgumentsJson(event.arguments, label),
+                _pendingItemId: itemId,
+            };
+            state.toolCalls.push(call);
+            if (call.id && call.name) delete call._pendingItemId;
+            try { onStreamDelta?.(); } catch {}
+            break;
+        }
+        case 'response.output_item.done': {
+            const item = event.item || {};
+            if (item.type === 'function_call') {
+                const tc = state.toolCalls.find(t => t._pendingItemId === (item.id || ''));
+                if (tc) {
+                    if (!tc.id && item.call_id) tc.id = item.call_id;
+                    if (!tc.name && item.name) tc.name = item.name;
+                    if (tc.id && tc.name) delete tc._pendingItemId;
+                } else if (item.call_id && item.name) {
+                    state.toolCalls.push({
+                        id: item.call_id,
+                        name: item.name,
+                        arguments: parseCompletedToolCallArgumentsJson(item.arguments, label),
+                    });
+                }
+            }
+            try { onStreamDelta?.(); } catch {}
+            break;
+        }
+        case 'response.completed': {
+            const resp = event.response || {};
+            state.completed = true;
+            state.completedResponse = resp;
+            if (!state.model && resp.model) state.model = resp.model;
+            if (!state.responseId && resp.id) state.responseId = resp.id;
+            if (!state.content) state.content = responseOutputText(resp);
+            if (!state.toolCalls.length) {
+                const parsed = parseResponsesToolCalls(resp, label);
+                if (parsed?.length) state.toolCalls.push(...parsed.map(t => ({ ...t })));
+            }
+            try { onStreamDelta?.(); } catch {}
+            break;
+        }
+        case 'response.done':
+            if (!event.response || event.response.status === 'completed') state.completed = true;
+            else if (event.response.status === 'failed') {
+                const msg = event.response?.error?.message || 'response.done failed';
+                const err = new Error(`xAI Responses stream response.done failed: ${msg}`);
+                populateHttpStatusFromMessage(err, msg);
+                throw err;
+            } else if (event.response.status === 'incomplete') {
+                throw new Error(`xAI Responses stream response.done incomplete: ${event.response?.incomplete_details?.reason || 'incomplete'}`);
+            }
+            break;
+        case 'response.failed': {
+            const msg = event.response?.error?.message || event.error?.message || event.message || 'response.failed';
+            const err = new Error(`xAI Responses stream response.failed: ${msg}`);
+            populateHttpStatusFromMessage(err, msg);
+            throw err;
+        }
+        case 'response.incomplete':
+            throw new Error(`xAI Responses stream response.incomplete: ${event.response?.incomplete_details?.reason || 'incomplete'}`);
+        case 'error': {
+            const msg = event.message || event.error?.message || 'unknown';
+            const err = new Error(`xAI Responses stream error: ${msg}`);
+            populateHttpStatusFromMessage(err, msg);
+            throw err;
+        }
+        default:
+            break;
+    }
+}
+
+export async function consumeCompatResponsesStream(stream, {
+    signal,
+    label,
+    onStreamDelta,
+    parseResponsesToolCalls,
+    responseOutputText,
+} = {}) {
+    const iterator = stream[Symbol.asyncIterator]();
+    const firstByteTimeout = createTimeoutSignal(signal, PROVIDER_FIRST_BYTE_TIMEOUT_MS, `${label} first byte`);
+    const idleEnabled = PROVIDER_SSE_IDLE_WATCHDOG_ENABLED;
+    const idleMs = PROVIDER_SSE_IDLE_TIMEOUT_MS;
+    const state = {
+        content: '',
+        model: '',
+        responseId: '',
+        toolCalls: [],
+        pendingCalls: new Map(),
+        completed: false,
+        completedResponse: null,
+        sawOutput: false,
+    };
+    let sawFirstEvent = false;
+    const deps = { label, parseResponsesToolCalls, responseOutputText, onStreamDelta };
+    try {
+        while (true) {
+            const { value: event, done } = await nextAsyncWithWatchdog(iterator, {
+                signal: sawFirstEvent ? signal : firstByteTimeout.signal,
+                idleMs,
+                idleEnabled: sawFirstEvent && idleEnabled,
+                idleLabel: `${label} SSE idle`,
+            });
+            if (done) break;
+            if (!sawFirstEvent) {
+                sawFirstEvent = true;
+                firstByteTimeout.cleanup();
+            }
+            handleCompatResponsesStreamEvent(event, state, deps);
+        }
+    } finally {
+        firstByteTimeout.cleanup();
+    }
+    if (!sawFirstEvent) {
+        if (firstByteTimeout.signal?.aborted) throw firstByteCompatStreamError(label);
+        throw firstByteCompatStreamError(label);
+    }
+    if (!state.completed) throw truncatedCompatStreamError(label, 'no response.completed');
+    const unresolved = state.toolCalls.find(t => t._pendingItemId);
+    if (unresolved) {
+        throw new Error(`xAI Responses stream function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`);
+    }
+    const response = state.completedResponse || {
+        id: state.responseId || null,
+        model: state.model || null,
+        output_text: state.content,
+        output: [],
+    };
+    const toolCalls = state.toolCalls.length
+        ? state.toolCalls.map(({ _pendingItemId, ...t }) => t)
+        : parseResponsesToolCalls(response, label);
+    return {
+        response,
+        content: state.content || responseOutputText(response),
+        toolCalls,
+        model: state.model || response.model || null,
+        responseId: state.responseId || response.id || null,
+    };
+}