mixdog 0.9.3 → 0.9.5

package/src/runtime/agent/orchestrator/providers/gemini.mjs

@@ -1,4 +1,4 @@
-import { GoogleGenerativeAI, SchemaType } from '@google/generative-ai';
+import { GoogleGenerativeAI } from '@google/generative-ai';
 import { loadConfig } from '../config.mjs';
 import { makeModelCache } from './model-cache.mjs';
 import { withRetry } from './retry-classifier.mjs';
@@ -14,9 +14,43 @@ import {
     createPassthroughSignal,
 } from '../stall-policy.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
-import { traceHash, stableTraceStringify, summarizeTraceTools, traceTextShape } from './trace-utils.mjs';
-import { normalizeContentForGeminiParts, splitToolContentForGemini } from './media-normalization.mjs';
-import { scanLeakedToolCalls } from './anthropic-leaked-toolcall.mjs';
+import {
+    GEMINI_FIRST_BYTE_TIMEOUT_MS,
+    geminiTimeoutError,
+    createGeminiTextLeakGuard,
+    consumeGeminiRestStreamResponse,
+    consumeGeminiSdkStream,
+} from './gemini-stream.mjs';
+import {
+    toGeminiTools,
+    toGeminiNativeTools,
+    toGeminiToolConfig,
+    toGeminiContents,
+    parseToolCalls,
+    emitGeminiToolCalls,
+    collectGeminiGroundingSources,
+} from './gemini-schema.mjs';
+import {
+    _estimateGeminiCacheTokens,
+    _geminiCacheMinTokens,
+    _geminiCachePrefixCount,
+    _geminiCachePrefixContents,
+    _geminiCachePrefixHash,
+    _geminiGlobalCacheKey,
+    _getGeminiGlobalCache,
+    _setGeminiGlobalCache,
+    _geminiGlobalCacheNameIsLive,
+    _attachGeminiCacheState,
+    _resolveGeminiCacheUsage,
+    writeGeminiCacheTrace,
+    geminiGlobalCacheCreates,
+    GEMINI_GLOBAL_CACHE_DELETE_GRACE_MS,
+} from './gemini-cache.mjs';
+
+// Legacy import path: tests + gemini-stream import these from gemini.mjs.
+// Re-export the extracted symbols so existing importers resolve unchanged.
+export { createGeminiTextLeakGuard };
+export { parseToolCalls, emitGeminiToolCalls, collectGeminiGroundingSources };
 
 const MODELS = [
     { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash Preview', provider: 'gemini', contextWindow: 1048576 },
@@ -94,1014 +128,9 @@ export async function ensureLatestGeminiModel(provider) {
     throw new Error('[gemini] model catalog unavailable after warmup — cannot resolve default model');
 }
 
-const GEMINI_FIRST_BYTE_TIMEOUT_MS = resolveTimeoutMs(
-    'MIXDOG_GEMINI_FIRST_BYTE_TIMEOUT_MS',
-    PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-    { minMs: 30_000, maxMs: PROVIDER_MAX_BEFORE_WARN_MS },
-);
-
-function summarizeTracePart(part) {
-    if (!part || typeof part !== 'object') return { type: typeof part };
-    if ('text' in part) {
-        return { type: 'text', ...traceTextShape(part.text) };
-    }
-    if (part.functionCall) {
-        return {
-            type: 'functionCall',
-            name: part.functionCall.name || null,
-            argsHash: traceHash(stableTraceStringify(part.functionCall.args || {})),
-        };
-    }
-    if (part.functionResponse) {
-        const response = part.functionResponse.response || {};
-        const responseShape = stableTraceStringify(response);
-        return {
-            type: 'functionResponse',
-            name: part.functionResponse.name || null,
-            responseChars: responseShape.length,
-            responseHash: traceHash(responseShape),
-        };
-    }
-    return { type: Object.keys(part).sort().join('|') || 'unknown' };
-}
-
-function summarizeTraceContents(contents) {
-    const summaries = (contents || []).map((content, index) => ({
-        index,
-        role: content?.role || null,
-        parts: Array.isArray(content?.parts) ? content.parts.map(summarizeTracePart) : [],
-    }));
-    if (summaries.length <= 12) return summaries;
-    return [
-        ...summaries.slice(0, 8),
-        { omittedTurns: summaries.length - 12 },
-        ...summaries.slice(-4),
-    ];
-}
-
-// Gemini cachedContents API rejects prefixes below the model-specific minimum
-// (Gemini 2.0/2.5 = 2048 tokens, Gemini 3.x = 4096 tokens) with HTTP 400
-// "Cached content is too small". Estimating chars/4 ≈ tokens lets us skip the
-// roundtrip when the prefix cannot satisfy the invariant. Estimate undercount
-// is harmless (we attempt and get the same 400 we would have skipped); overcount
-// is harmless (we skip, fall back to implicit cache).
-function _estimateGeminiCacheTokens(systemInstruction, geminiTools, contents) {
-    let chars = 0;
-    if (typeof systemInstruction === 'string') chars += systemInstruction.length;
-    if (Array.isArray(geminiTools) && geminiTools.length) {
-        try { chars += JSON.stringify(geminiTools).length; } catch {}
-    }
-    if (Array.isArray(contents) && contents.length > 1) {
-        for (let i = 0; i < contents.length - 1; i++) {
-            try { chars += JSON.stringify(contents[i]?.parts ?? '').length; } catch {}
-        }
-    }
-    return Math.ceil(chars / 4);
-}
-
-function _geminiCacheMinTokens(model) {
-    return /^gemini-3/i.test(String(model || '')) ? 4096 : 2048;
-}
-
-function _geminiCachePrefixCount(contents) {
-    return Array.isArray(contents) && contents.length > 1 ? contents.length - 1 : 0;
-}
-
-function _geminiCachePrefixContents(contents, prefixCount) {
-    if (!Array.isArray(contents) || prefixCount <= 0) return [];
-    return contents.slice(0, prefixCount).map(c => {
-        const r = c?.role;
-        const safeRole = (r === 'model' || r === 'user') ? r : 'user';
-        return {
-            role: safeRole,
-            parts: Array.isArray(c?.parts) ? c.parts : [],
-        };
-    });
-}
-
-function _geminiCachePrefixHash({ model, systemInstruction, geminiTools, contents, prefixCount }) {
-    return traceHash(stableTraceStringify({
-        model: model || null,
-        systemInstruction: systemInstruction || '',
-        tools: geminiTools || [],
-        contents: _geminiCachePrefixContents(contents, prefixCount),
-    }));
-}
-
-const GEMINI_GLOBAL_CACHE_MIN_LIVE_MS = 6 * 60 * 1000;
-const GEMINI_GLOBAL_CACHE_MAX_ENTRIES = 128;
-// Grace window before deleting a superseded cachedContents name (see the
-// cross-session race note at the L1341-1372 call site). Long enough that a
-// concurrent session still mid-flight on the old name has time to finish.
-const GEMINI_GLOBAL_CACHE_DELETE_GRACE_MS = 2 * 60 * 1000;
-const geminiGlobalCaches = new Map();
-const geminiGlobalCacheCreates = new Map();
-
-function _geminiGlobalCacheKey({ apiKey, model, cachePrefixHash, cachePrefixContentCount }) {
-    return traceHash(stableTraceStringify({
-        apiKeyHash: traceHash(apiKey || ''),
-        model: model || null,
-        cachePrefixHash,
-        cachePrefixContentCount,
-    }));
-}
-
-function _pruneGeminiGlobalCaches(now = Date.now()) {
-    for (const [key, entry] of geminiGlobalCaches) {
-        if (!entry?.cacheName || Number(entry.cacheExpiresAt || 0) <= now) {
-            geminiGlobalCaches.delete(key);
-        }
-    }
-    while (geminiGlobalCaches.size > GEMINI_GLOBAL_CACHE_MAX_ENTRIES) {
-        const oldest = geminiGlobalCaches.keys().next().value;
-        if (oldest === undefined) break;
-        geminiGlobalCaches.delete(oldest);
-    }
-}
-
-function _getGeminiGlobalCache(key, now = Date.now()) {
-    _pruneGeminiGlobalCaches(now);
-    const entry = geminiGlobalCaches.get(key);
-    if (!entry?.cacheName) return null;
-    if ((entry.cacheExpiresAt || 0) - now <= GEMINI_GLOBAL_CACHE_MIN_LIVE_MS) {
-        geminiGlobalCaches.delete(key);
-        return null;
-    }
-    entry.lastUsedAt = now;
-    return entry;
-}
-
-function _setGeminiGlobalCache(key, entry) {
-    if (!key || !entry?.cacheName) return;
-    geminiGlobalCaches.set(key, {
-        ...entry,
-        lastUsedAt: Date.now(),
-    });
-    _pruneGeminiGlobalCaches();
-}
-
-function _geminiGlobalCacheNameIsLive(cacheName, now = Date.now()) {
-    if (!cacheName) return false;
-    for (const entry of geminiGlobalCaches.values()) {
-        if (entry?.cacheName === cacheName && Number(entry.cacheExpiresAt || 0) > now) return true;
-    }
-    return false;
-}
-
-function _attachGeminiCacheState(opts, entry, currentIter) {
-    if (!entry?.cacheName) return;
-    opts.providerState = {
-        ...(opts.providerState || {}),
-        gemini: {
-            cacheName: entry.cacheName,
-            cacheCreatedAt: entry.cacheCreatedAt,
-            cacheCreatedAtIter: currentIter,
-            cacheExpiresAt: entry.cacheExpiresAt,
-            cacheModel: entry.cacheModel,
-            cacheTokenSize: entry.cacheTokenSize,
-            cachePrefixContentCount: entry.cachePrefixContentCount,
-            cachePrefixHash: entry.cachePrefixHash,
-        },
-    };
-}
-
-function _resolveGeminiCacheUsage({ usageMetadata, cachedContent, providerState }) {
-    const inputTokens = Number(usageMetadata?.promptTokenCount || usageMetadata?.totalTokenCount || 0) || 0;
-    const reportedCachedTokens = Number(usageMetadata?.cachedContentTokenCount || 0) || 0;
-    const cachedFallbackTokens = cachedContent
-        ? Number(providerState?.gemini?.cacheTokenSize || 0) || 0
-        : 0;
-    const rawCachedTokens = reportedCachedTokens > 0 ? reportedCachedTokens : cachedFallbackTokens;
-    const cachedTokens = inputTokens > 0 ? Math.min(rawCachedTokens, inputTokens) : rawCachedTokens;
-    const cacheTokenSource = reportedCachedTokens > 0
-        ? 'usage_metadata'
-        : (cachedFallbackTokens > 0 ? 'cache_create_fallback' : 'none');
-    return {
-        inputTokens,
-        reportedCachedTokens,
-        cachedFallbackTokens,
-        cachedTokens,
-        cacheTokenSource,
-    };
-}
-
-function writeGeminiCacheTrace({ opts, model, systemInstruction, tools, contents, usageMetadata, cachedContent }) {
-    if (process.env.MIXDOG_GEMINI_CACHE_TRACE !== '1') return;
-    try {
-        const session = opts?.session || {};
-        const {
-            inputTokens,
-            reportedCachedTokens,
-            cachedFallbackTokens,
-            cachedTokens,
-            cacheTokenSource,
-        } = _resolveGeminiCacheUsage({
-            usageMetadata,
-            cachedContent,
-            providerState: opts?.providerState,
-        });
-        const toolShape = summarizeTraceTools(tools);
-        const trace = {
-            event: 'generate',
-            provider: 'gemini',
-            model,
-            owner: session.owner || null,
-            agent: session.agent || null,
-            permission: session.permission || null,
-            toolPermission: session.toolPermission || null,
-            profileId: session.profileId || null,
-            sourceType: session.sourceType || null,
-            sourceName: session.sourceName || null,
-            sessionIdHash: opts?.sessionId ? traceHash(opts.sessionId) : null,
-            providerCacheKeyHash: opts?.providerCacheKey ? traceHash(opts.providerCacheKey) : null,
-            promptCacheKeyHash: opts?.promptCacheKey ? traceHash(opts.promptCacheKey) : null,
-            systemChars: systemInstruction ? systemInstruction.length : 0,
-            systemHash: systemInstruction ? traceHash(systemInstruction) : null,
-            toolCount: Array.isArray(tools) ? tools.length : 0,
-            toolSchemaHash: traceHash(stableTraceStringify(toolShape)),
-            contentTurnCount: Array.isArray(contents) ? contents.length : 0,
-            contents: summarizeTraceContents(contents),
-            inputTokens,
-            cachedTokens,
-            reportedCachedTokens,
-            cachedFallbackTokens,
-            cacheTokenSource,
-            cacheAttached: !!cachedContent,
-            cachePrefixContentCount: opts?.providerState?.gemini?.cachePrefixContentCount ?? null,
-            cacheHitRate: inputTokens > 0 ? Number((cachedTokens / inputTokens).toFixed(6)) : null,
-        };
-        process.stderr.write(`[gemini-cache-trace] ${JSON.stringify(trace)}\n`);
-    } catch (err) {
-        process.stderr.write(`[gemini-cache-trace] failed: ${err?.message || err}\n`);
-    }
-}
-
-function geminiTimeoutError(label, timeoutMs) {
-    const err = providerTimeoutError(label, timeoutMs);
-    err.name = 'GeminiTimeoutError';
-    err.code = 'EGEMINITIMEOUT';
-    return err;
-}
-
-function geminiTruncatedStreamError(message) {
-    return Object.assign(
-        new Error(message),
-        { name: 'TruncatedStreamError', code: 'TRUNCATED_STREAM', truncatedStream: true },
-    );
-}
-
-/**
- * Aggregate streamed GenerateContentResponse chunks into one response object
- * (same shape as a non-streaming generateContent JSON body).
- * Mirrors @google/generative-ai aggregateResponses().
- */
-function aggregateGeminiStreamChunks(responses) {
-    const lastResponse = responses[responses.length - 1];
-    const aggregatedResponse = {
-        promptFeedback: lastResponse?.promptFeedback,
-    };
-    for (const response of responses) {
-        if (response?.candidates) {
-            let candidateIndex = 0;
-            for (const candidate of response.candidates) {
-                if (!aggregatedResponse.candidates) aggregatedResponse.candidates = [];
-                if (!aggregatedResponse.candidates[candidateIndex]) {
-                    aggregatedResponse.candidates[candidateIndex] = { index: candidateIndex };
-                }
-                const aggCand = aggregatedResponse.candidates[candidateIndex];
-                aggCand.citationMetadata = candidate.citationMetadata;
-                aggCand.groundingMetadata = candidate.groundingMetadata;
-                aggCand.finishReason = candidate.finishReason;
-                aggCand.finishMessage = candidate.finishMessage;
-                aggCand.safetyRatings = candidate.safetyRatings;
-                if (candidate.content?.parts) {
-                    if (!aggCand.content) {
-                        aggCand.content = {
-                            role: candidate.content.role || 'user',
-                            parts: [],
-                        };
-                    }
-                    for (const part of candidate.content.parts) {
-                        const newPart = {};
-                        if (part.text) newPart.text = part.text;
-                        if (part.functionCall) newPart.functionCall = part.functionCall;
-                        if (part.thoughtSignature) newPart.thoughtSignature = part.thoughtSignature;
-                        if (part.thought_signature) newPart.thought_signature = part.thought_signature;
-                        if (part.executableCode) newPart.executableCode = part.executableCode;
-                        if (part.codeExecutionResult) newPart.codeExecutionResult = part.codeExecutionResult;
-                        if (Object.keys(newPart).length === 0) newPart.text = '';
-                        aggCand.content.parts.push(newPart);
-                    }
-                }
-                candidateIndex++;
-            }
-        }
-        if (response?.usageMetadata) aggregatedResponse.usageMetadata = response.usageMetadata;
-    }
-    return aggregatedResponse;
-}
-
-function assertGeminiStreamCompleted({ sawStreamChunk, finishReason, label }) {
-    if (!sawStreamChunk) {
-        throw geminiTruncatedStreamError(`${label} truncated: empty stream`);
-    }
-    if (!finishReason) {
-        throw geminiTruncatedStreamError(`${label} truncated: no finishReason`);
-    }
-}
-
-// Concatenate the text parts of a single streamed Gemini chunk. Used to feed
-// the gateway live-text relay (onTextDelta) with the incremental text payload
-// as each SSE/SDK chunk arrives. Returns '' for tool-call / thought-only /
-// malformed chunks so the caller can skip empty emits.
-function geminiChunkText(chunk) {
-    const parts = chunk?.candidates?.[0]?.content?.parts;
-    if (!Array.isArray(parts)) return '';
-    let text = '';
-    for (const p of parts) {
-        if (p && typeof p.text === 'string') text += p.text;
-    }
-    return text;
-}
-
-function relayGeminiStreamText(t, { onTextDelta, textLeakGuard }) {
-    if (!t) return;
-    if (textLeakGuard) textLeakGuard.feedText(t);
-    else if (onTextDelta) { try { onTextDelta(t); } catch {} }
-}
-
-/**
- * Rolling scanner for tool calls leaked as plain XML/antml tags inside Gemini
- * `part.text` streams. Mirrors the Anthropic OAuth guard: suppress tags from
- * visible text, synthesize known-tool calls, dispatch via onToolCall.
- */
-export function createGeminiTextLeakGuard({ knownToolNames, onTextDelta, onToolCall, onStreamDelta }) {
-    const _knownTools = knownToolNames instanceof Set
-        ? knownToolNames
-        : new Set(Array.isArray(knownToolNames) ? knownToolNames : []);
-    const _enabled = _knownTools.size > 0;
-    const _isKnownTool = (name) => _knownTools.has(name);
-    let leakBuffer = '';
-    const leakedCalls = [];
-    const dispatchedFingerprints = new Set();
-
-    const toolCallFingerprint = (name, args) => {
-        let a = args;
-        if (a === null || typeof a !== 'object' || Array.isArray(a)) a = {};
-        return traceHash(stableTraceStringify({ name: name || '', args: a }));
-    };
-
-    const dispatchLeakedCall = (recovered) => {
-        let args = recovered?.arguments;
-        if (args === null || typeof args !== 'object' || Array.isArray(args)) args = {};
-        const fp = toolCallFingerprint(recovered.name, args);
-        if (dispatchedFingerprints.has(fp)) return;
-        dispatchedFingerprints.add(fp);
-        const idHash = traceHash(stableTraceStringify({
-            name: recovered.name,
-            args,
-            leak: true,
-        })).slice(0, 16);
-        const call = {
-            id: `gemini_leaked_${idHash}`,
-            name: recovered.name,
-            arguments: args,
-        };
-        leakedCalls.push(call);
-        try { onToolCall?.(call); } catch {}
-        try { onStreamDelta?.(); } catch {}
-    };
-
-    const pumpLeakBuffer = (final) => {
-        if (!_enabled) return;
-        if (!leakBuffer && !final) return;
-        const { emit, calls, rest } = scanLeakedToolCalls(leakBuffer, { isKnownTool: _isKnownTool, final });
-        leakBuffer = rest;
-        if (emit && onTextDelta) {
-            try { onTextDelta(emit); } catch {}
-        }
-        for (const c of calls) dispatchLeakedCall(c);
-    };
-
-    return {
-        get enabled() { return _enabled; },
-        feedText(text) {
-            if (!text) return;
-            if (!_enabled) {
-                try { onTextDelta?.(text); } catch {}
-                return;
-            }
-            leakBuffer += text;
-            pumpLeakBuffer(false);
-        },
-        finalize() {
-            pumpLeakBuffer(true);
-        },
-        scrubAssistantText(raw) {
-            if (!raw) return '';
-            if (!_enabled) return raw;
-            const { emit, calls, rest } = scanLeakedToolCalls(raw, { isKnownTool: _isKnownTool, final: true });
-            for (const c of calls) dispatchLeakedCall(c);
-            return emit + rest;
-        },
-        filterNativeToolCalls(nativeCalls) {
-            if (!_enabled || !nativeCalls?.length) return nativeCalls;
-            const kept = [];
-            for (const call of nativeCalls) {
-                const fp = toolCallFingerprint(call?.name, call?.arguments);
-                if (dispatchedFingerprints.has(fp)) continue;
-                dispatchedFingerprints.add(fp);
-                kept.push(call);
-            }
-            return kept.length ? kept : undefined;
-        },
-        getLeakedToolCalls() {
-            return leakedCalls.length ? [...leakedCalls] : [];
-        },
-    };
-}
-
-async function consumeGeminiRestStreamResponse(response, { signal, onStreamDelta, onTextDelta, textLeakGuard, label }) {
-    if (!response?.body) throw new Error(`${label}: missing response body`);
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    const allChunks = [];
-    let sawStreamChunk = false;
-    let idleTimedOut = false;
-    let idleTimer = null;
-    let idleReject = null;
-
-    let firstByteTimer = setTimeout(() => {
-        try { reader.cancel('first byte timeout'); } catch {}
-        if (idleReject) {
-            const e = geminiTimeoutError(`${label} first byte`, GEMINI_FIRST_BYTE_TIMEOUT_MS);
-            const r = idleReject; idleReject = null; r(e);
-        }
-    }, GEMINI_FIRST_BYTE_TIMEOUT_MS);
-    if (firstByteTimer.unref) firstByteTimer.unref();
-
-    const clearFirstByteTimer = () => {
-        if (firstByteTimer) {
-            clearTimeout(firstByteTimer);
-            firstByteTimer = null;
-        }
-    };
-
-    const resetIdleTimer = () => {
-        if (!PROVIDER_SSE_IDLE_WATCHDOG_ENABLED) return;
-        if (idleTimer) clearTimeout(idleTimer);
-        idleTimer = setTimeout(() => {
-            idleTimedOut = true;
-            try { reader.cancel('SSE idle timeout'); } catch {}
-            if (idleReject) {
-                const e = geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
-                const r = idleReject; idleReject = null; r(e);
-            }
-        }, PROVIDER_SSE_IDLE_TIMEOUT_MS);
-        if (idleTimer.unref) idleTimer.unref();
-    };
-
-    const onAbort = () => {
-        try {
-            const c = reader.cancel('aborted');
-            if (c && typeof c.catch === 'function') c.catch(() => {});
-        } catch {}
-    };
-
-    if (signal) {
-        if (signal.aborted) {
-            const reason = signal.reason;
-            throw reason instanceof Error ? reason : new Error(`${label} aborted`);
-        }
-        signal.addEventListener('abort', onAbort, { once: true });
-    }
-
-    try {
-        resetIdleTimer();
-        while (true) {
-            let chunk;
-            try {
-                chunk = await new Promise((resolve, reject) => {
-                    idleReject = reject;
-                    reader.read().then(resolve, reject);
-                });
-            } catch (err) {
-                if (idleTimedOut) {
-                    throw geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
-                }
-                if (signal?.aborted) {
-                    const reason = signal.reason;
-                    throw reason instanceof Error ? reason : new Error(`${label} aborted`);
-                }
-                throw err;
-            } finally {
-                idleReject = null;
-            }
-            const { done, value } = chunk;
-            if (done) break;
-            resetIdleTimer();
-            buffer += decoder.decode(value, { stream: true });
-            let lineEnd;
-            while ((lineEnd = buffer.indexOf('\n')) >= 0) {
-                let line = buffer.slice(0, lineEnd);
-                buffer = buffer.slice(lineEnd + 1);
-                line = line.replace(/\r$/, '');
-                if (!line.startsWith('data: ')) continue;
-                const data = line.slice(6).trim();
-                if (!data || data === '[DONE]') continue;
-                let parsed;
-                try { parsed = JSON.parse(data); } catch { continue; }
-                if (!sawStreamChunk) {
-                    sawStreamChunk = true;
-                    clearFirstByteTimer();
-                }
-                allChunks.push(parsed);
-                try { onStreamDelta?.(); } catch {}
-                if (onTextDelta || textLeakGuard) {
-                    const t = geminiChunkText(parsed);
-                    relayGeminiStreamText(t, { onTextDelta, textLeakGuard });
-                }
-            }
-        }
-        if (buffer.trim()) {
-            const line = buffer.trim().replace(/\r$/, '');
-            if (line.startsWith('data: ')) {
-                const data = line.slice(6).trim();
-                if (data && data !== '[DONE]') {
-                    try {
-                        const parsed = JSON.parse(data);
-                        if (!sawStreamChunk) {
-                            sawStreamChunk = true;
-                            clearFirstByteTimer();
-                        }
-                        allChunks.push(parsed);
-                        try { onStreamDelta?.(); } catch {}
-                        if (onTextDelta || textLeakGuard) {
-                            const t = geminiChunkText(parsed);
-                            relayGeminiStreamText(t, { onTextDelta, textLeakGuard });
-                        }
-                    } catch { /* skip malformed tail */ }
-                }
-            }
-        }
-    } finally {
-        clearFirstByteTimer();
-        if (idleTimer) clearTimeout(idleTimer);
-        if (signal) signal.removeEventListener('abort', onAbort);
-        try { reader.releaseLock(); } catch {}
-        try { textLeakGuard?.finalize(); } catch {}
-    }
-
-    const aggregated = aggregateGeminiStreamChunks(allChunks);
-    const finishReason = aggregated.candidates?.[0]?.finishReason || null;
-    assertGeminiStreamCompleted({ sawStreamChunk, finishReason, label });
-    return aggregated;
-}
-
-async function consumeGeminiSdkStream(streamResult, { signal, onStreamDelta, onTextDelta, textLeakGuard, label }) {
-    let sawStreamChunk = false;
-    let idleTimedOut = false;
-    let idleTimer = null;
-    let firstByteReject = null;
-    let firstByteTimer = null;
-    let inFlightReject = null;
-
-    const armFirstByteTimer = () => {
-        if (firstByteTimer) clearTimeout(firstByteTimer);
-        firstByteTimer = setTimeout(() => {
-            if (firstByteReject) {
-                const e = geminiTimeoutError(`${label} first byte`, GEMINI_FIRST_BYTE_TIMEOUT_MS);
-                const r = firstByteReject; firstByteReject = null; r(e);
-            }
-        }, GEMINI_FIRST_BYTE_TIMEOUT_MS);
-        if (firstByteTimer.unref) firstByteTimer.unref();
-    };
-
-    const clearFirstByteTimer = () => {
-        if (firstByteTimer) {
-            clearTimeout(firstByteTimer);
-            firstByteTimer = null;
-        }
-        firstByteReject = null;
-    };
-
-    const resetIdleTimer = () => {
-        if (!PROVIDER_SSE_IDLE_WATCHDOG_ENABLED) return;
-        if (idleTimer) clearTimeout(idleTimer);
-        idleTimer = setTimeout(() => {
-            idleTimedOut = true;
-            if (inFlightReject) {
-                const e = geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
-                const r = inFlightReject; inFlightReject = null; r(e);
-            }
-        }, PROVIDER_SSE_IDLE_TIMEOUT_MS);
-        if (idleTimer.unref) idleTimer.unref();
-    };
-
-    if (signal?.aborted) {
-        const reason = signal.reason;
-        throw reason instanceof Error ? reason : new Error(`${label} aborted`);
-    }
-
-    const iterator = streamResult.stream[Symbol.asyncIterator]();
-
-    // Wire the abort signal to actually CANCEL iteration (mirror of the REST
-    // consumer's onAbort -> reader.cancel). Without this, a parent / client /
-    // gateway abort that fires AFTER the first byte — with the SSE idle
-    // watchdog off by default — would leave iterator.next() hanging: the loop
-    // below only reads `signal` for error translation, never to interrupt the
-    // pending read. Rejecting the in-flight promise and returning the iterator
-    // releases it promptly even if the SDK is slow to propagate the underlying
-    // request abort.
-    let onSignalAbort = null;
-    if (signal) {
-        onSignalAbort = () => {
-            const reason = signal.reason;
-            const err = reason instanceof Error ? reason : new Error(`${label} aborted`);
-            if (inFlightReject) {
-                const r = inFlightReject;
-                inFlightReject = null;
-                firstByteReject = null;
-                r(err);
-            }
-            try {
-                const ret = iterator.return?.();
-                if (ret && typeof ret.catch === 'function') ret.catch(() => {});
-            } catch {}
-        };
-        signal.addEventListener('abort', onSignalAbort, { once: true });
-    }
-
-    try {
-        armFirstByteTimer();
-        resetIdleTimer();
-        while (true) {
-            if (idleTimedOut) {
-                throw geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
-            }
-            let step;
-            try {
-                step = await new Promise((resolve, reject) => {
-                    inFlightReject = reject;
-                    if (!sawStreamChunk) firstByteReject = reject;
-                    iterator.next().then(
-                        (value) => {
-                            inFlightReject = null;
-                            firstByteReject = null;
-                            resolve(value);
-                        },
-                        (err) => {
-                            inFlightReject = null;
-                            firstByteReject = null;
-                            reject(err);
-                        },
-                    );
-                });
-            } catch (err) {
-                if (idleTimedOut) {
-                    throw geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
-                }
-                if (signal?.aborted) {
-                    const reason = signal.reason;
-                    throw reason instanceof Error ? reason : new Error(`${label} aborted`);
-                }
-                throw err;
-            }
-            if (step.done) break;
-            if (!sawStreamChunk) {
-                sawStreamChunk = true;
-                clearFirstByteTimer();
-            }
-            resetIdleTimer();
-            try { onStreamDelta?.(); } catch {}
-            if (onTextDelta || textLeakGuard) {
-                const t = geminiChunkText(step.value);
-                relayGeminiStreamText(t, { onTextDelta, textLeakGuard });
-            }
-        }
-        if (idleTimedOut) {
-            throw geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
-        }
-    } catch (err) {
-        clearFirstByteTimer();
-        if (signal?.aborted) {
-            const reason = signal.reason;
-            throw reason instanceof Error ? reason : new Error(`${label} aborted`);
-        }
-        throw err;
-    } finally {
-        clearFirstByteTimer();
-        if (idleTimer) clearTimeout(idleTimer);
-        if (signal && onSignalAbort) {
-            try { signal.removeEventListener('abort', onSignalAbort); } catch {}
-        }
-        try { textLeakGuard?.finalize(); } catch {}
-    }
-
-    let response;
-    try {
-        response = await streamResult.response;
-    } catch (err) {
-        if (signal?.aborted) {
-            const reason = signal.reason;
-            throw reason instanceof Error ? reason : new Error(`${label} aborted`);
-        }
-        throw err;
-    }
-    const raw = response?.candidates ? response : (response?.response || response);
-    const finishReason = raw?.candidates?.[0]?.finishReason || null;
-    assertGeminiStreamCompleted({ sawStreamChunk, finishReason, label });
-    return raw;
-}
-
-/**
- * Convert JSON Schema type string to Gemini SchemaType.
- * Gemini SDK uses its own enum instead of plain strings.
- */
-function toSchemaType(t) {
-    const map = {
-        string: SchemaType.STRING,
-        number: SchemaType.NUMBER,
-        integer: SchemaType.INTEGER,
-        boolean: SchemaType.BOOLEAN,
-        array: SchemaType.ARRAY,
-        object: SchemaType.OBJECT,
-    };
-    return map[t] ?? SchemaType.STRING;
-}
-
-/**
- * Recursively convert a JSON Schema object to Gemini's FunctionDeclarationSchema.
- * Gemini requires `type` to be a SchemaType enum, not a plain string, and
- * rejects several JSON Schema fields the API does not understand
- * (additionalProperties, $schema, $ref, const, examples, definitions,
- * patternProperties). We strip those at every level.
- */
-const GEMINI_SCHEMA_STRIP = new Set([
-    'additionalProperties',
-    '$schema',
-    '$ref',
-    'const',
-    'examples',
-    'definitions',
-    'patternProperties',
-]);
-function convertSchema(schema) {
-    if (!schema || typeof schema !== 'object') return schema;
-    const result = {};
-    for (const [k, v] of Object.entries(schema)) {
-        if (GEMINI_SCHEMA_STRIP.has(k)) continue;
-        result[k] = v;
-    }
-    // Gemini's Schema validator requires every `enum` entry to be a string,
-    // even when the parent `type` is integer/number/boolean. Drop the enum in
-    // that case rather than emit an invalid typed enum — `type` plus the
-    // description still guides the model, and the tool handler revalidates.
-    const rawType = typeof result.type === 'string' ? result.type : undefined;
-    if (Array.isArray(result.enum) && (rawType === 'integer' || rawType === 'number' || rawType === 'boolean')) {
-        if (result.enum.some((item) => typeof item !== 'string')) {
-            delete result.enum;
-        }
-    }
-    // Gemini rejects array schemas that omit `items`; fill a permissive
-    // default so the declaration validates.
-    if (rawType === 'array' && (!result.items || typeof result.items !== 'object')) {
-        result.items = { type: 'string' };
-    }
-    if (typeof result.type === 'string') {
-        result.type = toSchemaType(result.type);
-    }
-    if (result.properties && typeof result.properties === 'object') {
-        const props = {};
-        for (const [key, val] of Object.entries(result.properties)) {
-            props[key] = convertSchema(val);
-        }
-        result.properties = props;
-    }
-    if (result.items && typeof result.items === 'object') {
-        result.items = convertSchema(result.items);
-    }
-    // Recurse into JSON Schema combinator keys so disallowed fields
-    // (additionalProperties, $schema, etc.) get stripped at every nesting
-    // level. Without this, schemas using anyOf/oneOf/allOf/not pass the
-    // shallow strip but fail Gemini validation at depth.
-    //
-    // Two Gemini-specific normalizations are also applied per combinator
-    // subschema:
-    //   1. Inject `type: OBJECT` when a subschema uses object-only keys
-    //      (`required` / `properties`) without an explicit type — Gemini
-    //      rejects `required` outside of OBJECT type.
-    //   2. Materialize a local `properties` map from the parent's properties
-    //      when the subschema only carries `required: [names]` — Gemini
-    //      validates that every name in `required` exists in *this*
-    //      subschema's `properties` (it does not inherit from the parent
-    //      the way JSON Schema's compositional model does).
-    for (const combinator of ['anyOf', 'oneOf', 'allOf']) {
-        if (Array.isArray(result[combinator])) {
-            result[combinator] = result[combinator].map((s) => {
-                const sub = convertSchema(s);
-                if (sub && typeof sub === 'object') {
-                    const usesObjectKeys = sub.required !== undefined || sub.properties !== undefined;
-                    if (usesObjectKeys && sub.type === undefined) {
-                        sub.type = toSchemaType('object');
-                    }
-                    if (Array.isArray(sub.required) && !sub.properties && result.properties) {
-                        const projected = {};
-                        for (const k of sub.required) {
-                            if (result.properties[k]) projected[k] = result.properties[k];
-                        }
-                        if (Object.keys(projected).length > 0) sub.properties = projected;
-                    }
-                }
-                return sub;
-            });
-        }
-    }
-    if (result.not && typeof result.not === 'object') {
-        result.not = convertSchema(result.not);
-    }
-    return result;
-}
-
-function toGeminiTools(tools) {
-    return {
-        functionDeclarations: tools.map((t) => ({
-            name: t.name,
-            description: t.description,
-            parameters: convertSchema(t.inputSchema),
-        })),
-    };
-}
-function toGeminiNativeTools(nativeTools) {
-    if (!Array.isArray(nativeTools)) return [];
-    const out = [];
-    for (const tool of nativeTools) {
-        const type = String(tool?.type || '').trim().toLowerCase();
-        if (type === 'google_search' || type === 'google_search_retrieval') {
-            out.push({ googleSearch: {} });
-        }
-    }
-    return out;
-}
-
-function collectGeminiGroundingSources(candidate) {
-    const out = [];
-    const seen = new Set();
-    const add = (source) => {
-        if (!source || typeof source !== 'object') return;
-        const web = source.web && typeof source.web === 'object' ? source.web : source;
-        const url = String(web.uri || web.url || source.uri || source.url || '').trim();
-        if (!url || seen.has(url)) return;
-        seen.add(url);
-        out.push({
-            title: String(web.title || source.title || url).trim(),
-            url,
-            snippet: '',
-            source: 'gemini-grounding',
-            provider: 'gemini',
-        });
-    };
-    const grounding = candidate?.groundingMetadata || {};
-    for (const chunk of Array.isArray(grounding.groundingChunks) ? grounding.groundingChunks : []) add(chunk);
-    const citationMetadata = candidate?.citationMetadata || {};
-    for (const source of Array.isArray(citationMetadata.citationSources) ? citationMetadata.citationSources : []) add(source);
-    return out;
-}
-
-// Map the orchestrator-level toolChoice to Gemini's functionCallingConfig.
-//   auto      -> AUTO
-//   required  -> ANY
-//   none      -> NONE
-//   { name }  -> ANY + allowedFunctionNames:[name]   (specific tool)
-function toGeminiToolConfig(toolChoice) {
-    if (toolChoice == null) return undefined;
-    if (typeof toolChoice === 'string') {
-        if (toolChoice === 'auto') return { functionCallingConfig: { mode: 'AUTO' } };
-        if (toolChoice === 'required') return { functionCallingConfig: { mode: 'ANY' } };
-        if (toolChoice === 'none') return { functionCallingConfig: { mode: 'NONE' } };
-        return undefined;
-    }
-    if (typeof toolChoice === 'object') {
-        const name = toolChoice.name || toolChoice.function?.name;
-        if (typeof name === 'string' && name) {
-            return { functionCallingConfig: { mode: 'ANY', allowedFunctionNames: [name] } };
-        }
-    }
-    return undefined;
-}
-
-function toGeminiContent(message, toolNameByCallId) {
-    if (!message || message.role === 'system') return null;
-    if (message.role === 'assistant' && message.toolCalls?.length) {
-        const parts = [];
-        if (message.content) parts.push(...normalizeContentForGeminiParts(message.content));
-        for (const tc of message.toolCalls) {
-            // Gemini 3 thinking models require the original thoughtSignature
-            // echoed back on every prior functionCall so the cached thinking
-            // prefix stays valid. v1beta places the field at the Part level
-            // (sibling of functionCall) — putting it inside functionCall returns
-            // 400 "Unknown name". Older models / first turn have no signature.
-            const part = { functionCall: { name: tc.name, args: tc.arguments } };
-            if (tc.thoughtSignature) part.thoughtSignature = tc.thoughtSignature;
-            parts.push(part);
-        }
-        return { role: 'model', parts };
-    }
-    if (message.role === 'tool') {
-        // Tool result content stays byte-identical for cache prefix stability.
-        // Gemini accepts functionResponse parts under role 'user' (per docs).
-        // Using 'user' keeps tool_result entries byte-identical between
-        // cachedContents.create (which rejects role:'function') and
-        // generateContent, so the cached prefix actually matches at runtime.
-        // functionResponse.name must be the FUNCTION name, not the synthetic
-        // toolCallId. Resolve it from the toolCallId->functionName map built
-        // from prior assistant tool_calls; fall back to the raw id only when
-        // no mapping exists.
-        const functionName = (toolNameByCallId && toolNameByCallId.get(message.toolCallId))
-            || message.toolCallId
-            || '';
-        const { response, mediaParts } = splitToolContentForGemini(message.content);
-        const parts = [{ functionResponse: { name: functionName, response } }];
-        if (mediaParts.length) parts.push(...mediaParts);
-        return {
-            role: 'user',
-            parts,
-        };
-    }
-    return {
-        role: message.role === 'assistant' ? 'model' : 'user',
-        parts: normalizeContentForGeminiParts(message.content),
-    };
-}
-
-function toGeminiContents(messages) {
-    const contents = [];
-    // Map synthetic toolCallId -> function name from prior assistant
-    // tool_calls so each functionResponse part carries the real function name.
-    const toolNameByCallId = new Map();
-    for (const m of messages) {
-        if (m?.role === 'assistant' && Array.isArray(m.toolCalls)) {
-            for (const tc of m.toolCalls) {
-                if (tc?.id && tc?.name) toolNameByCallId.set(tc.id, tc.name);
-            }
-        }
-    }
-    for (const message of messages) {
-        const content = toGeminiContent(message, toolNameByCallId);
-        if (content) contents.push(content);
-    }
-    return contents;
-}
-
-export function parseToolCalls(parts) {
-    const calls = parts.filter((p) => 'functionCall' in p && !!p.functionCall);
-    if (!calls.length)
-        return undefined;
-    // The @google/generative-ai 0.24.1 SDK predates Gemini 3 thinking — its
-    // FunctionCall type only declares { name, args }. The runtime object,
-    // however, retains whatever the wire response carried, which means the
-    // signature may sit under any of:
-    //   • part.functionCall.thoughtSignature   (camelCase, expected)
-    //   • part.functionCall.thought_signature  (snake_case, raw protobuf)
-    //   • part.thoughtSignature / part.thought_signature (sibling on Part)
-    // Read all four and use the first non-empty hit. Set MIXDOG_DEBUG_GEMINI=1
-    // to dump the raw parts so we can confirm the actual key location on the
-    // next session and harden the parser.
-    if (process.env.MIXDOG_DEBUG_GEMINI === '1') {
-        try { process.stderr.write(`[gemini fc raw] ${JSON.stringify(parts)}\n`); } catch {}
-    }
-    return calls.map((p, i) => {
-        const fc = p.functionCall;
-        const sig = fc.thoughtSignature
-            || fc.thought_signature
-            || p.thoughtSignature
-            || p.thought_signature
-            || null;
-        const idHash = traceHash(stableTraceStringify({
-            index: i,
-            name: fc.name || '',
-            args: fc.args ?? {},
-        })).slice(0, 16);
-        const call = {
-            id: `gemini_${idHash}`,
-            name: fc.name,
-            arguments: (fc.args ?? {}),
-        };
-        if (sig) call.thoughtSignature = sig;
-        return call;
-    });
-}
-
-function emitGeminiToolCalls(toolCalls, onToolCall) {
-    if (typeof onToolCall !== 'function' || !Array.isArray(toolCalls)) return;
-    const emitted = new Set();
-    for (const call of toolCalls) {
-        if (!call?.id || !call?.name || emitted.has(call.id)) continue;
-        emitted.add(call.id);
-        try { onToolCall(call); } catch {}
-    }
-}
+// --- Cache accounting/trace: extracted to gemini-cache.mjs ---
+// --- Stream consumption/guards: extracted to gemini-stream.mjs ---
+// --- Schema/content/tool-call mapping: extracted to gemini-schema.mjs ---
 
 export class GeminiProvider {
     // promptTokenCount is the total (cachedContentTokenCount is a subset), so
@@ -1851,7 +880,8 @@ export class GeminiProvider {
         _markLatestGemini(normalized);
         // LiteLLM catalog overlays pricing and updated metadata.
         const { enrichModels } = await import('./model-catalog.mjs');
-        const enriched = await enrichModels(normalized);
+        const { sanitizeModelList } = await import('./model-list-sanitize.mjs');
+        const enriched = sanitizeModelList(await enrichModels(normalized), { provider: 'gemini' });
         _modelCache.save(enriched);
         return enriched;
     }