mixdog 0.9.52 → 0.9.53

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

@@ -24,7 +24,7 @@ import {
     ANTHROPIC_MAX_MIDSTREAM_RETRIES,
     parseSSEStream,
     _classifyMidstreamError,
-} from './anthropic-oauth.mjs';
+} from './anthropic-sse.mjs';
 import { buildAnthropicBetaHeaders, supportsAnthropicFastMode } from './anthropic-betas.mjs';
 import {
     applyAnthropicEffortToBody,
@@ -34,11 +34,21 @@ import {
 import { normalizeContentForAnthropic } from './media-normalization.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
-import { providerNativeToolPrefixCount } from '../../../../session-runtime/provider-request-tools.mjs';
 import { makeModelCache } from './model-cache.mjs';
 import { resolveAnthropicMaxTokens } from './anthropic-max-tokens.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { notifyCurrentAnthropicRateLimit } from './admission-scheduler.mjs';
+import {
+    ANTHROPIC_CACHE_TTL_STABLE as CACHE_TTL_STABLE,
+    ANTHROPIC_CACHE_TTL_VOLATILE as CACHE_TTL_VOLATILE,
+    applyAnthropicCacheMarkers,
+    clampAnthropicThinkingBudget as clampThinkingBudgetTokens,
+    deferredAnthropicTools as sharedDeferredAnthropicTools,
+    requestAnthropicTools as sharedRequestAnthropicTools,
+    resolveAnthropicCacheTtls as resolveCacheTtls,
+    sanitizeAnthropicInputSchema,
+    toAnthropicToolChoice,
+} from './lib/anthropic-request-utils.mjs';
 
 const require = createRequire(import.meta.url);
 let _Anthropic = null;
@@ -61,66 +71,11 @@ function _midstreamSleepWithAbort(ms, signal) {
 // breakpoint, so they do not spend a separate cache_control slot. 1h TTL
 // requires the extended-cache-ttl beta header, which we set on the client via
 // defaultHeaders below.
-const CACHE_TTL_STABLE = { type: 'ephemeral', ttl: '1h' };
-const CACHE_TTL_VOLATILE = { type: 'ephemeral' };
-
-function withCacheControl(block, ttl = CACHE_TTL_VOLATILE) {
-    if (!block || typeof block !== 'object' || block.cache_control) return block;
-    return { ...block, cache_control: ttl };
-}
-
-function appendCacheControl(content, ttl = CACHE_TTL_VOLATILE) {
-    if (Array.isArray(content)) {
-        if (content.length === 0) return content;
-        const next = [...content];
-        next[next.length - 1] = withCacheControl(next[next.length - 1], ttl);
-        return next;
-    }
-    if (typeof content === 'string') {
-        return [withCacheControl({ type: 'text', text: content }, ttl)];
-    }
-    return content;
-}
 
 // BP3 (tier3) rides its own `system` role block (the 3rd system block, tagged
 // cacheTier:'tier3'). buildSystemBlocks applies the tier3 1h cache_control to
 // that block; BP1/BP2 take the system TTL. Mirrors anthropic-oauth.mjs.
 
-function resolveCacheTtls(opts) {
-    const strategy = opts?.cacheStrategy || {};
-    const pick = (layer, fallback) => {
-        const v = strategy[layer];
-        if (v === '1h') return CACHE_TTL_STABLE;
-        if (v === '5m') return CACHE_TTL_VOLATILE;
-        if (v === 'none') return null;
-        return fallback;
-    };
-    const resolved = {
-        tools: pick('tools', null),
-        system: pick('system', CACHE_TTL_STABLE),
-        tier3: pick('tier3', CACHE_TTL_STABLE),
-        messages: pick('messages', CACHE_TTL_STABLE),
-    };
-    // A partial cacheStrategy override (e.g. {system:'5m'} while tier3/
-    // messages default to '1h') can put a longer TTL after a shorter one in
-    // request order, which Anthropic rejects: 1h breakpoints must all appear
-    // before any 5m breakpoint. Normalize left-to-right in wire order
-    // (system -> tier3 -> messages; tools is emitted before system and is
-    // excluded from the run) so a later layer is downgraded to the earliest
-    // shorter TTL seen so far — never re-promoted. Layers set to null ('none')
-    // emit no breakpoint at all, so they neither violate nor constrain
-    // ordering and are skipped. Mirrors anthropic-oauth.mjs.
-    const ttlRank = (ttl) => (ttl === CACHE_TTL_STABLE ? 2 : 1); // 1h=2, 5m=1
-    let minRank = Infinity;
-    for (const layer of ['system', 'tier3', 'messages']) {
-        if (!resolved[layer]) continue;
-        const rank = ttlRank(resolved[layer]);
-        if (rank > minRank) resolved[layer] = CACHE_TTL_VOLATILE;
-        else minRank = rank;
-    }
-    return resolved;
-}
-
 function buildSystemBlocks(systemMsgs, systemTtl, tier3Ttl) {
     // systemMsgs is an array of { content, cacheTier }. Each non-empty element
     // becomes its own content block: cacheTier:'tier3' (BP3 sessionMarker) gets
@@ -248,84 +203,11 @@ export const _test = {
     resolveMaxTokens,
     deferredAnthropicTools,
     requestAnthropicTools,
-    sanitizeInputSchema: _sanitizeInputSchema,
+    sanitizeInputSchema: (schema, toolName) => sanitizeAnthropicInputSchema(schema, toolName, 'anthropic'),
 };
 
-const MIN_THINKING_BUDGET = 1024;
-const THINKING_OUTPUT_RESERVE = 1024;
-
-function clampThinkingBudgetTokens(value, maxTokens) {
-    const desired = Math.floor(Number(value));
-    const max = Math.floor(Number(maxTokens));
-    if (!Number.isFinite(desired) || desired <= 0 || !Number.isFinite(max)) return null;
-    const ceiling = max - THINKING_OUTPUT_RESERVE;
-    if (ceiling < MIN_THINKING_BUDGET) return null;
-    return Math.max(MIN_THINKING_BUDGET, Math.min(desired, ceiling));
-}
 // Anthropic forbids oneOf / allOf / anyOf at the TOP level of input_schema.
 // Mirror the same sanitizer as anthropic-oauth.mjs so both providers are safe.
-function _sanitizeInputSchema(schema, toolName) {
-    if (!schema || typeof schema !== 'object') {
-        return { type: 'object', properties: {} };
-    }
-    const compound = schema.oneOf || schema.anyOf || schema.allOf;
-    if (!compound) return structuredClone(schema);
-    const mergedProps = { ...(schema.properties && typeof schema.properties === 'object' ? schema.properties : {}) };
-    const branchDescs = [];
-    for (const branch of Array.isArray(compound) ? compound : []) {
-        if (branch && typeof branch === 'object' && branch.properties) {
-            Object.assign(mergedProps, branch.properties);
-        }
-        if (branch && typeof branch === 'object') {
-            const parts = [];
-            if (branch.description) parts.push(branch.description);
-            else if (branch.type) parts.push(`type:${branch.type}`);
-            if (parts.length) branchDescs.push(parts.join(' '));
-        }
-    }
-    const compoundKey = schema.oneOf ? 'oneOf' : schema.anyOf ? 'anyOf' : 'allOf';
-    let description = schema.description || '';
-    if (branchDescs.length) {
-        const parts = [];
-        let used = 0;
-        for (let i = 0; i < branchDescs.length; i++) {
-            const v = `(variant ${i + 1}: ${branchDescs[i]})`;
-            if (used + v.length + (parts.length ? 1 : 0) > 500) break;
-            parts.push(v);
-            used += v.length + (parts.length > 1 ? 1 : 0);
-        }
-        const addition = parts.join(' ');
-        if (addition) description = description ? `${description} ${addition}` : addition;
-    }
-    const mergedPropsCount = Object.keys(mergedProps).length;
-    if (process.env.MIXDOG_DEBUG_SESSION_LOG) {
-        process.stderr.write(
-            `[anthropic-sanitizer] tool="${toolName ?? ''}" compound="${compoundKey}" branches=${Array.isArray(compound) ? compound.length : 0} mergedProps=${mergedPropsCount}\n`
-        );
-    }
-    return {
-        type: 'object',
-        ...(description ? { description } : {}),
-        properties: mergedProps,
-    };
-}
-
-function toAnthropicTools(tools) {
-    return tools.map((t) => {
-        const out = {
-            name: t.name,
-            description: t.description,
-            input_schema: _sanitizeInputSchema(t.inputSchema, t.name),
-        };
-        if (t.deferLoading === true || t.defer_loading === true) out.defer_loading = true;
-        return out;
-    });
-}
-function nativeAnthropicTools(opts) {
-    return Array.isArray(opts?.nativeTools)
-        ? opts.nativeTools.filter(t => t && typeof t === 'object')
-        : [];
-}
 // Map the orchestrator-level opts.toolChoice into Anthropic's tool_choice.
 // Only 'none' is activated: it lets the hard-cap final turn keep the tool
 // DEFINITIONS in-request (so the tools->system->messages prefix — and its
@@ -339,58 +221,11 @@ function nativeAnthropicTools(opts) {
 // previously-harmless no-op into a hard 400 on exactly that turn. Attached
 // only when the request actually carries tools (see _doSend). Mirrors
 // anthropic-oauth.mjs.
-function toAnthropicToolChoice(toolChoice) {
-    return toolChoice === 'none' ? { type: 'none' } : undefined;
-}
-function discoveredAnthropicToolNames(messages, opts, provider) {
-    const anthropicNative = new Set(['anthropic', 'anthropic-oauth']);
-    const discovered = new Set(
-        Array.isArray(opts?.session?.deferredDiscoveredTools)
-            ? opts.session.deferredDiscoveredTools.map((name) => String(name || '').trim()).filter(Boolean)
-            : [],
-    );
-    for (const message of Array.isArray(messages) ? messages : []) {
-        const native = message?.nativeToolSearch;
-        const source = String(native?.provider || '').toLowerCase();
-        if (source && source !== provider
-            && !(anthropicNative.has(source) && anthropicNative.has(provider))) continue;
-        for (const name of Array.isArray(native?.toolReferences) ? native.toolReferences : []) {
-            const key = String(name || '').trim();
-            if (key) discovered.add(key);
-        }
-    }
-    return discovered;
-}
 function deferredAnthropicTools(activeTools, messages, opts) {
-    if (opts?.session?.deferredNativeTools !== true) return [];
-    // Guard against an all-deferred tools array — the API rejects it with
-    // `400: At least one tool must have defer_loading=false` (iteration-cap
-    // final turn sends tools: []). See anthropic-oauth.mjs counterpart.
-    if (!Array.isArray(activeTools) || activeTools.length === 0) return [];
-    const active = new Set((activeTools || []).map((tool) => String(tool?.name || '').trim()).filter(Boolean));
-    const discovered = discoveredAnthropicToolNames(messages, opts, 'anthropic');
-    const catalog = Array.isArray(opts.session.deferredToolCatalog) ? opts.session.deferredToolCatalog : [];
-    return catalog
-        .filter((tool) => tool?.name && discovered.has(String(tool.name)) && !active.has(String(tool.name)))
-        .map((tool) => ({ ...tool, deferLoading: true }));
+    return sharedDeferredAnthropicTools(activeTools, messages, opts, 'anthropic');
 }
 function requestAnthropicTools(tools, messages, opts) {
-    const activeTools = Array.isArray(tools) ? tools : [];
-    if (opts?.providerToolSnapshotAuthoritative === true) {
-        const nativePrefixCount = providerNativeToolPrefixCount(
-            activeTools,
-            opts.providerNativeToolPrefixCount,
-        );
-        return [
-            ...activeTools.slice(0, nativePrefixCount),
-            ...toAnthropicTools(activeTools.slice(nativePrefixCount)),
-        ];
-    }
-    const deferredTools = deferredAnthropicTools(activeTools, messages, opts);
-    return [
-        ...nativeAnthropicTools(opts),
-        ...toAnthropicTools([...activeTools, ...deferredTools]),
-    ];
+    return sharedRequestAnthropicTools(tools, messages, opts, 'anthropic');
 }
 function toAnthropicMessages(messages) {
     // Marker-free lowering. cache_control is applied AFTER sanitization by
@@ -492,92 +327,6 @@ export function _toAnthropicMessagesForTest(messages) {
 // messageTtl === null disables the tail. BP3 (tier3) now rides a system block,
 // so it is no longer marked here.
 // ANTHROPIC_MSG_SLOTS=0 is honoured upstream by passing messageTtl = null.
-function applyAnthropicCacheMarkers(sanitizedMessages, { messageTtl = CACHE_TTL_VOLATILE, messageSlots = 1 } = {}) {
-    if (!Array.isArray(sanitizedMessages) || sanitizedMessages.length === 0) {
-        return sanitizedMessages;
-    }
-
-    const firstText = (content) => {
-        if (typeof content === 'string') return content;
-        if (Array.isArray(content)) {
-            const first = content.find((b) => b?.type === 'text');
-            return first && typeof first.text === 'string' ? first.text : '';
-        }
-        return '';
-    };
-    const isSystemReminder = (content) => firstText(content).startsWith('<system-reminder>');
-
-    const markLast = (msg, ttl) => {
-        if (!msg) return;
-        msg.content = appendCacheControl(msg.content, ttl);
-    };
-    const ttlRank = (ttl) => ttl?.ttl === '1h' ? 2 : 1;
-    const canMarkMessageIdx = (idx) => {
-        // System-reminder messages (volatileTail / roleSpecific BP4) vary
-        // per-call, so never pin them with a 1h marker. The 1h system blocks
-        // (BP1/BP2/BP3) already satisfy Anthropic's "1h before 5m" ordering.
-        if (idx < 0) return false;
-        const msg = sanitizedMessages[idx];
-        if (ttlRank(messageTtl) > ttlRank(CACHE_TTL_VOLATILE)
-            && isSystemReminder(msg?.content)) {
-            return false;
-        }
-        return true;
-    };
-    const hasUserText = (msg) => {
-        if (msg?.role !== 'user') return false;
-        if (isSystemReminder(msg.content)) return false;
-        if (typeof msg.content === 'string') return msg.content.trim().length > 0;
-        if (!Array.isArray(msg.content)) return false;
-        return msg.content.some(b => b?.type === 'text' && typeof b.text === 'string' && b.text.trim().length > 0);
-    };
-    const previousUserTextAnchorIdx = () => {
-        const tailIdx = sanitizedMessages.length - 1;
-        for (let i = tailIdx - 1; i >= 0; i--) {
-            if (hasUserText(sanitizedMessages[i])) return i;
-        }
-        return -1;
-    };
-    const latestToolResultTailIdx = () => {
-        for (let i = sanitizedMessages.length - 1; i >= 0; i--) {
-            const msg = sanitizedMessages[i];
-            if (msg?.role !== 'user' || !Array.isArray(msg.content) || msg.content.length === 0) continue;
-            const lastBlock = msg.content[msg.content.length - 1];
-            if (lastBlock?.type === 'tool_result') return i;
-        }
-        return -1;
-    };
-
-    const firstRequestUserPromptIdx = () => {
-        // Iteration-1 fallback: on the very first request a session has only the
-        // current user prompt — no tool_result tail and no earlier user turn, so
-        // both anchors above return -1 and NO message breakpoint is placed. That
-        // left the whole tools+system prefix (~4.2k) uncached on iter1: nothing
-        // was written, so iter2 re-sent it as a fresh full write instead of a
-        // read hit. Anchor the current prompt's tail so the stable prefix is
-        // cache-written on the first ask and read back on the next. Only used
-        // when neither real anchor exists, so later turns still prefer the
-        // tool_result / previous-user-text anchors (never the volatile new
-        // prompt). Synthetic <system-reminder> turns are excluded by hasUserText.
-        if (latestToolResultTailIdx() !== -1 || previousUserTextAnchorIdx() !== -1) return -1;
-        const tailIdx = sanitizedMessages.length - 1;
-        return hasUserText(sanitizedMessages[tailIdx]) ? tailIdx : -1;
-    };
-    if (messageTtl !== null) {
-        const slots = Math.max(0, Math.min(4, Number(messageSlots) || 0));
-        const marked = new Set();
-        const candidates = [latestToolResultTailIdx(), previousUserTextAnchorIdx(), firstRequestUserPromptIdx()];
-        for (const idx of candidates) {
-            if (slots <= 0) break;
-            if (idx < 0 || marked.has(idx) || !canMarkMessageIdx(idx)) continue;
-            markLast(sanitizedMessages[idx], messageTtl);
-            marked.add(idx);
-            if (marked.size >= slots) break;
-        }
-    }
-
-    return sanitizedMessages;
-}
 export class AnthropicProvider {
     // Anthropic reports usage.input_tokens EXCLUDING cache_read/cache_creation
     // (those are separate fields), so the live context-window footprint must
@@ -799,6 +548,9 @@ export class AnthropicProvider {
                     rawUsage: usageRaw,
                     provider: this.name,
                     requestKind: opts.requestKind || null,
+                    // Anthropic usage is additive at this inner transport
+                    // boundary, even when OpenCode Go supplies the provider id.
+                    inputTokensInclusive: false,
                 });
             }
 

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

@@ -204,12 +204,29 @@ export function _resolveGeminiCacheUsage({ usageMetadata, cachedContent, provide
         }
         return 0;
     };
-    const inputTokens = firstFinite(
+    const promptTokens = firstFinite(
         usageMetadata?.promptTokenCount,
         usageMetadata?.prompt_token_count,
+    );
+    const totalTokens = firstFinite(
         usageMetadata?.totalTokenCount,
         usageMetadata?.total_token_count,
     );
+    // Gemini totalTokenCount includes candidate and thought output tokens.
+    // When promptTokenCount is omitted, derive the prompt portion so callers
+    // that separately record output tokens do not count them twice.
+    const outputTokens = firstFinite(
+        usageMetadata?.candidatesTokenCount,
+        usageMetadata?.candidates_token_count,
+    ) + firstFinite(
+        usageMetadata?.thoughtsTokenCount,
+        usageMetadata?.thoughts_token_count,
+    );
+    const hasExplicitPromptTokens = Object.prototype.hasOwnProperty.call(usageMetadata || {}, 'promptTokenCount')
+        || Object.prototype.hasOwnProperty.call(usageMetadata || {}, 'prompt_token_count');
+    const inputTokens = hasExplicitPromptTokens
+        ? promptTokens
+        : Math.max(0, totalTokens - outputTokens);
     const reportedCachedTokens = firstFinite(
         // generateContent UsageMetadata field.
         usageMetadata?.cachedContentTokenCount,

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

@@ -1,6 +1,5 @@
 import { GoogleGenerativeAI } from '@google/generative-ai';
 import { getAgentApiKey } from '../../../shared/provider-api-key.mjs';
-import { makeModelCache } from './model-cache.mjs';
 import { withRetry } from './retry-classifier.mjs';
 import { traceAgentUsage, appendAgentTrace } from '../agent-trace.mjs';
 import {
@@ -50,107 +49,26 @@ import {
     _geminiCredentialFingerprint,
     _invalidateGeminiCachesForCredentialFingerprint,
 } from './gemini-cache.mjs';
+import {
+    GEMINI_MODELS as MODELS,
+    DEFAULT_GEMINI_MODEL as DEFAULT_MODEL,
+    geminiModelCache as _modelCache,
+    fetchGeminiModelPages,
+    resolveLatestGeminiModel,
+    ensureLatestGeminiModel,
+    fetchAndCacheGeminiModels,
+} from './lib/gemini-model-catalog.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, parseGeminiTextPartMetadata };
-
-const MODELS = [
-    { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash Preview', provider: 'gemini', contextWindow: 1048576 },
-    { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro Preview', provider: 'gemini', contextWindow: 1048576 },
-    { id: 'gemini-3-pro-preview', name: 'Gemini 3 Pro Preview', provider: 'gemini', contextWindow: 1048576 },
-    { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', provider: 'gemini', contextWindow: 1048576 },
-    { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', provider: 'gemini', contextWindow: 1048576 },
-];
-
-const DEFAULT_MODEL = MODELS[0].id;
-
-// --- Model catalog cache (24h disk TTL) ---
-// Gemini's /models has no `created` timestamp, so latest-resolution is
-// VERSION-based (parse gemini-X.Y) rather than release-date based.
-const MODEL_CACHE_TTL_MS = 24 * 60 * 60_000;
-// Bump when the on-disk cache shape changes so stale-shape entries are
-// discarded instead of misread.
-const GEMINI_MODEL_CACHE_SCHEMA_VERSION = 2;
+export { fetchGeminiModelPages, resolveLatestGeminiModel, ensureLatestGeminiModel };
 
 // De-dupes concurrent force-refreshes so they share one HTTP round-trip,
 // mirroring anthropic-oauth's _modelRefreshInFlight.
 let _modelRefreshInFlight = null;
 
-export async function fetchGeminiModelPages(apiKey, fetchFn = fetch) {
-    const items = [];
-    let pageToken = '';
-    do {
-        const params = new URLSearchParams({ key: apiKey, pageSize: '1000' });
-        if (pageToken) params.set('pageToken', pageToken);
-        const url = `https://generativelanguage.googleapis.com/v1beta/models?${params}`;
-        const res = await fetchFn(url, {
-            signal: AbortSignal.timeout(60_000),
-            dispatcher: getLlmDispatcher(),
-        });
-        if (!res.ok) throw new Error(`gemini list_models ${res.status}`);
-        const data = await res.json();
-        if (Array.isArray(data?.models)) items.push(...data.models);
-        pageToken = typeof data?.nextPageToken === 'string' ? data.nextPageToken : '';
-    } while (pageToken);
-    return items;
-}
-
-const _modelCache = makeModelCache({
-    fileName: 'gemini-models.json',
-    ttlMs: MODEL_CACHE_TTL_MS,
-    version: GEMINI_MODEL_CACHE_SCHEMA_VERSION,
-});
-
-// Mirror of anthropic-oauth.mjs _compareVersion: compare two gemini ids by the
-// X.Y version embedded in the id (gemini-3.5-flash -> [3, 5]). Falls back to a
-// lexicographic tiebreak so ordering is total.
-function _compareVersion(a, b) {
-    const na = (a.match(/gemini-(\d+)(?:\.(\d+))?/) || []).slice(1).map(Number);
-    const nb = (b.match(/gemini-(\d+)(?:\.(\d+))?/) || []).slice(1).map(Number);
-    for (let i = 0; i < Math.max(na.length, nb.length); i++) {
-        if ((na[i] || 0) !== (nb[i] || 0)) return (na[i] || 0) - (nb[i] || 0);
-    }
-    return a.localeCompare(b);
-}
-
-// Per family, mark the highest-version model as latest:true.
-function _markLatestGemini(models) {
-    const byFamily = new Map();
-    for (const m of models) {
-        if (!m?.id) continue;
-        const cur = byFamily.get(m.family);
-        if (!cur || _compareVersion(m.id, cur.id) > 0) {
-            byFamily.set(m.family, m);
-        }
-    }
-    for (const m of byFamily.values()) m.latest = true;
-}
-
-// Newest chat model by VERSION in the 'gemini-flash' family, read from the
-// on-disk catalog cache. Returns null until cached; callers warm via
-// ensureLatestGeminiModel when null.
-export function resolveLatestGeminiModel() {
-    const cached = _modelCache.loadSync();
-    if (!Array.isArray(cached)) return null;
-    let best = null;
-    for (const m of cached) {
-        if (!m?.id || m.family !== 'gemini-flash') continue;
-        if (!best || _compareVersion(m.id, best.id) > 0) best = m;
-    }
-    return best?.id || null;
-}
-
-export async function ensureLatestGeminiModel(provider) {
-    let m = resolveLatestGeminiModel();
-    if (m) return m;
-    await provider._refreshModelCache();
-    m = resolveLatestGeminiModel();
-    if (m) return m;
-    throw new Error('[gemini] model catalog unavailable after warmup — cannot resolve default model');
-}
-
 // --- 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 ---
@@ -918,45 +836,12 @@ export class GeminiProvider {
     // TTL check) and _refreshModelCache() (bypassing it). Throws on failure so
     // each caller applies its own fallback/logging.
     async _fetchAndCacheModels(apiKey) {
-        const items = await fetchGeminiModelPages(apiKey, this._fetch);
-        // Filter to Gemini family; skip embedding/imagen and non-coding SKUs
-        // (robotics, computer-use) that the chat picker should never show.
-        const normalized = items
-            .filter(m => (m?.name || '').includes('gemini'))
-            .filter(m => !Array.isArray(m?.supportedGenerationMethods)
-                || m.supportedGenerationMethods.includes('generateContent'))
-            .filter(m => !/embedding|aqa|imagen|robotics|computer-use/.test(m?.name || ''))
-            .map(m => {
-                const id = (m.name || '').replace(/^models\//, '');
-                const family = /flash-lite/.test(id) ? 'gemini-flash-lite'
-                    : /flash/.test(id) ? 'gemini-flash'
-                    : /pro/.test(id) ? 'gemini-pro'
-                    : 'gemini';
-                return {
-                    id,
-                    display: m.displayName || id,
-                    family,
-                    provider: 'gemini',
-                    // No fabricated fallbacks: when the API omits limits leave
-                    // them null so enrichModels can fill from the catalog and
-                    // the picker shows no context label instead of a fake 1M.
-                    contextWindow: m.inputTokenLimit || null,
-                    outputTokens: m.outputTokenLimit || null,
-                    tier: 'version',
-                    latest: false,
-                    description: m.description || '',
-                };
-            });
-        _markLatestGemini(normalized);
-        // LiteLLM catalog overlays pricing and updated metadata.
-        const { enrichModels } = await import('./model-catalog.mjs');
-        const { sanitizeModelList } = await import('./model-list-sanitize.mjs');
-        const enriched = sanitizeModelList(await enrichModels(normalized, {
+        return fetchAndCacheGeminiModels({
+            apiKey,
             fetchFn: this._fetch,
-            force: this.config.catalogForceRefresh === true,
-        }), { provider: 'gemini' });
-        this._modelCache.save(enriched);
-        return enriched;
+            modelCache: this._modelCache,
+            catalogForceRefresh: this.config.catalogForceRefresh,
+        });
     }
 
     // Force a catalog refresh (ignores the 24h disk TTL). De-duped via