mixdog 0.9.53 → 0.9.54

package/scripts/provider-contract-test.mjs

@@ -12,7 +12,12 @@ import {
     applyCompatProviderChatOptions,
     parseToolCalls,
 } from '../src/runtime/agent/orchestrator/providers/openai-compat.mjs';
-import { consumeCompatChatCompletionStream } from '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs';
+import {
+    consumeCompatChatCompletionStream,
+    consumeCompatResponsesStream,
+} from '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs';
+import { useXaiResponsesWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-compat-xai.mjs';
+import { classifyError } from '../src/runtime/agent/orchestrator/providers/retry-classifier.mjs';
 import { GrokOAuthProvider } from '../src/runtime/agent/orchestrator/providers/grok-oauth.mjs';
 import { sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
 import {
@@ -341,13 +346,18 @@ test('Grok OAuth end-to-end HTTP Responses path is hermetic through inner compat
         },
         responsesTransport: 'http',
     });
-    provider.ensureAuth = async () => ({ access_token: 'fixture-token' });
-    const inner = provider._ensureInner('fixture-token', 'grok-4.5');
-    assert.equal(inner.config.preconnect, false, 'Grok seam must propagate to inner compat');
-    assert.equal(typeof inner.config.preconnectFn, 'function');
-    inner.client = {
-        responses: {
-            create: async () => stream([
+    provider.ensureAuth = async () => ({ access_token: 'fixture-token', user_id: 'fixture-user' });
+    const ensureInner = provider._ensureInner.bind(provider);
+    let capturedInner = null;
+    let capturedParams = null;
+    provider._ensureInner = (...args) => {
+        const inner = ensureInner(...args);
+        capturedInner = inner;
+        inner.client = {
+            responses: {
+                create: async (params) => {
+                    capturedParams = params;
+                    return stream([
                 { type: 'response.created', response: { id: 'resp_fixture', model: 'grok-4.5' } },
                 { type: 'response.output_text.delta', delta: 'hermetic' },
                 {
@@ -360,20 +370,66 @@ test('Grok OAuth end-to-end HTTP Responses path is hermetic through inner compat
                         usage: { input_tokens: 3, output_tokens: 1 },
                     },
                 },
-            ]),
-        },
+                    ]);
+                },
+            },
+        };
+        return inner;
     };
 
     const result = await provider.send(
         [{ role: 'user', content: 'fixture' }],
         'grok-4.5',
         [],
-        { sessionId: 'hermetic-grok-contract' },
+        { sessionId: 'hermetic-grok-contract', iteration: 2 },
     );
     assert.equal(result.content, 'hermetic');
     assert.equal(result.usage.inputTokens, 3);
+    assert.equal(capturedInner.config.preconnect, false, 'Grok seam must propagate to inner compat');
+    assert.equal(typeof capturedInner.config.preconnectFn, 'function');
+    assert.equal(capturedInner.baseURL, 'https://cli-chat-proxy.grok.com/v1');
+    assert.equal(capturedInner.config.responsesTransport, 'http');
+    assert.equal(capturedInner.defaultHeaders['x-grok-conv-id'], undefined);
+    assert.equal(capturedInner.defaultHeaders['x-grok-session-id'], 'hermetic-grok-contract');
+    assert.match(capturedInner.defaultHeaders['x-grok-req-id'], /^[0-9a-f-]{36}$/);
+    assert.equal(capturedInner.defaultHeaders['x-grok-model-override'], 'grok-4.5');
+    assert.equal(capturedInner.defaultHeaders['x-grok-turn-idx'], '2');
+    assert.equal(capturedInner.defaultHeaders['x-grok-user-id'], 'fixture-user');
+    assert.equal(capturedParams.store, false);
+    assert.deepEqual(capturedParams.include, ['reasoning.encrypted_content']);
+    assert.equal(result.providerState.xaiResponses.store, false);
+    assert.equal(result.providerState.xaiResponses.previousResponseId, null);
+});
+
+test('xAI Responses defaults to HTTP and keeps WebSocket behind explicit opt-in', () => {
+    assert.equal(useXaiResponsesWebSocket({}, {}), false);
+    assert.equal(useXaiResponsesWebSocket({}, { responsesTransport: 'http' }), false);
+    assert.equal(useXaiResponsesWebSocket({}, { responsesTransport: 'websocket' }), true);
 });
 
