mixdog 0.9.52 → 0.9.54

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

@@ -28,6 +28,7 @@ export const LEGACY_EFFORT_BUDGET = Object.freeze({
 });
 const _LOGGED_EFFORT_NORMALIZATION = new Set();
 const _LOGGED_UNKNOWN_EFFORT = new Set();
+const MAX_LOGGED_UNKNOWN_EFFORTS = 100;
 
 function normalizeModelId(model) {
     return String(model || '').toLowerCase().replace(/\./g, '-');
@@ -223,8 +224,12 @@ export function applyAnthropicEffortToBody(
         return;
     }
 
-    if (opts.effort && normalized === undefined && !_LOGGED_UNKNOWN_EFFORT.has(opts.effort)) {
-        _LOGGED_UNKNOWN_EFFORT.add(opts.effort);
+    const unknownEffort = String(opts.effort ?? '');
+    if (opts.effort && normalized === undefined && !_LOGGED_UNKNOWN_EFFORT.has(unknownEffort)) {
+        if (_LOGGED_UNKNOWN_EFFORT.size >= MAX_LOGGED_UNKNOWN_EFFORTS) {
+            _LOGGED_UNKNOWN_EFFORT.delete(_LOGGED_UNKNOWN_EFFORT.values().next().value);
+        }
+        _LOGGED_UNKNOWN_EFFORT.add(unknownEffort);
         try {
             process.stderr.write(
                 `[${logTag}] unknown effort=${opts.effort} ignored (known legacy: ${Object.keys(LEGACY_EFFORT_BUDGET).join(', ')})\n`,

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

@@ -25,7 +25,6 @@ import {
     ensureLatestAnthropicModel,
 } from './anthropic-model-resolve.mjs';
 import { sanitizeToolPairs, sanitizeAnthropicContentPairs, foldUserTextIntoToolResultTail } from '../session/context-utils.mjs';
-import { providerNativeToolPrefixCount } from '../../../../session-runtime/provider-request-tools.mjs';
 import {
     TOKEN_REFRESH_SKEW_MS,
     isAnthropicOAuthRefreshDisabled,
@@ -70,8 +69,19 @@ import {
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { normalizeContentForAnthropic } from './media-normalization.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,
+    normalizeAnthropicNonStreamingResponse,
+    resolveAnthropicCacheTtls as resolveCacheTtls,
+    sanitizeAnthropicInputSchema,
+    toAnthropicToolChoice,
+} from './lib/anthropic-request-utils.mjs';
 
-// --- Model catalog cache helpers: extracted to anthropic-model-resolve.mjs ---
 // SSE progress emits (per-request "Response …" and "Done:" lines). Off by default.
 const SSE_VERBOSE = process.env.MIXDOG_SSE_VERBOSE === '1';
 
@@ -202,113 +212,12 @@ function resolveMaxTokens(model) {
     return resolveAnthropicMaxTokens(model, { catalogLookup: _catalogOutputTokens });
 }
 
-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));
-}
-
-// Layered cache TTLs — stable layers get 1h, volatile layers get 5m.
-// Anthropic requires 1h entries to appear before 5m entries in the request.
-const CACHE_TTL_STABLE = { type: 'ephemeral', ttl: '1h' };   // tools, system, tier3, messages
-const CACHE_TTL_VOLATILE = { type: 'ephemeral' };             // explicit 5m override
-
 // --- Message conversion ---
 
-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;
-}
-
 // Anthropic's tool spec forbids oneOf / allOf / anyOf at the TOP level of
 // input_schema (nested usage inside properties is allowed). External MCP
 // servers sometimes emit such schemas.
 // Convert them to a flat object schema so the API never sees a 400.
-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);
-    // Merge all branch properties into one permissive object schema.
-    // None of the branches' required lists are hoisted — callers that relied
-    // on discriminated-union semantics will still function; the model simply
-    // receives a union of the property surface with no hard-required constraint.
-    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-oauth-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
@@ -321,59 +230,11 @@ function nativeAnthropicTools(opts) {
 // effort/thinking active on reasoning models — activating it would convert a
 // previously-harmless no-op into a hard 400 on exactly that turn. Attached
 // only when the request actually carries tools (see buildRequestBody).
-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 [];
-    // A request whose ONLY tools are deferred is rejected by the API with
-    // `400: At least one tool must have defer_loading=false` — happens on the
-    // iteration-cap final turn (loop sends tools: [] to force a text answer).
-    // No active tools ⇒ send no deferred catalog either.
-    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-oauth');
-    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-oauth');
 }
 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-oauth');
 }
 
 function toAnthropicMessages(messages) {
@@ -475,154 +336,8 @@ function toAnthropicMessages(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 = () => {
-        // Prefer the user text turn before the current tail. In a normal
-        // user->assistant->tool loop this is the last prompt that was already
-        // present in the previous API request, so its prefix can overlap.
-        const tailIdx = sanitizedMessages.length - 1;
-        for (let i = tailIdx - 1; i >= 0; i--) {
-            if (hasUserText(sanitizedMessages[i])) return i;
-        }
-        return -1;
-    };
-    const latestToolResultTailIdx = () => {
-        // Claude/pi refs allow cache_control on tool_result blocks. Keep this
-        // narrower than "last message" so a fresh user prompt or steering text
-        // never becomes a 1h breakpoint.
-        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;
-}
-
-// --- SSE parser + midstream retry policy: extracted to anthropic-sse.mjs ---
-
 // --- Build request body ---
 
-function resolveCacheTtls(opts) {
-    // Layered cache strategy — caller may override per-layer via opts.cacheStrategy.
-    // Anthropic enforces: 1h entries must appear before 5m entries in the request.
-    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;
-    };
-    // BP budget (4 total):
-    //   BP1 baseRules    — 1h (shared tool policy + compact skill manifest)
-    //   BP2 stableSystem — 1h (role/system rules)
-    //   BP3 tier3        — 1h (sessionMarker: stable memory/meta body)
-    //   BP4 messages     — 1h sliding tail (tool_result cache across iter)
-    // tools BP is dropped — system BP covers the tools prefix via
-    // Anthropic's prompt cache prefix semantics (order: tools → system
-    // → messages).
-    // tier3 defaults to 1h (stable) — sessionMarker content is stable per
-    // memory/meta tuple and the BP slot is only spent when a 3rd
-    // (cacheTier:'tier3') system block is actually present, so this default is
-    // free for sessions that don't carry one. Previously null here meant any
-    // caller that skipped agent runtime resolve (CLI, raw agent spawn)
-    // silently lost the tier3 cache layer even though it supported one.
-    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.
-    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;
-}
-
 // BP3 (tier3) is injected by session/manager as 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. No
@@ -848,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.
@@ -898,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();
 
@@ -951,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(),
                 });
@@ -993,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) {
@@ -1024,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 }) => {
@@ -1046,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;
@@ -1205,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
@@ -1444,5 +1195,5 @@ export const _test = {
     resolveMaxTokens,
     deferredAnthropicTools,
     requestAnthropicTools,
-    sanitizeInputSchema: _sanitizeInputSchema,
+    sanitizeInputSchema: (schema, toolName) => sanitizeAnthropicInputSchema(schema, toolName, 'anthropic-oauth'),
 };

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

@@ -1,10 +1,8 @@
 /**
  * anthropic-sse.mjs — Anthropic SSE stream parser + mid-stream retry policy.
  *
- * Extracted from anthropic-oauth.mjs. Shared by BOTH Anthropic providers:
- * anthropic-oauth.mjs (OAuth) and anthropic.mjs (API key) import
- * parseSSEStream / _classifyMidstreamError / ANTHROPIC_MAX_MIDSTREAM_RETRIES
- * from here (via the anthropic-oauth.mjs re-export for legacy paths).
+ * Shared by both Anthropic providers. anthropic-oauth.mjs retains its public
+ * re-exports for provider test and integration entry points.
  */
 import { randomBytes } from 'crypto';
 import {
@@ -176,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 {}
             }
         }
@@ -460,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) {