mixdog 1.3.5 → 1.4.1

package/src/runtime/agent/orchestrator/providers/anthropic-cache-warm.mjs

@@ -0,0 +1,165 @@
+// anthropic-cache-warm.mjs — the cache-warm mode both Anthropic providers
+// expose as `sendCacheWarm` (session/cache-warm.mjs): one POST of the
+// request the provider's own builder produces, no retry, fallback, re-send,
+// wait or account rotation, and the stream cut at the first content block
+// once the usage (cache read / write) has been reported. Right before the
+// POST the account gate (cache-warm-admission.mjs) may skip it; a refusal is
+// fed into the shared rate-limit and roster state. The request is bounded by
+// the providers' own watchdogs: the first-byte timeout until the usage
+// arrives, then the SSE idle timeout between events. Usage is handed to
+// `onUsage` as it arrives, so a warm that fails or is aborted after the
+// provider accepted it is still accounted. Every exit cancels the stream and
+// aborts the transport.
+import { PROVIDER_FIRST_BYTE_TIMEOUT_MS, PROVIDER_SSE_IDLE_TIMEOUT_MS } from '../stall-policy.mjs';
+import { updateTurnUsage } from './anthropic-sse-turn/turn-state.mjs';
+import { _anthropicSseError } from './anthropic-sse.mjs';
+import { anthropicQuotaError } from './anthropic-oauth-request/initial-status.mjs';
+import { cacheWarmAccountBlock, cacheWarmBlockedError, recordCacheWarmRefusal } from './cache-warm-admission.mjs';
+import { scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
+
+const SSE_LABELS = Object.freeze({ display: 'Anthropic cache warm' });
+
+function usageSnapshot(usage) {
+  const { raw: _raw, ...rest } = usage;
+  return { ...rest };
+}
+
+// An abort deadline: `arm(ms)` (re)starts it; it fires `controller.abort`.
+function watchdog(controller) {
+  let timer = null;
+  return {
+    arm(ms, what) {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => controller.abort(new Error(`cache warm ${what} timed out after ${ms}ms`)), ms);
+      timer.unref?.();
+    },
+    clear() {
+      if (timer) clearTimeout(timer);
+      timer = null;
+    },
+  };
+}
+
+/**
+ * Read a warm's SSE stream until usage is known and the first content block
+ * starts, or the message ends. Resolves the usage; a stream error rejects
+ * with `error.usage` set to what was reported before it. `onChunk` hears
+ * every chunk (the idle watchdog). The stream is cancelled on every exit.
+ */
+export async function readCacheWarmStream(response, { onUsage = () => {}, onChunk = () => {} } = {}) {
+  const usage = { inputTokens: 0, outputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, raw: null };
+  let reported = false;
+  const report = (raw) => {
+    if (!raw || typeof raw !== 'object') return;
+    updateTurnUsage(usage, raw);
+    reported = true;
+    onUsage(usageSnapshot(usage));
+  };
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  try {
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let cut = buffer.indexOf('\n\n');
+      while (cut >= 0) {
+        const frame = buffer.slice(0, cut);
+        buffer = buffer.slice(cut + 2);
+        cut = buffer.indexOf('\n\n');
+        const data = frame
+          .split('\n')
+          .filter((line) => line.startsWith('data:'))
+          .map((line) => line.slice(5).trimStart())
+          .join('\n');
+        if (!data) continue;
+        let event;
+        try {
+          event = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        if (event?.type === 'error' || event?.error) throw _anthropicSseError(event, SSE_LABELS);
+        if (event.type === 'message_start') report(event.message?.usage);
+        else if (event.type === 'message_delta') report(event.usage);
+        else if (event.type === 'content_block_start' && reported) {
+          // The prefix was read (and the cache refreshed) before any content:
+          // nothing generated after this point is needed.
+          return usageSnapshot(usage);
+        } else if (event.type === 'message_stop') return usageSnapshot(usage);
+      }
+      onChunk(reported);
+    }
+  } catch (error) {
+    if (error && typeof error === 'object' && error.usage === undefined) {
+      error.usage = reported ? usageSnapshot(usage) : null;
+    }
+    throw error;
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+  return usageSnapshot(usage);
+}
+
+/**
+ * One warm on account instance `instance` (roster account `accountId`, empty
+ * for a provider without a roster) of `providerName`: the account gate, then
+ * `post(signal)` (the provider's single POST of its built body), then the
+ * stream. A refusal reaches the shared rate-limit and roster state; the
+ * transport is aborted on every exit.
+ */
+export async function sendAnthropicCacheWarm({
+  providerName,
+  instance,
+  accountId = '',
+  model,
+  opts = {},
+  post,
+  onUsage,
+}) {
+  const blocked = cacheWarmAccountBlock(providerName, instance, {
+    accountId,
+    model,
+    sessionId: opts.session?.id || opts.sessionId || '',
+  });
+  if (blocked) throw cacheWarmBlockedError(blocked);
+  const controller = new AbortController();
+  const callerSignal = opts.signal;
+  const onCallerAbort = () => controller.abort(callerSignal.reason);
+  if (callerSignal?.aborted) controller.abort(callerSignal.reason);
+  else callerSignal?.addEventListener?.('abort', onCallerAbort, { once: true });
+  const deadline = watchdog(controller);
+  deadline.arm(PROVIDER_FIRST_BYTE_TIMEOUT_MS, 'first byte');
+  try {
+    const response = await post(controller.signal);
+    if (!response.ok) {
+      const bodyText = await response.text().catch(() => '');
+      throw anthropicQuotaError(response.status, response.headers, bodyText);
+    }
+    return await readCacheWarmStream(response, {
+      onUsage,
+      onChunk: (reported) => {
+        if (reported) deadline.arm(PROVIDER_SSE_IDLE_TIMEOUT_MS, 'stream');
+      },
+    });
+  } catch (error) {
+    // The warm's own error is what the caller needs; a failure to persist the
+    // refusal (quota / roster state) is reported, scrubbed, like the other
+    // credential and account-state write failures of the Anthropic providers.
+    await recordCacheWarmRefusal(providerName, instance, error, {
+      accountId,
+      model,
+      aborted: Boolean(callerSignal?.aborted),
+    }).catch((recordError) => {
+      process.stderr.write(
+        `[anthropic-cache-warm] refusal record failed: ${scrubOAuthSecrets(recordError?.message || String(recordError))}\n`
+      );
+    });
+    throw error;
+  } finally {
+    callerSignal?.removeEventListener?.('abort', onCallerAbort);
+    deadline.clear();
+    controller.abort(new Error('cache warm finished'));
+  }
+}

package/src/runtime/agent/orchestrator/providers/anthropic-max-tokens-recovery.mjs

@@ -22,11 +22,15 @@ export function parseMaxTokensContextOverflow(status, message) {
   const match = OVERFLOW_RE.exec(String(message || ''));
   if (!match) return null;
   const [inputTokens, maxTokens, contextLimit] = match.slice(1).map((value) => Number.parseInt(value, 10));
-  return [inputTokens, maxTokens, contextLimit].every(Number.isFinite) ? { inputTokens, maxTokens, contextLimit } : null;
+  return [inputTokens, maxTokens, contextLimit].every(Number.isFinite)
+    ? { inputTokens, maxTokens, contextLimit }
+    : null;
 }
 
 const thinkingBudget = (body) =>
-  body?.thinking?.type === 'enabled' && Number(body.thinking.budget_tokens) > 0 ? Number(body.thinking.budget_tokens) : 0;
+  body?.thinking?.type === 'enabled' && Number(body.thinking.budget_tokens) > 0
+    ? Number(body.thinking.budget_tokens)
+    : 0;
 
 /**
  * Shrink `body.max_tokens` to fit the reported context. Returns true when the

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

@@ -159,8 +159,8 @@ function deferredAnthropicTools(activeTools, messages, opts, provider = 'anthrop
   return sharedDeferredAnthropicTools(activeTools, messages, opts, provider);
 }
 // `provider`: the engine's name (a gateway Messages engine runs under its gateway's).
-export function requestAnthropicTools(tools, messages, opts, provider = 'anthropic') {
-  return sharedRequestAnthropicTools(tools, messages, opts, provider);
+export function requestAnthropicTools(tools, messages, opts, provider = 'anthropic', config = {}) {
+  return sharedRequestAnthropicTools(tools, messages, opts, provider, config);
 }
 // Test-only: expose the lowering so the steering-provenance test can assert
 // the API-key provider keeps steering-tagged user turns distinct (mirrors

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

@@ -10,7 +10,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // source release just to advance the user-agent version.
 // Claude Opus 5.5 requires 2.1.280 or newer. The release workflow raises this
 // to the published CLI version (scripts/sync-client-version-floors.mjs).
-export const DEFAULT_CLI_VERSION = '2.1.310';
+export const DEFAULT_CLI_VERSION = '2.1.311';
 export const CLAUDE_CLI_NPM_PACKAGE = '@anthropic-ai/claude-code';
 
 const CACHE_SCHEMA_VERSION = 1;

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

@@ -15,6 +15,7 @@ import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { modelProxyClientMode, serverModelCredentialsDisabledError } from '../../../shared/model-proxy-mode.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
+import { TIMEOUT_PHASE } from '../../../shared/provider-timeout-phase.mjs';
 import { claudeCliUserAgent, resolveCliVersion } from './anthropic-oauth-client-version.mjs';
 import {
   accountIdentityFields,
@@ -375,7 +376,9 @@ async function _refreshOAuthCredentialsUnlocked(creds) {
     return refreshed;
   } catch (err) {
     if (err?.name === 'AbortError') {
-      throw new Error('Anthropic OAuth token refresh timed out after 30000ms');
+      throw Object.assign(new Error('Anthropic OAuth token refresh timed out after 30000ms'), {
+        timeoutPhase: TIMEOUT_PHASE.AUTH,
+      });
     }
     throw err;
   } finally {

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

@@ -12,7 +12,9 @@ import { sendGzipCompressed } from '../lib/request-compression.mjs';
 const API_URL = 'https://api.anthropic.com/v1/messages';
 export { ANTHROPIC_VERSION };
 
-export async function postMessages({ accessToken, requestBody, betaHeaders, signal, compress }) {
+// `plain`: exactly one uncompressed POST (a cache warm), so no compression
+// rejection resend can follow.
+export async function postMessages({ accessToken, requestBody, betaHeaders, signal, compress, plain = false }) {
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     'anthropic-version': ANTHROPIC_VERSION,
@@ -22,17 +24,15 @@ export async function postMessages({ accessToken, requestBody, betaHeaders, sign
     'x-app': 'cli',
     'Content-Type': 'application/json',
   };
-  return sendGzipCompressed({
-    raw: Buffer.from(JSON.stringify(requestBody)),
-    headers,
-    compress,
-    send: (body, sendHeaders) =>
-      fetch(API_URL, {
-        method: 'POST',
-        headers: sendHeaders,
-        body,
-        signal,
-        dispatcher: getLlmDispatcher(),
-      }),
-  });
+  const raw = Buffer.from(JSON.stringify(requestBody));
+  const send = (body, sendHeaders) =>
+    fetch(API_URL, {
+      method: 'POST',
+      headers: sendHeaders,
+      body,
+      signal,
+      dispatcher: getLlmDispatcher(),
+    });
+  if (plain) return send(raw, headers);
+  return sendGzipCompressed({ raw, headers, compress, send });
 }

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

@@ -50,7 +50,9 @@ export function anthropicQuotaError(status, headers, bodyText = '') {
   const detail = bodyText ? `: ${String(bodyText).slice(0, 200)}` : '';
   const retry = retryAfter ? ` retryAfter=${retryAfter}` : '';
   const quota = hasQuotaHeaders(headers);
-  const err = new Error(`Anthropic OAuth API ${status} ${quota ? 'quota/rate limit' : 'request rejected'}${retry}${detail}`);
+  const err = new Error(
+    `Anthropic OAuth API ${status} ${quota ? 'quota/rate limit' : 'request rejected'}${retry}${detail}`
+  );
   err.name = quota ? 'ProviderQuotaError' : 'ProviderRequestRejectedError';
   err.headers = headers;
   err.response = { status, headers };

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

@@ -8,6 +8,7 @@
 import { traceAgentSse, traceAgentUsage } from '../agent-trace.mjs';
 import {
   anthropicPrefixFingerprint,
+  anthropicPrefixSessionId,
   latestAnthropicPrefix,
   recordAnthropicPrefix,
 } from './lib/anthropic-prefix-trace.mjs';
@@ -43,16 +44,17 @@ import {
 } from './anthropic-oauth-credentials.mjs';
 import { claudeCliUserAgent, learnRequiredCliVersion, warmCliVersion } from './anthropic-oauth-client-version.mjs';
 import { createPassthroughSignal } from '../stall-policy.mjs';
-import { AnthropicFallbackTriggeredError } from './retry-classifier.mjs';
 import { ANTHROPIC_MAX_MIDSTREAM_RETRIES, parseSSEStream, _classifyMidstreamError } from './anthropic-sse.mjs';
 import { buildAnthropicBetaHeaders, supportsAnthropicFastMode } from './anthropic-betas.mjs';
 import { applyAnthropicServerFallback } from './anthropic-server-fallback.mjs';
 import { fastModeAvailable, fastModeDowngraded, noteFastModeCapacityError } from './anthropic-fast-mode.mjs';
 import { ANTHROPIC_VERSION, anthropicQuotaError, createAnthropicOAuthRequest } from './anthropic-oauth-request.mjs';
 import { isRefreshableAuthRejection } from './anthropic-oauth-request/initial-status.mjs';
+import { postMessages } from './anthropic-oauth-request/gzip-post.mjs';
+import { sendAnthropicCacheWarm } from './anthropic-cache-warm.mjs';
 import { applyAnthropicErrorContract } from './anthropic-error-contract.mjs';
 import { adjustMaxTokensForContextOverflow } from './anthropic-max-tokens-recovery.mjs';
-import { announceAnthropicModelFallback, createAnthropicOverloadTracker } from './anthropic-overload-fallback.mjs';
+import { createAnthropicOverloadTracker, takeAnthropicModelFallback } from './anthropic-overload-fallback.mjs';
 import { createAnthropicOAuthRecovery } from './anthropic-oauth-recovery.mjs';
 import { createMidState, createMidstreamRecovery } from './anthropic-oauth-midstream.mjs';
 import { assertAnthropicStreamNotEmpty } from './anthropic-midstream-recovery.mjs';
@@ -302,6 +304,28 @@ function buildRequestBody(requestMessages, model, tools, sendOpts) {
   return markAnthropicEffortBody(body, effortProjection);
 }
 
+// Known tool names for the leaked-tool-call guard in parseSSEStream:
+// recovered leaked calls are only synthesized when they name a tool
+// actually offered to this request (native + lowered). Derived from the
+// final request body so it matches exactly what the model was given.
+function requestToolNames(body) {
+  return new Set(
+    (Array.isArray(body.tools) ? body.tools : [])
+      .map((t) => (t && typeof t.name === 'string' ? t.name : null))
+      .filter(Boolean)
+  );
+}
+
+// The number of mid-stream retries a streamed turn took, as a hidden field of
+// the result.
+function tagMidstreamRetries(result, attemptIndex) {
+  try {
+    Object.defineProperty(result, '__midstreamRetries', { value: attemptIndex, enumerable: false });
+  } catch {
+    /* ignore non-extensible result */
+  }
+}
+
 export function _buildRequestBodyForCacheSmoke(messages, model, tools = [], sendOpts = {}) {
   return buildRequestBody(messages, model, tools, sendOpts);
 }