+for (const event of [
+    { type: 'response.failed', response: { error: { message: 'forbidden' } } },
+    { type: 'error', message: 'forbidden' },
+]) {
+    test(`xAI ${event.type} stream event is retryable 500-equivalent without changing other compat labels`, async () => {
+        const xaiError = await consumeCompatResponsesStream(stream([event]), {
+            label: 'xai:responses',
+            parseResponsesToolCalls: () => [],
+            responseOutputText: () => '',
+        }).then(() => null, (err) => err);
+        assert.equal(xaiError.httpStatus, 500);
+        assert.equal(classifyError(xaiError), 'transient');
+
+        const otherError = await consumeCompatResponsesStream(stream([event]), {
+            label: 'other-compat',
+            parseResponsesToolCalls: () => [],
+            responseOutputText: () => '',
+        }).then(() => null, (err) => err);
+        assert.equal(otherError.httpStatus, 403);
+        assert.equal(classifyError(otherError), 'auth');
+    });
+}
+
 test('Grok OAuth does not refresh/replay a 401 after visible tool dispatch', async () => {
     const provider = Object.create(GrokOAuthProvider.prototype);
     provider.config = { preconnect: false };
@@ -500,26 +556,28 @@ test('xAI safe 401 replay carries completed warmup into the retry', async () =>
     assert.equal(attempts, 2);
 });
 
-test('Grok OAuth safe 401 replay carries completed warmup to refreshed xAI inner', async () => {
-    const provider = Object.create(GrokOAuthProvider.prototype);
-    provider.config = { preconnect: false };
-    const warmup = { usage: { inputTokens: 10 } };
-    let authCalls = 0;
-    provider.ensureAuth = async ({ forceRefresh = false } = {}) => {
-        authCalls += 1;
-        return { access_token: forceRefresh ? 'fresh' : 'stale' };
-    };
-    provider._ensureInner = (token) => ({
-        _doSend: async (_messages, _model, _tools, opts) => {
-            if (token === 'stale') {
-                const err = Object.assign(new Error('401'), { httpStatus: 401 });
-                Object.defineProperty(err, '__warmup', { value: warmup });
-                throw err;
-            }
-            assert.equal(opts._carriedWarmup, warmup);
-            return { content: 'retried' };
-        },
+for (const status of [401, 403]) {
+    test(`Grok OAuth safe ${status} replay carries completed warmup to refreshed xAI inner`, async () => {
+        const provider = Object.create(GrokOAuthProvider.prototype);
+        provider.config = { preconnect: false };
+        const warmup = { usage: { inputTokens: 10 } };
+        let authCalls = 0;
+        provider.ensureAuth = async ({ forceRefresh = false } = {}) => {
+            authCalls += 1;
+            return { access_token: forceRefresh ? 'fresh' : 'stale' };
+        };
+        provider._ensureInner = (token) => ({
+            _doSend: async (_messages, _model, _tools, opts) => {
+                if (token === 'stale') {
+                    const err = Object.assign(new Error(String(status)), { httpStatus: status });
+                    Object.defineProperty(err, '__warmup', { value: warmup });
+                    throw err;
+                }
+                assert.equal(opts._carriedWarmup, warmup);
+                return { content: 'retried' };
+            },
+        });
+        assert.equal((await provider.send([], 'grok-4.5', [], {})).content, 'retried');
+        assert.equal(authCalls, 2);
     });
-    assert.equal((await provider.send([], 'grok-4.5', [], {})).content, 'retried');
-    assert.equal(authCalls, 2);
-});
+}

package/scripts/provider-toolcall-test.mjs

@@ -833,6 +833,89 @@ test('openai-compat/xai Responses: load_tool history replays as function_call',
     assert.equal(input.some((item) => item.type === 'function_call_output' && item.call_id === 'call_load_1'), true);
 });
 
+test('openai-compat/xai store=false continuation replays the full conversation with encrypted reasoning', () => {
+    const encrypted = {
+        type: 'reasoning',
+        id: 'reasoning_1',
+        encrypted_content: 'opaque-ciphertext',
+        summary: [],
+    };
+    const { input, previousResponseId, startIndex } = _toXaiResponsesInputForTest([
+        { role: 'user', content: 'call read' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'call_1', name: 'read', arguments: { path: 'a' } }],
+        },
+        { role: 'tool', toolCallId: 'call_1', content: 'contents' },
+    ], {
+        xaiResponses: {
+            previousResponseId: null,
+            responseId: 'resp_unstored',
+            store: false,
+            encryptedReasoningItems: [encrypted],
+            seenMessageCount: 1,
+            model: 'grok-4.5',
+        },
+    }, { model: 'grok-4.5' });
+    assert.equal(previousResponseId, null);
+    assert.equal(startIndex, 0);
+    assert.equal(input[0].role, 'user');
+    assert.deepEqual(input[1], encrypted);
+    assert.equal(input[2].call_id, 'call_1');
+    assert.equal(input[3].call_id, 'call_1');
+});
+
+test('openai-compat/xai store=false second tool round retains original system/user and both tool results', () => {
+    const firstReasoning = {
+        type: 'reasoning',
+        id: 'reasoning_1',
+        encrypted_content: 'opaque-first',
+        summary: [],
+    };
+    const secondReasoning = {
+        type: 'reasoning',
+        id: 'reasoning_2',
+        encrypted_content: 'opaque-second',
+        summary: [],
+    };
+    const { input, previousResponseId, startIndex } = _toXaiResponsesInputForTest([
+        { role: 'system', content: 'original system' },
+        { role: 'user', content: 'original user request' },
+        { role: 'assistant', content: '', toolCalls: [{ id: 'call_1', name: 'read', arguments: { path: 'a' } }] },
+        { role: 'tool', toolCallId: 'call_1', content: 'first tool result' },
+        { role: 'assistant', content: '', toolCalls: [{ id: 'call_2', name: 'grep', arguments: { pattern: 'x' } }] },
+        { role: 'tool', toolCallId: 'call_2', content: 'second tool result' },
+    ], {
+        xaiResponses: {
+            previousResponseId: null,
+            responseId: 'resp_unstored_2',
+            store: false,
+            encryptedReasoningHistory: [
+                { messageIndex: 2, items: [firstReasoning] },
+                { messageIndex: 4, items: [secondReasoning] },
+            ],
+            seenMessageCount: 4,
+            model: 'grok-4.5',
+        },
+    }, { model: 'grok-4.5' });
+    assert.equal(previousResponseId, null);
+    assert.equal(startIndex, 0);
+    assert.equal(input[0].role, 'system');
+    assert.equal(input[0].content[0].text, 'original system');
+    assert.equal(input[1].role, 'user');
+    assert.equal(input[1].content[0].text, 'original user request');
+    assert.deepEqual(input.filter((item) => item.type === 'reasoning'), [firstReasoning, secondReasoning]);
+    assert.deepEqual(
+        input.filter((item) => item.type === 'function_call').map((item) => item.call_id),
+        ['call_1', 'call_2'],
+    );
+    assert.deepEqual(
+        input.filter((item) => item.type === 'function_call_output').map((item) => item.output),
+        ['first tool result', 'second tool result'],
+    );
+});
+
 test('openai-compat/xai Responses: model switch drops prior tool transcript history', () => {
     const { input, previousResponseId, continuationResetReason } = _toXaiResponsesInputForTest([
         { role: 'system', content: 'sys' },
@@ -2869,7 +2952,7 @@ test('openai-compat/xai: HTTP pin uses only the injected preconnect seam', async
     }
 });
 
-test('grok-oauth: all Grok models inherit global transport; explicit setting is the escape hatch', () => {
+test('grok-oauth: every OAuth model is pinned to the CLI proxy over HTTP/SSE', () => {
     const prevOaiTransport = process.env.MIXDOG_OAI_TRANSPORT;
     const prevResponsesTransport = process.env.MIXDOG_GROK_OAUTH_RESPONSES_TRANSPORT;
     const prevGrokTransport = process.env.MIXDOG_GROK_OAUTH_TRANSPORT;
@@ -2879,22 +2962,19 @@ test('grok-oauth: all Grok models inherit global transport; explicit setting is
         delete process.env.MIXDOG_GROK_OAUTH_TRANSPORT;
         const provider = new GrokOAuthProvider({});
 
-        const apiInner = provider._ensureInner('tok', 'grok-build-0.1');
-        assert.equal(apiInner.config.responsesTransport, undefined);
-
-        // No Grok-specific override: proxy-only grok-build now inherits the
-        // shared switch too (WS→api.x.ai), no implicit HTTP pin.
-        const proxyInner = provider._ensureInner('tok', 'grok-build');
-        assert.equal(proxyInner.config.responsesTransport, undefined);
-
-        // Escape hatch: an explicit Grok-specific http setting pins proxy-only
-        // models back onto the Grok CLI proxy over HTTP.
-        process.env.MIXDOG_GROK_OAUTH_RESPONSES_TRANSPORT = 'http';
-        const pinnedProvider = new GrokOAuthProvider({});
-        const pinnedProxy = pinnedProvider._ensureInner('tok', 'grok-build');
-        assert.equal(pinnedProxy.config.responsesTransport, 'http');
-        const pinnedApi = pinnedProvider._ensureInner('tok2', 'grok-build-0.1');
-        assert.equal(pinnedApi.config.responsesTransport, 'http');
+        for (const model of ['grok-build-0.1', 'grok-build', 'grok-4.5']) {
+            const inner = provider._ensureInner(`tok-${model}`, model);
+            assert.equal(inner.config.responsesTransport, 'http');
+            assert.equal(inner.baseURL, 'https://cli-chat-proxy.grok.com/v1');
+        }
+
+        // OAuth routing is a security boundary: even explicit WS settings
+        // cannot send the session bearer to the fixed api.x.ai WS endpoint.
+        process.env.MIXDOG_GROK_OAUTH_RESPONSES_TRANSPORT = 'websocket';
+        const pinnedProvider = new GrokOAuthProvider({ responsesTransport: 'websocket' });
+        const pinned = pinnedProvider._ensureInner('tok-explicit', 'grok-4.5');
+        assert.equal(pinned.config.responsesTransport, 'http');
+        assert.equal(pinned.baseURL, 'https://cli-chat-proxy.grok.com/v1');
     } finally {
         if (prevOaiTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
         else process.env.MIXDOG_OAI_TRANSPORT = prevOaiTransport;

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) {