mixdog 0.9.53 → 0.9.55

package/src/lib/keychain-cjs.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const { spawnSync } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 const { resolvePluginData } = require('./plugin-paths.cjs');
@@ -12,16 +12,18 @@ const KEYCHAIN_TIMEOUT_MS = Number(process.env.MIXDOG_KEYCHAIN_TIMEOUT_MS || 150
 const POWERSHELL_TIMEOUT_MS = KEYCHAIN_TIMEOUT_MS;
 
 // ---------------------------------------------------------------------------
-// getSecret read cache — collapse repeated reads during a turn while bounding
-// cross-process staleness. Misses are never cached, so a token saved by another
-// process becomes visible immediately; hits expire so rotations are observed.
+// getSecret read cache — decrypted secrets stay resident for this process by
+// default, avoiding repeated synchronous keychain subprocesses. An explicit
+// finite TTL can bound cross-process staleness; 0 disables the cache.
 // ---------------------------------------------------------------------------
 const KEYCHAIN_CACHE_TTL_MS = (() => {
     const value = Number(process.env.MIXDOG_KEYCHAIN_CACHE_TTL_MS);
-    return Number.isFinite(value) && value >= 0 ? value : 30000;
+    return Number.isFinite(value) && value >= 0 ? value : Number.POSITIVE_INFINITY;
 })();
 /** @type {Map<string, {value: string, expiresAt: number}>} */
 const _secretCache = new Map();
+const _cacheGenerations = new Map();
+let _cacheEpoch = 0;
 
 function _cacheGet(account) {
     const key = `${SERVICE}\0${account}`;
@@ -38,17 +40,22 @@ function _cacheSet(account, value) {
     if (value == null || KEYCHAIN_CACHE_TTL_MS === 0) return;
     _secretCache.set(`${SERVICE}\0${account}`, {
         value,
-        expiresAt: Date.now() + KEYCHAIN_CACHE_TTL_MS,
+        expiresAt: KEYCHAIN_CACHE_TTL_MS === Number.POSITIVE_INFINITY
+            ? Number.POSITIVE_INFINITY
+            : Date.now() + KEYCHAIN_CACHE_TTL_MS,
     });
 }
 
 function _cacheInvalidate(account) {
     _secretCache.delete(`${SERVICE}\0${account}`);
+    _cacheGenerations.set(account, (_cacheGenerations.get(account) || 0) + 1);
 }
 
 function invalidateSecretCache(account) {
     if (account == null) {
         _secretCache.clear();
+        _cacheGenerations.clear();
+        _cacheEpoch += 1;
         return;
     }
     _cacheInvalidate(account);
@@ -91,6 +98,25 @@ function run(cmd, args, opts) {
 
 // PS 5.1(powershell.exe) first: pwsh(PS 7) does not auto-load ProtectedData assembly,
 // so DPAPI calls silently fail there. Windows always ships powershell.exe.
+function resolvePowershellExe() {
+    const sysRoot = process.env.SystemRoot || process.env.windir;
+    if (!sysRoot) {
+        throw new Error('[keychain] cannot resolve SystemRoot to locate powershell.exe for DPAPI');
+    }
+    return path.join(sysRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+}
+
+function powershellEnv() {
+    const env = {};
+    for (const key of [
+        'SystemRoot', 'windir', 'PATH', 'PATHEXT',
+        'TEMP', 'TMP', 'USERPROFILE',
+    ]) {
+        if (process.env[key] !== undefined) env[key] = process.env[key];
+    }
+    return env;
+}
+
 function powershell(script) {
     // Bound DPAPI PowerShell calls with a timeout: a hung powershell.exe
     // (AV scan stall, profile loader, transient cert chain lookup) would
@@ -101,26 +127,52 @@ function powershell(script) {
     // a PATH lookup, so a shadow `powershell.exe` earlier in PATH cannot hijack
     // secret encryption/decryption. (pwsh/PS7 is intentionally not used: it does
     // not auto-load the ProtectedData assembly, so DPAPI silently fails there.)
-    const _sysRoot = process.env.SystemRoot || process.env.windir;
-    if (!_sysRoot) {
-        throw new Error('[keychain] cannot resolve SystemRoot to locate powershell.exe for DPAPI');
-    }
-    const _psHosts = [path.join(_sysRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')];
-    let timedOut = null;
-    for (const exe of _psHosts) {
-        const r = run(exe, ['-NonInteractive', '-NoProfile', '-Command', script], { timeout: POWERSHELL_TIMEOUT_MS });
-        if (r.error && r.error.code === 'ENOENT') continue;
-        if (r.error && r.error.code === 'ETIMEDOUT') {
-            timedOut = { exe, timeoutMs: POWERSHELL_TIMEOUT_MS };
-            continue;
-        }
-        return r;
+    const exe = resolvePowershellExe();
+    const r = run(exe, ['-NonInteractive', '-NoProfile', '-Command', script], { timeout: POWERSHELL_TIMEOUT_MS });
+    if (r.error && r.error.code === 'ETIMEDOUT') {
+        throw new Error(`[keychain] PowerShell DPAPI command timed out after ${POWERSHELL_TIMEOUT_MS}ms (host: ${exe})`);
     }
-    if (timedOut) {
-        throw new Error(`[keychain] PowerShell DPAPI command timed out after ${timedOut.timeoutMs}ms (last host: ${timedOut.exe})`);
+    if (r.error && r.error.code === 'ENOENT') {
+        throw new Error(`[keychain] PowerShell not found: ${exe}`);
     }
-    const err = new Error('[keychain] PowerShell not found (tried powershell, pwsh)');
-    throw err;
+    return r;
+}
+
+function powershellAsync(script) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(
+                resolvePowershellExe(),
+                ['-NonInteractive', '-NoProfile', '-Command', script],
+                {
+                    env: powershellEnv(),
+                    shell: false,
+                    windowsHide: true,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    timeout: POWERSHELL_TIMEOUT_MS,
+                },
+            );
+        } catch (error) {
+            resolve({ status: null, stdout: '', stderr: '', error });
+            return;
+        }
+
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => { stdout += chunk; });
+        child.stderr.on('data', (chunk) => { stderr += chunk; });
+        const finish = (status, error = null) => {
+            if (settled) return;
+            settled = true;
+            resolve({ status, stdout, stderr, error });
+        };
+        child.once('error', (error) => finish(null, error));
+        child.once('close', (status) => finish(status));
+    });
 }
 
 function secretsDir() {
@@ -296,6 +348,35 @@ function win32Get(account) {
     return out;
 }
 
+async function prewarmSecrets() {
+    try {
+        if (platform() !== 'win32' || KEYCHAIN_CACHE_TTL_MS === 0) return;
+        const dir = secretsDir();
+        const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        const epoch = _cacheEpoch;
+        await Promise.all(entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.dpapi'))
+            .map(async (entry) => {
+                const account = entry.name.slice(0, -'.dpapi'.length);
+                const generation = _cacheGenerations.get(account) || 0;
+                try {
+                    const b64 = (await fs.promises.readFile(path.join(dir, entry.name), 'utf8')).trim();
+                    if (!b64) return;
+                    const r = await powershellAsync(`& { ${PS_UNPROTECT} } '${b64}'`);
+                    const value = (r.stdout || '').trim();
+                    if (r.error || r.status !== 0 || !value) return;
+                    if (_cacheEpoch !== epoch || (_cacheGenerations.get(account) || 0) !== generation) return;
+                    _cacheSet(account, value);
+                } catch {
+                    // Individual corrupt, deleted, or undecryptable entries must
+                    // not prevent the remaining secrets from warming.
+                }
+            }));
+    } catch {
+        // Prewarming is an optional startup optimization and must never fail boot.
+    }
+}
+
 function win32Set(account, value) {
     const dir = secretsDir();
     fs.mkdirSync(dir, { recursive: true });
@@ -367,4 +448,12 @@ function deleteSecret(account) {
     }
 }
 
-module.exports = { getSecret, setSecret, deleteSecret, hasSecret, invalidateSecretCache, SERVICE };
+module.exports = {
+    getSecret,
+    setSecret,
+    deleteSecret,
+    hasSecret,
+    invalidateSecretCache,
+    prewarmSecrets,
+    SERVICE,
+};

package/src/repl.mjs

@@ -185,6 +185,17 @@ export async function runRepl({ provider: providerName, model, toolMode = 'full'
               stdout.write(chunk);
               atLineStart = chunk.endsWith('\n');
             },
+            onTextReset: ({ chars } = {}) => {
+              const count = Math.max(0, Number(chars) || 0);
+              if (!count || !colorEnabled() || printedToolCard) return false;
+              const remaining = streamedText.slice(0, Math.max(0, streamedText.length - count));
+              eraseStreamedBlock(streamedText);
+              streamedText = remaining;
+              if (remaining) stdout.write(remaining);
+              printedAny = !!remaining;
+              atLineStart = !remaining || remaining.endsWith('\n');
+              return true;
+            },
             onUsageDelta: (delta) => applyUsageDelta(stats, delta),
           },
         );

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

@@ -76,6 +76,7 @@ import {
     clampAnthropicThinkingBudget as clampThinkingBudgetTokens,
     deferredAnthropicTools as sharedDeferredAnthropicTools,
     requestAnthropicTools as sharedRequestAnthropicTools,
+    normalizeAnthropicNonStreamingResponse,
     resolveAnthropicCacheTtls as resolveCacheTtls,
     sanitizeAnthropicInputSchema,
     toAnthropicToolChoice,
@@ -562,6 +563,7 @@ export class AnthropicOAuthProvider {
         const onStreamDelta = typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null;
         const onToolCall = typeof opts.onToolCall === 'function' ? opts.onToolCall : null;
         const onTextDelta = typeof opts.onTextDelta === 'function' ? opts.onTextDelta : null;
+        const onTextReset = typeof opts.onTextReset === 'function' ? opts.onTextReset : null;
         const externalSignal = opts.signal || null;
         // Test seam: lets the retry harness drive stream outcomes without a
         // live OAuth session.
@@ -612,7 +614,7 @@ export class AnthropicOAuthProvider {
             try { totalSignal.removeEventListener('abort', handler); } catch {}
         };
 
-        const doRequest = async (accessToken, requestSignal = null) => {
+        const doRequest = async (accessToken, requestSignal = null, requestBody = body) => {
             const controller = createAbortController();
             const fetchStartedAt = Date.now();
 
@@ -665,7 +667,7 @@ export class AnthropicOAuthProvider {
                         'x-app': 'cli',
                         'Content-Type': 'application/json',
                     },
-                    body: JSON.stringify(body),
+                    body: JSON.stringify(requestBody),
                     signal: controller.signal,
                     dispatcher: getLlmDispatcher(),
                 });
@@ -707,8 +709,8 @@ export class AnthropicOAuthProvider {
         // Test seam: injectable request factory for retry-path tests.
         const doRequestImpl = typeof opts._doRequestFn === 'function' ? opts._doRequestFn : doRequest;
 
-        const requestWithRetry = async (accessToken) => withRetry(async ({ signal: attemptSignal }) => {
-            const result = await doRequestImpl(accessToken, attemptSignal);
+        const requestWithRetry = async (accessToken, requestBody = body) => withRetry(async ({ signal: attemptSignal }) => {
+            const result = await doRequestImpl(accessToken, attemptSignal, requestBody);
             const status = Number(result?.response?.status || 0);
             const transientStatus = classifyError({ httpStatus: status }) === 'transient';
             if (transientStatus || status === 429) {
@@ -738,8 +740,14 @@ export class AnthropicOAuthProvider {
             backoffMs: ANTHROPIC_RETRY_BACKOFF_MS,
             retryJitterRatio: ANTHROPIC_RETRY_JITTER_RATIO,
             retryJitterMode: 'positive',
+            // Max/Pro OAuth sessions use subscription quota windows. Claude
+            // Code fails their 429s immediately rather than waiting through
+            // the API-key/PAYG retry budget (which may carry hours-long
+            // Retry-After values).
+            retry429: false,
             perAttemptTimeoutMs: requestTimeoutMs,
             perAttemptLabel: 'Anthropic OAuth initial response',
+            provider: 'anthropic',
             model: useModel,
             fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
             onRetry: ({ attempt, lastErr, delayMs, delayReason }) => {
@@ -760,6 +768,51 @@ export class AnthropicOAuthProvider {
         let firstAttemptError = null;
         let firstAttemptClassifier = null;
 
+        const recoverNonStreaming = async (midState, streamingError, controller) => {
+            const exposedChars = Number(midState?.emittedTextChars) || 0;
+            if (!onTextReset || exposedChars <= 0
+                || midState.emittedToolCall || midState.partialToolCall || midState.emittedThinking) {
+                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
+                throw streamingError;
+            }
+            let resetAccepted = false;
+            try {
+                resetAccepted = await onTextReset({
+                    chars: exposedChars,
+                    reason: 'anthropic-streaming-fallback',
+                }) === true;
+            } catch {}
+            if (!resetAccepted) {
+                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
+                throw streamingError;
+            }
+            try { controller?.abort?.(streamingError); } catch {}
+            try { onStageChange?.('requesting', { transport: 'non-streaming-fallback' }); } catch {}
+            let fallback = await requestWithRetry(creds.accessToken, { ...body, stream: false });
+            if (fallback.response.status === 401) {
+                cleanupCancelHandler(fallback.cancelHandler);
+                try { fallback.controller?.abort?.(); } catch {}
+                creds = await this.ensureAuth({ forceRefresh: true, reason: '401' });
+                fallback = await requestWithRetry(creds.accessToken, { ...body, stream: false });
+            }
+            if (!fallback.response.ok) {
+                const text = await fallback.response.text().catch(() => '');
+                cleanupCancelHandler(fallback.cancelHandler);
+                try { fallback.controller?.abort?.(); } catch {}
+                const fallbackError = new Error(`Anthropic OAuth API ${fallback.response.status}: ${this.scrubTokens(text).slice(0, 200)}`);
+                fallbackError.status = fallback.response.status;
+                fallbackError.httpStatus = fallback.response.status;
+                throw fallbackError;
+            }
+            try {
+                const message = await fallback.response.json();
+                return normalizeAnthropicNonStreamingResponse(message, useModel);
+            } finally {
+                cleanupCancelHandler(fallback.cancelHandler);
+                try { fallback.controller?.abort?.('Anthropic non-streaming fallback complete'); } catch {}
+            }
+        };
+
         try {
         for (let attemptIndex = 0; attemptIndex <= MAX_MIDSTREAM_RETRIES; attemptIndex++) {
             let response, controller, cancelHandler;
@@ -919,28 +972,12 @@ export class AnthropicOAuthProvider {
                 } catch { /* ignore non-extensible result */ }
                 return result;
             } catch (err) {
-                // Live-text invariant: once a non-empty text chunk has been
-                // relayed to the client (gateway live mode), the rendered output
-                // cannot be withdrawn and re-issuing would concatenate a second
-                // attempt. Surface the failure immediately — never retry — and
-                // tag the error so upstream layers refuse to retry as well.
+                // Acknowledged reset semantics let the owner tombstone this
+                // attempt before the full request is restarted non-streaming.
+                // Without that acknowledgement, recoverNonStreaming stamps
+                // the error unsafe and preserves the no-concatenation rule.
                 if (midState.emittedText) {
-                    try { err.liveTextEmitted = true; err.unsafeToRetry = true; } catch {}
-                    try { controller?.abort?.(err); } catch { /* best-effort teardown */ }
-                    if (attemptIndex > 0 && firstAttemptError) {
-                        try { firstAttemptError.midstreamRetries = attemptIndex; } catch {}
-                        try { firstAttemptError.midstreamClassifier = firstAttemptClassifier; } catch {}
-                        // firstAttemptError is what actually propagates here when
-                        // live text was emitted this attempt — stamp the unsafe
-                        // flags onto IT too, else upstream sees an unmarked error
-                        // and retries, duplicating already-streamed output.
-                        try {
-                            firstAttemptError.liveTextEmitted = true;
-                            firstAttemptError.unsafeToRetry = true;
-                        } catch {}
-                        throw err;
-                    }
-                    throw err;
+                    return await recoverNonStreaming(midState, err, controller);
                 }
                 // Completed/partial tools and thinking blocks are also replay
                 // boundaries. Stamp the current (latest) error so no upstream

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

@@ -174,7 +174,10 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
             content += emit;
             try { onStreamDelta?.('text'); } catch {}
             if (onTextDelta) {
-                if (state) state.emittedText = true;
+                if (state) {
+                    state.emittedText = true;
+                    state.emittedTextChars = (Number(state.emittedTextChars) || 0) + emit.length;
+                }
                 try { onTextDelta(emit); } catch {}
             }
         }
@@ -458,7 +461,10 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
                             } else {
                                 content += delta.text || '';
                                 if (delta.text && onTextDelta) {
-                                    if (state) state.emittedText = true;
+                                    if (state) {
+                                        state.emittedText = true;
+                                        state.emittedTextChars = (Number(state.emittedTextChars) || 0) + delta.text.length;
+                                    }
                                     try { onTextDelta(delta.text); } catch {}
                                 }
                                 if (delta.text) {

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

@@ -45,6 +45,7 @@ import {
     clampAnthropicThinkingBudget as clampThinkingBudgetTokens,
     deferredAnthropicTools as sharedDeferredAnthropicTools,
     requestAnthropicTools as sharedRequestAnthropicTools,
+    normalizeAnthropicNonStreamingResponse,
     resolveAnthropicCacheTtls as resolveCacheTtls,
     sanitizeAnthropicInputSchema,
     toAnthropicToolChoice,
@@ -489,6 +490,7 @@ export class AnthropicProvider {
         const onStreamDelta = typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null;
         const onToolCall = typeof opts.onToolCall === 'function' ? opts.onToolCall : null;
         const onTextDelta = typeof opts.onTextDelta === 'function' ? opts.onTextDelta : null;
+        const onTextReset = typeof opts.onTextReset === 'function' ? opts.onTextReset : null;
 
         // No absolute wall-clock cap on streaming generation: a stream still
         // emitting SSE deltas must not be killed by a fixed total-lifetime timer.
@@ -579,6 +581,48 @@ export class AnthropicProvider {
             };
         };
 
+        const recoverNonStreaming = async (midState, streamingError, streamController) => {
+            const exposedChars = Number(midState?.emittedTextChars) || 0;
+            if (!onTextReset || exposedChars <= 0
+                || midState.emittedToolCall || midState.partialToolCall || midState.emittedThinking) {
+                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
+                throw streamingError;
+            }
+            let resetAccepted = false;
+            try {
+                resetAccepted = await onTextReset({
+                    chars: exposedChars,
+                    reason: 'anthropic-streaming-fallback',
+                }) === true;
+            } catch {}
+            if (!resetAccepted) {
+                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
+                throw streamingError;
+            }
+            try { streamController.abort?.(streamingError); } catch {}
+            try { onStageChange?.('requesting', { transport: 'non-streaming-fallback' }); } catch {}
+            const nonStreamingParams = { ...params, stream: false };
+            const message = await withRetry(
+                async ({ signal: attemptSignal }) => this.client.messages.create(nonStreamingParams, {
+                    signal: attemptSignal,
+                    ...(betaHeaders ? { headers: betaHeaders } : {}),
+                }),
+                {
+                    signal: totalSignal,
+                    maxAttempts: anthropicMaxAttempts(),
+                    backoffMs: ANTHROPIC_RETRY_BACKOFF_MS,
+                    retryJitterRatio: ANTHROPIC_RETRY_JITTER_RATIO,
+                    retryJitterMode: 'positive',
+                    perAttemptTimeoutMs: anthropicRequestTimeoutMs(),
+                    perAttemptLabel: `${this.name} Anthropic non-streaming fallback`,
+                    provider: 'anthropic',
+                    model: useModel,
+                    fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
+                },
+            );
+            return buildReturnFromParse(normalizeAnthropicNonStreamingResponse(message, useModel));
+        };
+
         try {
             for (let attemptIndex = 0; attemptIndex <= MAX_MIDSTREAM_RETRIES; attemptIndex++) {
                 const streamController = createAbortController();
@@ -662,6 +706,7 @@ export class AnthropicProvider {
                             retryJitterMode: 'positive',
                             perAttemptTimeoutMs: anthropicRequestTimeoutMs(),
                             perAttemptLabel: `${this.name} Anthropic streaming response`,
+                            provider: 'anthropic',
                             model: useModel,
                             fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
                             onRetry: ({ attempt, lastErr, delayMs, delayReason }) => {
@@ -740,30 +785,12 @@ export class AnthropicProvider {
                             _fallbackTriggered: true,
                         });
                     }
-                    // Live-text invariant: once a non-empty text chunk has been
-                    // relayed to the client (gateway live mode), the rendered
-                    // output cannot be withdrawn and re-issuing would concatenate
-                    // a second attempt. Surface immediately — never retry — and
-                    // tag the error so upstream layers refuse to retry as well.
+                    // Acknowledged reset semantics let the owner tombstone this
+                    // attempt before the full request is restarted non-streaming.
+                    // Without that acknowledgement, recoverNonStreaming stamps
+                    // the error unsafe and preserves the no-concatenation rule.
                     if (midState.emittedText) {
-                        try { err.liveTextEmitted = true; err.unsafeToRetry = true; } catch {}
-                        try { streamController.abort?.(err); } catch {}
-                        if (attemptIndex > 0 && firstAttemptError) {
-                            try { firstAttemptError.midstreamRetries = attemptIndex; } catch {}
-                            try { firstAttemptError.midstreamClassifier = firstAttemptClassifier; } catch {}
-                            // firstAttemptError (from an earlier retried attempt)
-                            // is what actually propagates when live text was
-                            // emitted this attempt — stamp the unsafe/partial
-                            // flags onto IT too, otherwise upstream sees an
-                            // unmarked error and retries, duplicating streamed
-                            // output.
-                            try {
-                                firstAttemptError.liveTextEmitted = true;
-                                firstAttemptError.unsafeToRetry = true;
-                            } catch {}
-                            throw err;
-                        }
-                        throw err;
+                        return await recoverNonStreaming(midState, err, streamController);
                     }
                     if (midState.emittedToolCall || midState.partialToolCall || midState.emittedThinking) {
                         try {

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

@@ -100,10 +100,10 @@ export function _geminiCachePrefixHash({ model, systemInstruction, geminiTools,
     }));
 }
 
-// The provider's default explicit-cache TTL is five minutes. A six-minute
-// global-cache floor made every freshly-created default cache ineligible for
-// cross-session reuse. Ten seconds matches the per-session minimum headroom.
-export const GEMINI_GLOBAL_CACHE_MIN_LIVE_MS = 10 * 1000;
+// Keep enough headroom for the provider's 60s first-byte window plus setup
+// overhead. This matches the default five-minute cache's per-session 25%
+// reuse threshold, so a cross-session hit cannot expire while opening.
+export const GEMINI_GLOBAL_CACHE_MIN_LIVE_MS = 75 * 1000;
 export const GEMINI_GLOBAL_CACHE_MAX_ENTRIES = 128;
 // Grace window before deleting a superseded cachedContents name (see the
 // cross-session race note at the delete call site in gemini.mjs). Long enough
@@ -136,6 +136,17 @@ export function _invalidateGeminiCachesForCredentialFingerprint(credentialFinger
     return removed;
 }
 
+export function _invalidateGeminiCacheName(cacheName) {
+    if (!cacheName) return 0;
+    let removed = 0;
+    for (const [key, entry] of geminiGlobalCaches) {
+        if (entry?.cacheName !== cacheName) continue;
+        geminiGlobalCaches.delete(key);
+        removed += 1;
+    }
+    return removed;
+}
+
 export function _pruneGeminiGlobalCaches(now = Date.now()) {
     for (const [key, entry] of geminiGlobalCaches) {
         if (!entry?.cacheName || Number(entry.cacheExpiresAt || 0) <= now) {