@@ -466,6 +490,41 @@ export class AnthropicOAuthProvider {
     );
   }
 
+  /**
+   * Cache-warm mode (anthropic-cache-warm.mjs): the body `send` would build
+   * for these arguments, POSTed once — no retry, credential replay, fallback
+   * model or re-send — and cut at the first content block. `onUsage` receives
+   * the reported usage as it arrives; resolves the final usage.
+   */
+  async sendCacheWarm(messages, model, tools, sendOpts = {}, { onUsage, accountId = '' } = {}) {
+    await warmCliVersion();
+    const opts = sendOpts || {};
+    const creds = await this.ensureAuth();
+    const body = buildRequestBody(sanitizeToolPairs(messages), model, tools, opts);
+    body.messages = await prepareAnthropicImages(body.messages, { signal: opts.signal });
+    return sendAnthropicCacheWarm({
+      providerName: this.name,
+      instance: this,
+      accountId,
+      model,
+      opts,
+      onUsage,
+      post: (signal) =>
+        postMessages({
+          accessToken: creds.accessToken,
+          requestBody: body,
+          betaHeaders: buildOAuthBetaHeaders(body, {
+            fastMode: this.fastModeBetaHeaderLatched,
+            toolSearch: Array.isArray(body.tools) && body.tools.some((t) => t?.defer_loading === true),
+            model,
+            opts,
+          }),
+          signal,
+          plain: true,
+        }),
+    });
+  }
+
   async _sendOnce(messages, model, tools, sendOpts) {
     await warmCliVersion();
     // Re-warm the kept-alive socket before the turn. preconnect() is a
@@ -497,7 +556,7 @@ export class AnthropicOAuthProvider {
     const body = buildRequestBody(messages, useModel, tools, sendOpts);
     body.messages = await prepareAnthropicImages(body.messages, { signal: externalSignal });
     // Diagnostic: per-block prefix hashes of exactly what is sent.
-    recordAnthropicPrefix(opts.sessionId || null, anthropicPrefixFingerprint(body));
+    recordAnthropicPrefix(anthropicPrefixSessionId(opts), anthropicPrefixFingerprint(body));
     if (body.speed === 'fast') {
       this.fastModeBetaHeaderLatched = true;
     }
@@ -505,15 +564,7 @@ export class AnthropicOAuthProvider {
     // actually carries deferred (defer_loading) tools — gate the header on
     // that instead of sending it unconditionally on every request.
     const hasDeferredTools = Array.isArray(body.tools) && body.tools.some((t) => t && t.defer_loading === true);
-    // Known tool names for the leaked-tool-call guard in parseSSEStream:
-    // recovered leaked calls are only synthesized when they name a tool
-    // actually offered to this request (native + lowered). Derived from the
-    // final request body so it matches exactly what the model was given.
-    const knownToolNames = new Set(
-      (Array.isArray(body.tools) ? body.tools : [])
-        .map((t) => (t && typeof t.name === 'string' ? t.name : null))
-        .filter(Boolean)
-    );
+    const knownToolNames = requestToolNames(body);
     const sessionId = opts.sessionId || null;
     const iteration = Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null;
     // Option A: no absolute wall-clock cap on streaming generation. A stream
@@ -530,51 +581,17 @@ export class AnthropicOAuthProvider {
     // totalSignal is therefore a pure pass-through of externalSignal with no timer.
     const totalTimeout = createPassthroughSignal(externalSignal);
     const totalSignal = totalTimeout.signal;
-    // Request-loop 529s and SSE overload events share one counter; at the
-    // limit the configured fallback model takes over the whole send.
-    const overload = createAnthropicOverloadTracker({
-      model: useModel,
-      fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
-    });
-    const { requestWithRetry, cleanupCancelHandler } = createAnthropicOAuthRequest({
-      provider: this,
+    const { requestWithRetry, cleanupCancelHandler, midstream } = this._createSendRecovery({
       opts,
       body,
       useModel,
       sessionId,
-      totalSignal,
-      overload,
-      betaHeadersFor: (requestBody) =>
-        buildOAuthBetaHeaders(requestBody, {
-          fastMode: this.fastModeBetaHeaderLatched,
-          toolSearch: hasDeferredTools,
-          model: useModel,
-          opts,
-        }),
-      onStageChange,
-    });
-    const recovery = createAnthropicOAuthRecovery({
-      provider: this,
-      opts,
-      body,
-      useModel,
       auth,
       totalSignal,
-      requestWithRetry,
-      cleanupCancelHandler,
+      hasDeferredTools,
       onStageChange,
       onTextReset,
     });
-    // Bounded mid-stream retries for transient stream loss; jittered backoff
-    // between attempts (anthropic-oauth-midstream.mjs).
-    const midstream = createMidstreamRecovery({
-      maxRetries: ANTHROPIC_MAX_MIDSTREAM_RETRIES,
-      totalSignal,
-      recovery,
-      onStageChange,
-      retry529: opts.retry529 !== false,
-      overload,
-    });
 
     let maxTokensAdjusted = false;
     try {
@@ -605,7 +622,9 @@ export class AnthropicOAuthProvider {
         if (SSE_VERBOSE) process.stderr.write(`[anthropic-oauth] Response ${response.status}, parsing SSE...\n`);
         try {
           onStageChange?.('streaming');
-        } catch {}
+        } catch {
+          // the stage observer is advisory
+        }
 
         const midState = createMidState(attemptIndex);
         try {
@@ -623,7 +642,9 @@ export class AnthropicOAuthProvider {
           );
           try {
             controller?.abort?.('Anthropic SSE complete');
-          } catch {}
+          } catch {
+            // the stream is complete; the controller may already be aborted
+          }
           this._settleStreamedTurn({
             result,
             midState,
@@ -632,12 +653,9 @@ export class AnthropicOAuthProvider {
             iteration,
             useModel,
             requestKind: opts.requestKind || null,
+            prefixSessionId: anthropicPrefixSessionId(opts),
           });
-          try {
-            Object.defineProperty(result, '__midstreamRetries', { value: attemptIndex, enumerable: false });
-          } catch {
-            /* ignore non-extensible result */
-          }
+          tagMidstreamRetries(result, attemptIndex);
           return result;
         } catch (err) {
           const decision = await midstream.onStreamError({ err, midState, controller, response, attemptIndex });
@@ -649,22 +667,81 @@ export class AnthropicOAuthProvider {
       }
       throw midstream.exhaustedError();
     } catch (err) {
-      // The fallback trigger can surface from the request loop, a mid-stream
-      // overload, or the non-streaming recovery: handle it around the whole
-      // operation, not just the first request.
-      if (!(err instanceof AnthropicFallbackTriggeredError)) throw err;
-      process.stderr.write(`[anthropic-oauth] ${err.message}\n`);
-      announceAnthropicModelFallback(onStageChange, _displayModel(useModel), _displayModel(err.fallbackModel));
-      return await this.send(messages, err.fallbackModel, tools, {
-        ...opts,
-        fallbackModel: undefined,
-        _fallbackTriggered: true,
+      const fallbackOpts = takeAnthropicModelFallback(err, {
+        tag: 'anthropic-oauth',
+        model: useModel,
+        opts,
+        onStageChange,
+        displayModel: _displayModel,
       });
+      return await this.send(messages, err.fallbackModel, tools, fallbackOpts);
     } finally {
       totalTimeout.cleanup();
     }
   }
 
+  // The request and recovery pipeline of one send over its fixed body: the
+  // shared overload counter, the retried request with its per-request beta
+  // headers, the non-streaming recovery and the bounded mid-stream retries.
+  _createSendRecovery({
+    opts,
+    body,
+    useModel,
+    sessionId,
+    auth,
+    totalSignal,
+    hasDeferredTools,
+    onStageChange,
+    onTextReset,
+  }) {
+    // Request-loop 529s and SSE overload events share one counter; at the
+    // limit the configured fallback model takes over the whole send.
+    const overload = createAnthropicOverloadTracker({
+      model: useModel,
+      fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
+    });
+    const { requestWithRetry, cleanupCancelHandler } = createAnthropicOAuthRequest({
+      provider: this,
+      opts,
+      body,
+      useModel,
+      sessionId,
+      totalSignal,
+      overload,
+      betaHeadersFor: (requestBody) =>
+        buildOAuthBetaHeaders(requestBody, {
+          fastMode: this.fastModeBetaHeaderLatched,
+          toolSearch: hasDeferredTools,
+          model: useModel,
+          opts,
+        }),
+      onStageChange,
+    });
+    const recovery = createAnthropicOAuthRecovery({
+      provider: this,
+      opts,
+      body,
+      useModel,
+      auth,
+      totalSignal,
+      requestWithRetry,
+      cleanupCancelHandler,
+      onStageChange,
+      onTextReset,
+    });
+    // Bounded mid-stream retries for transient stream loss; jittered backoff
+    // between attempts (anthropic-oauth-midstream.mjs).
+    const midstream = createMidstreamRecovery({
+      maxRetries: ANTHROPIC_MAX_MIDSTREAM_RETRIES,
+      totalSignal,
+      recovery,
+      onStageChange,
+      retry529: opts.retry529 !== false,
+      overload,
+    });
+    return { requestWithRetry, cleanupCancelHandler, midstream };
+  }
+
   // One attempt's initial response: a 401 (or Anthropic's exact revoked-token
   // 403) refreshes the credentials in `auth` and replays once; a context
   // overflow 400 shrinks `body.max_tokens` and replays once per send
@@ -687,7 +764,9 @@ export class AnthropicOAuthProvider {
       // resources before the credential-refresh replay.
       try {
         controller?.abort?.();
-      } catch {}
+      } catch {
+        // the controller may already be aborted before the credential-refresh replay
+      }
       auth.creds = await this.ensureAuth({ forceRefresh: true, reason: String(response.status) });
       ({ response, controller, cancelHandler } = await requestWithRetry(auth.creds.accessToken));
       rejectedAuthBody = null;
@@ -702,7 +781,9 @@ export class AnthropicOAuthProvider {
         cleanupCancelHandler(cancelHandler);
         try {
           controller?.abort?.();
-        } catch {}
+        } catch {
+          // the controller may already be aborted before the max-tokens replay
+        }
         ({ response, controller, cancelHandler } = await requestWithRetry(auth.creds.accessToken));
         rejectedAuthBody = null;
       }
@@ -808,7 +889,16 @@ export class AnthropicOAuthProvider {
   }
 
   // Traces + catalog upkeep for a streamed turn, then the empty-stream guard.
-  _settleStreamedTurn({ result, midState, sseStartedAt, sessionId, iteration, useModel, requestKind }) {
+  _settleStreamedTurn({
+    result,
+    midState,
+    sseStartedAt,
+    sessionId,
+    iteration,
+    useModel,
+    requestKind,
+    prefixSessionId,
+  }) {
     const ttftMs = midState.ttftAt ? midState.ttftAt - sseStartedAt : null;
     const liveModel = result.model || useModel;
     traceAgentSse({
@@ -833,7 +923,7 @@ export class AnthropicOAuthProvider {
       rawUsage: result.usage?.raw || null,
       provider: 'anthropic-oauth',
       requestKind,
-      prefixBlocks: latestAnthropicPrefix(sessionId),
+      prefixBlocks: latestAnthropicPrefix(prefixSessionId),
     });
 
     // Phase I: if the live response surfaced a model id we don't know

package/src/runtime/agent/orchestrator/providers/anthropic-overload-fallback.mjs

@@ -12,11 +12,15 @@
 import { ANTHROPIC_MAX_CONSECUTIVE_529 } from './retry-backoff.mjs';
 import { AnthropicFallbackTriggeredError } from './retry-classifier.mjs';
 
-export const OVERLOADED_ERROR_CODE = 'overloaded_error';
+const OVERLOADED_ERROR_CODE = 'overloaded_error';
 
 /** Consecutive 529s end the request only for API-key (non-subscriber) first-party Opus. */
 export function isTerminalOverloadModel(model) {
-  return /^claude-opus-/.test(String(model || '').trim().toLowerCase());
+  return /^claude-opus-/.test(
+    String(model || '')
+      .trim()
+      .toLowerCase()
+  );
 }
 
 export function isAnthropicOverloadError(err) {
@@ -56,8 +60,26 @@ export function createAnthropicOverloadTracker({ model, fallbackModel, terminalA
   };
 }
 
+/**
+ * The catch around a whole Anthropic send. The fallback trigger can surface
+ * from the request loop, a mid-stream overload, or the non-streaming
+ * recovery; any other error is rethrown unchanged. For the trigger it logs,
+ * announces the model switch, and returns the options of the single re-send
+ * on `err.fallbackModel` (no second hop).
+ */
+export function takeAnthropicModelFallback(err, { tag, model, opts, onStageChange, displayModel = (id) => id }) {
+  if (!(err instanceof AnthropicFallbackTriggeredError)) throw err;
+  process.stderr.write(`[${tag}] ${err.message}\n`);
+  announceAnthropicModelFallback(onStageChange, displayModel(model), displayModel(err.fallbackModel));
+  return {
+    ...opts,
+    fallbackModel: undefined,
+    _fallbackTriggered: true,
+  };
+}
+
 /** Visible model-switch notice on the existing display-only stage channel. */
-export function announceAnthropicModelFallback(onStageChange, fromLabel, toLabel) {
+function announceAnthropicModelFallback(onStageChange, fromLabel, toLabel) {
   if (typeof onStageChange !== 'function') return;
   try {
     onStageChange('reconnecting', {