mixdog 1.2.1 → 1.2.3

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

@@ -42,8 +42,12 @@ 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 } from './anthropic-fast-mode.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 { applyAnthropicErrorContract } from './anthropic-error-contract.mjs';
+import { adjustMaxTokensForContextOverflow } from './anthropic-max-tokens-recovery.mjs';
+import { announceAnthropicModelFallback, createAnthropicOverloadTracker } 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';
@@ -51,6 +55,7 @@ import { applyAnthropicEffortToBody, shouldIncludeEffortBeta } from './anthropic
 import { ANTHROPIC_EFFORT_LEVELS, withEffortRejectionFallback } from './effort-rejection.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import {
+  anthropicThinkingActive,
   applyAnthropicCacheMarkers,
   clampAnthropicThinkingBudget as clampThinkingBudgetTokens,
   deferredAnthropicTools as sharedDeferredAnthropicTools,
@@ -58,6 +63,7 @@ import {
   resolveAnthropicCacheTtls as resolveCacheTtls,
   resolveAnthropicMessageCacheSlots,
   sanitizeAnthropicInputSchema,
+  sharedCachePrefixBoundary,
   toAnthropicMessages,
   toAnthropicToolChoice,
 } from './lib/anthropic-request-utils.mjs';
@@ -91,12 +97,6 @@ function logQuiet(line) {
   if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[anthropic-oauth] ${line}\n`);
 }
 
-function requiresSystemPrefix(model) {
-  // Every Claude OAuth model needs the first-party system prefix for OAuth
-  // pool routing; without it the server answers 429 rate_limit_error "Error".
-  return /^claude-/.test(String(model || '').toLowerCase());
-}
-
 function buildOAuthBetaHeaders(body, { fastMode = false, toolSearch = false, model, opts = {} } = {}) {
   return buildAnthropicBetaHeaders({
     base: usesAnthropicEffortBody(body) ? `${OAUTH_BETA_HEADERS},${EFFORT_CONFIGURATION_BETA}` : OAUTH_BETA_HEADERS,
@@ -114,23 +114,21 @@ function buildOAuthBetaHeaders(body, { fastMode = false, toolSearch = false, mod
 // content (even the prefix concatenated with extra text in the same block)
 // falls into the standard pool and Opus/Sonnet return 429. Splitting into
 // two blocks — [prefix, rest] — keeps both routing and user instructions.
-function buildSystemBlocks(systemMsgs, model, systemTtl, tier3Ttl) {
+function buildSystemBlocks(systemMsgs, systemTtl, tier3Ttl) {
   // systemMsgs is an array of { content, cacheTier } — each non-empty element
   // becomes its own Anthropic content block with its own cache_control
   // breakpoint. Blocks tagged cacheTier:'tier3' (BP3 sessionMarker) take the
   // tier3 TTL; every other block (BP1 baseRules / BP2 stableSystem) takes the
   // system TTL. Invariant: callers must pass an array.
   const items = systemBlockItems(systemMsgs);
-  const gated = requiresSystemPrefix(model);
 
-  const blocks = [];
-  if (gated) {
-    blocks.push({ type: 'text', text: CLAUDE_CODE_SYSTEM_PREFIX });
-  }
+  // Every model on the OAuth route is routed by this prefix block, so it is
+  // sent unconditionally rather than keyed on the model id.
+  const blocks = [{ type: 'text', text: CLAUDE_CODE_SYSTEM_PREFIX }];
   for (let i = 0; i < items.length; i++) {
     let body = items[i].text;
     // Strip a duplicated OAuth system prefix from the first block if present.
-    if (gated && i === 0 && body.startsWith(CLAUDE_CODE_SYSTEM_PREFIX)) {
+    if (i === 0 && body.startsWith(CLAUDE_CODE_SYSTEM_PREFIX)) {
       body = body.slice(CLAUDE_CODE_SYSTEM_PREFIX.length).trim();
       if (!body) continue;
     }
@@ -170,10 +168,10 @@ function buildSystemBlocks(systemMsgs, model, systemTtl, tier3Ttl) {
 //   1. MIXDOG_ANTHROPIC_MAX_OUTPUT_TOKENS env override, if set, wins outright.
 //   2. Catalog outputTokens (trusted over hardcoded heuristics when present),
 //      clamped to [MAX_TOKENS_FLOOR, safetyCap].
-//   3. Static MAX_TOKENS table / family heuristic fallback when the catalog
-//      has no entry for this model, also clamped to the safety cap.
-function resolveMaxTokens(model) {
-  return resolveAnthropicMaxTokens(model, { catalogLookup: _catalogOutputTokens });
+//   3. Shared model catalog outputTokens, then the floor, when the live
+//      roster has no entry for this model.
+function resolveMaxTokens(model, { modelMaxOutputTokens = null } = {}) {
+  return resolveAnthropicMaxTokens(model, { catalogLookup: _catalogOutputTokens, modelMaxOutputTokens });
 }
 
 // --- Message conversion ---
@@ -195,29 +193,38 @@ function requestAnthropicTools(tools, messages, opts) {
 function buildRequestBody(messages, model, tools, sendOpts) {
   const systemMsgs = messages.filter((m) => m.role === 'system');
   const chatMsgs = messages.filter((m) => m.role !== 'system');
-  const maxTokens = resolveMaxTokens(model);
   const opts = sendOpts || {};
+  const maxTokens = resolveMaxTokens(model, { modelMaxOutputTokens: opts.modelMaxOutputTokens });
   const effortProjection = projectEffortConfiguration(messages, 'anthropic-oauth', model, opts);
   const ttls = resolveCacheTtls(opts);
   // Each system message becomes its own Anthropic content block with its own
   // breakpoint: BP1 baseRules + BP2 stableSystem at ttls.system, BP3
   // sessionMarker (cacheTier:'tier3') at ttls.tier3.
-  const systemBlocks = buildSystemBlocks(systemMsgs, model, ttls?.system, ttls?.tier3);
+  const systemBlocks = buildSystemBlocks(systemMsgs, ttls?.system, ttls?.tier3);
 
   // Message-tail cache budget (4-BP layout + ANTHROPIC_MSG_SLOTS) is shared
   // with anthropic.mjs — see resolveAnthropicMessageCacheSlots.
-  const messageCacheSlots = resolveAnthropicMessageCacheSlots(systemBlocks, ttls);
   // Tools are resolved BEFORE the messages: the lowering needs the final
   // tool list to drop tool_reference blocks whose tool no longer ships in
   // this request (otherwise the API rejects the whole turn).
   const requestTools = requestAnthropicTools(tools, chatMsgs, opts);
+  const messageCacheSlots = resolveAnthropicMessageCacheSlots(systemBlocks, ttls, { tools: requestTools });
   // Build → sanitize (once, inside toAnthropicMessages) → mark. Markers are
   // applied to the FINAL sanitized array by invariant, so block drops /
   // inserts / reorders performed by the sanitizer can never move or delete a
   // marked block. NEVER sanitize again after this (see send path).
+  const lowerHistory = (history, projection) =>
+    lowerAnthropicEffortHistory(
+      history.filter((m) => m.role !== 'system'),
+      (segment) => toAnthropicMessages(segment, requestTools),
+      projection
+    );
   const anthropicMessages = applyAnthropicCacheMarkers(
-    lowerAnthropicEffortHistory(chatMsgs, (segment) => toAnthropicMessages(segment, requestTools), effortProjection),
-    messageCacheSlots
+    lowerHistory(chatMsgs, effortProjection),
+    messageCacheSlots,
+    sharedCachePrefixBoundary(messages, opts, (prefix) =>
+      lowerHistory(prefix, projectEffortConfiguration(prefix, 'anthropic-oauth', model, opts))
+    )
   );
 
   const body = {
@@ -242,10 +249,8 @@ function buildRequestBody(messages, model, tools, sendOpts) {
   // tool_choice only when tools are actually present (Anthropic rejects
   // tool_choice without tools). 'none' rides the hard-cap final turn to
   // forbid tool USE while keeping the tools prefix stable for cache reuse.
-  if (body.tools) {
-    const toolChoice = toAnthropicToolChoice(opts.toolChoice);
-    if (toolChoice) body.tool_choice = toolChoice;
-  }
+  // Key reserved for wire order; resolved after thinking is applied.
+  if (body.tools) body.tool_choice = undefined;
 
   applyAnthropicEffortToBody(body, {
     model,
@@ -256,6 +261,16 @@ function buildRequestBody(messages, model, tools, sendOpts) {
     progressUpdates: true,
   });
 
+  if (body.tools) {
+    const toolChoice = toAnthropicToolChoice(opts.toolChoice, {
+      thinking: anthropicThinkingActive(body),
+      disableParallelToolUse: opts.disableParallelToolUse === true,
+      onThinkingConflict: opts.toolChoiceThinkingConflict,
+    });
+    if (toolChoice) body.tool_choice = toolChoice;
+    else delete body.tool_choice;
+  }
+
   // Skipped while the fast capacity pool is in cooldown (or permanently
   // unavailable) so a drained pool is not re-probed every turn.
   if (opts.fast === true && supportsAnthropicFastMode(model) && fastModeAvailable()) {
@@ -480,6 +495,12 @@ 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,
       opts,
@@ -487,6 +508,7 @@ export class AnthropicOAuthProvider {
       useModel,
       sessionId,
       totalSignal,
+      overload,
       betaHeadersFor: (requestBody) =>
         buildOAuthBetaHeaders(requestBody, {
           fastMode: this.fastModeBetaHeaderLatched,
@@ -516,24 +538,14 @@ export class AnthropicOAuthProvider {
       recovery,
       onStageChange,
       retry529: opts.retry529 !== false,
+      overload,
     });
 
+    let maxTokensAdjusted = false;
     try {
       for (let attemptIndex = 0; attemptIndex <= ANTHROPIC_MAX_MIDSTREAM_RETRIES; attemptIndex++) {
         let response, controller, cancelHandler;
-        try {
-          ({ response, controller, cancelHandler } = await requestWithRetry(auth.creds.accessToken));
-        } catch (err) {
-          if (err instanceof AnthropicFallbackTriggeredError) {
-            process.stderr.write(`[anthropic-oauth] ${err.message}\n`);
-            return this.send(messages, err.fallbackModel, tools, {
-              ...opts,
-              fallbackModel: undefined,
-              _fallbackTriggered: true,
-            });
-          }
-          throw err;
-        }
+        ({ response, controller, cancelHandler } = await requestWithRetry(auth.creds.accessToken));
 
         // Refresh on 401, and only Anthropic's exact official revoked-token
         // 403 signature. Ordinary permission/policy 403s are terminal.
@@ -541,8 +553,7 @@ export class AnthropicOAuthProvider {
         if (response.status === 401 || response.status === 403) {
           rejectedAuthBody = await response.text().catch(() => '');
         }
-        const revoked403 = response.status === 403 && String(rejectedAuthBody).includes('OAuth token has been revoked');
-        if (response.status === 401 || revoked403) {
+        if (isRefreshableAuthRejection(response.status, rejectedAuthBody)) {
           process.stderr.write(`[anthropic-oauth] ${response.status} — forcing refresh and retrying once\n`);
           cleanupCancelHandler(cancelHandler);
           // Body was drained above; abort closes any remaining transport
@@ -555,6 +566,20 @@ export class AnthropicOAuthProvider {
           rejectedAuthBody = null;
         }
 
+        // "input length and max_tokens exceed context limit": shrink max_tokens
+        // to what the context has room for and replay once.
+        if (response.status === 400 && !maxTokensAdjusted) {
+          rejectedAuthBody = await response.text().catch(() => '');
+          if (adjustMaxTokensForContextOverflow(body, 400, rejectedAuthBody)) {
+            maxTokensAdjusted = true;
+            cleanupCancelHandler(cancelHandler);
+            try {
+              controller?.abort?.();
+            } catch {}
+            ({ response, controller, cancelHandler } = await requestWithRetry(auth.creds.accessToken));
+            rejectedAuthBody = null;
+          }
+        }
         if (!response.ok) {
           cleanupCancelHandler(cancelHandler);
           return await this._resendAfterRejection({
@@ -615,6 +640,18 @@ 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,
+      });
     } finally {
       totalTimeout.cleanup();
     }
@@ -632,6 +669,21 @@ export class AnthropicOAuthProvider {
       throw anthropicQuotaError(response.status, response.headers, safeText);
     }
 
+    // An account that cannot use fast mode answers the speed field with a
+    // 400. Fast mode is now off for this process, so replaying the turn once
+    // builds a standard-speed request.
+    if (
+      response.status === 400 &&
+      opts.fast === true &&
+      !opts._fastModeRetry &&
+      fastModeDowngraded(
+        noteFastModeCapacityError({ httpStatus: 400, message: scrubbedText }, { fast: true })
+      )
+    ) {
+      process.stderr.write(`[anthropic-oauth] fast mode is not enabled for this account; retrying at standard speed\n`);
+      return this.send(messages, useModel, tools, { ...opts, _fastModeRetry: true });
+    }
+
     // A newer model that rejects the mid-conversation effort update: switch
     // the updates off for it in this process and replay the turn once
     // without them (the request keeps its turn effort).
@@ -694,9 +746,14 @@ export class AnthropicOAuthProvider {
       return this.send(messages, fallbackModel || model, tools, { ...opts, _modelRetry: true });
     }
     const err = new Error(`Anthropic OAuth API ${response.status}: ${safeText}`);
-    err.status = response.status;
-    err.httpStatus = response.status;
-    throw err;
+    // 413 stays `request_too_large` (a byte/media size refusal) and a 400
+    // "prompt is too long" stays `invalid_request_error`, so the core can tell
+    // a payload it must shrink from a context it can compact.
+    throw applyAnthropicErrorContract(err, {
+      status: response.status,
+      headers: response.headers,
+      bodyText: scrubbedText,
+    });
   }
 
   // Traces + catalog upkeep for a streamed turn, then the empty-stream guard.

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

@@ -0,0 +1,69 @@
+/**
+ * anthropic-overload-fallback.mjs — one overload counter per logical send,
+ * shared by the request loop (HTTP 529 before a stream exists) and the SSE
+ * parser (`overloaded_error` event after one started). Both reach it through
+ * the same error fields — `status: 529` / `code: 'overloaded_error'` — so a
+ * mix of the two trips the configured fallback model after the same number of
+ * consecutive overloads, instead of each path counting only its own.
+ *
+ * The request loop's counter is withRetry's `overloadState`; this tracker owns
+ * that object, so the SSE path increments the very counter the loop reads.
+ */
+import { ANTHROPIC_MAX_CONSECUTIVE_529 } from './retry-backoff.mjs';
+import { AnthropicFallbackTriggeredError } from './retry-classifier.mjs';
+
+export 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());
+}
+
+export function isAnthropicOverloadError(err) {
+  const status = Number(err?.httpStatus || err?.status || err?.response?.status || 0);
+  return status === 529 || String(err?.code || '').toLowerCase() === OVERLOADED_ERROR_CODE;
+}
+
+/**
+ * @param {{ model: string, fallbackModel?: string|null, terminalAtLimit?: boolean }} deps  fallbackModel is
+ *   already undefined when this send IS the fallback (no second hop).
+ */
+export function createAnthropicOverloadTracker({ model, fallbackModel, terminalAtLimit = false }) {
+  const canFallback = Boolean(fallbackModel) && fallbackModel !== model;
+  // Handed to every withRetry of the send as `overloadState`: the request
+  // loop increments this same object on each 529.
+  const state = { consecutive529Errors: 0 };
+  return {
+    state,
+    // Repeated-overload stop, handed to withRetry as `stopAfterRepeated529`: with no
+    // fallback model, API-key Opus stops after repeated 529s. A configured
+    // fallback always wins (the executor checks it first).
+    stopAfterRepeated529: terminalAtLimit && !canFallback,
+    /**
+     * An overload SSE error. Returns the fallback trigger to throw once the
+     * consecutive limit is reached and a fallback model is configured.
+     */
+    noteStreamOverload(err) {
+      state.consecutive529Errors += 1;
+      if (state.consecutive529Errors < ANTHROPIC_MAX_CONSECUTIVE_529) return null;
+      if (canFallback) return new AnthropicFallbackTriggeredError(model, fallbackModel, err);
+      // No fallback model: API-key Opus stops here ("Repeated 529 Overloaded
+      // errors") instead of spending the full budget.
+      if (!terminalAtLimit) return null;
+      err.repeated529 = true;
+      return err;
+    },
+  };
+}
+
+/** Visible model-switch notice on the existing display-only stage channel. */
+export function announceAnthropicModelFallback(onStageChange, fromLabel, toLabel) {
+  if (typeof onStageChange !== 'function') return;
+  try {
+    onStageChange('reconnecting', {
+      message: `${fromLabel} is overloaded — continuing on ${toLabel}`,
+    });
+  } catch {
+    /* display-only */
+  }
+}

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

@@ -6,6 +6,10 @@ function normalizedModelId(value) {
   return typeof raw === 'string' ? raw.trim() : '';
 }
 
+// Kept as an id pattern: no catalog field declares server-side fallback, and
+// `fallbacks` is a beta-gated body field other models reject (a wrong "yes" is
+// a 400, a wrong "no" only skips an optional refusal fallback), so unknown ids
+// stay off.
 export function supportsAnthropicServerFallback(model) {
   const id = normalizeClaudeModelId(normalizedModelId(model));
   return /^claude-(?:opus|fable)-5(?:$|[-@])/.test(id);

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

@@ -36,6 +36,20 @@ export function createTurnBlocks() {
   const appendText = (index, chunk) => {
     text.set(index, (text.get(index) || '') + (chunk || ''));
   };
+  // Per-index citations of a text block (content_block_start `citations` plus
+  // streamed citations_delta), replayed verbatim on the text block they cite.
+  const citations = new Map();
+  const appendCitation = (index, citation) => {
+    if (!citation || typeof citation !== 'object') return;
+    if (!text.has(index)) text.set(index, '');
+    let copy;
+    try {
+      copy = structuredClone(citation);
+    } catch {
+      copy = { ...citation };
+    }
+    citations.set(index, [...(citations.get(index) || []), copy]);
+  };
   // Client tool_use blocks that were actually dispatched, kept for the same
   // ordered replay list (deduped/skipped calls are intentionally absent).
   const clientToolUse = new Map();
@@ -61,7 +75,11 @@ export function createTurnBlocks() {
     ...thinking.entries(),
     ...[...text.entries()].map(([index, value]) => [
       index,
-      { type: 'text', text: typeof value === 'string' ? value : '' },
+      {
+        type: 'text',
+        text: typeof value === 'string' ? value : '',
+        ...(citations.get(index)?.length ? { citations: citations.get(index) } : {}),
+      },
     ]),
     ...completedNativeBlocks(),
     ...clientToolUse.entries(),
@@ -105,6 +123,7 @@ export function createTurnBlocks() {
     pendingToolInputs,
     clientToolUse,
     appendText,
+    appendCitation,
     toolInputInFlight,
     orderedThinkingBlocks,
     orderedAssistantBlocks,

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-events/content-block-delta.mjs

@@ -88,14 +88,27 @@ export function createContentBlockDelta({ turn, blocks, state, leak, relayText,
     progress('tool');
   };
 
-  return (index, delta) => {
+  const stampTtft = () => {
+    if (state && !state.ttftAt) state.ttftAt = Date.now();
+  };
+
+  const onContentBlockDelta = (index, delta) => {
     if (delta?.type) turn.contentBlockTypes.add(delta.type);
     // Time-to-first-token: stamp the first content delta (text / thinking /
     // tool input_json) exactly once so the SSE trace can separate first-byte
     // latency from total stream/generation time.
-    if (state && !state.ttftAt) state.ttftAt = Date.now();
+    stampTtft();
     if (delta?.type === 'text_delta') onTextDelta(index, delta.text);
+    if (delta?.type === 'citations_delta') blocks.appendCitation(index, delta.citation);
     if (delta?.type === 'thinking_delta' || delta?.type === 'signature_delta') onThinkingDelta(index, delta);
     if (delta?.type === 'input_json_delta') onInputJsonDelta(index, delta.partial_json);
   };
+  // A text block may open with non-empty `text` on content_block_start: it is
+  // model output and takes the same path as a text_delta (live relay, leak
+  // guard, returned content, ordered replay copy).
+  onContentBlockDelta.seedText = (index, initialText) => {
+    stampTtft();
+    onTextDelta(index, initialText);
+  };
+  return onContentBlockDelta;
 }

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-events/content-block-start.mjs

@@ -19,7 +19,7 @@ function cloneNativeBlock(block) {
   }
 }
 
-export function createContentBlockStart({ turn, blocks, state, progress }) {
+export function createContentBlockStart({ turn, blocks, state, progress, seedText }) {
   const seedThinkingBlock = (index, block) => {
     if (block.type === 'redacted_thinking') {
       // Opaque redacted payload: real reasoning content, exposed as a block.
@@ -61,9 +61,16 @@ export function createContentBlockStart({ turn, blocks, state, progress }) {
       });
     }
     if (block?.type === 'text') {
-      // Seed the ordered text slot (a text block may open with a non-empty
-      // `text` before any delta).
-      blocks.appendText(index, typeof block.text === 'string' ? block.text : '');
+      // Seed the ordered text slot. An empty block still needs its slot (it
+      // separates thinking runs); a non-empty opening `text` is model output
+      // and is routed exactly like a text_delta so it reaches the returned and
+      // live content once.
+      const initialText = typeof block.text === 'string' ? block.text : '';
+      if (initialText) seedText(index, initialText);
+      else blocks.appendText(index, '');
+      if (Array.isArray(block.citations)) {
+        for (const citation of block.citations) blocks.appendCitation(index, citation);
+      }
     }
     if (NATIVE_SERVER_TOOL_CALL_BLOCK_TYPES.has(block?.type)) {
       // Verbatim seed; `input` is completed from the streamed

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

@@ -26,6 +26,9 @@ export function createMessageEvents({ turn, blocks, state }) {
     if (event.delta && (event.delta.stop_details != null || event.delta.category != null)) {
       turn.stopDetails = stopDetailsFrom(event.delta);
     }
+    if (event.delta?.stop_sequence != null) {
+      turn.stopSequence = event.delta.stop_sequence;
+    }
     if (event.usage) updateTurnUsage(turn.usage, event.usage);
     // A terminal stop_reason while ANY tool input is still streaming ends the
     // turn truncated, immediately: the model declared it stopped sampling, so

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

@@ -21,18 +21,25 @@ export function createTurnEvents({
   labels,
 }) {
   const { onMessageStart, onMessageDelta, onMessageStop } = createMessageEvents({ turn, blocks, state });
+  const onContentBlockDelta = createContentBlockDelta({
+    turn,
+    blocks,
+    state,
+    leak,
+    relayText,
+    progress,
+    relayProgressUpdates,
+  });
   return {
     onMessageStart,
-    onContentBlockStart: createContentBlockStart({ turn, blocks, state, progress }),
-    onContentBlockDelta: createContentBlockDelta({
+    onContentBlockStart: createContentBlockStart({
       turn,
       blocks,
       state,
-      leak,
-      relayText,
       progress,
-      relayProgressUpdates,
+      seedText: onContentBlockDelta.seedText,
     }),
+    onContentBlockDelta,
     onContentBlockStop: createContentBlockStop({ turn, blocks, state, leak, progress, onToolCall, labels }),
     onMessageDelta,
     onMessageStop,

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

@@ -138,6 +138,7 @@ export function createTurnOutcome({ turn, blocks, state, labels = OAUTH_STREAM_L
       usage: turn.usage,
       stopReason: turn.stopReason,
       stopDetails: turn.stopDetails,
+      ...(turn.stopSequence != null ? { stopSequence: turn.stopSequence } : {}),
       hasThinkingContent: turn.hasThinkingContent,
       contentBlockTypes: Array.from(turn.contentBlockTypes),
       // Ordered extended-thinking blocks (verbatim thinking text + signature)

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

@@ -5,6 +5,8 @@
  * module of the turn reads and writes this one object; nothing about the
  * turn's progress is hidden in a closure.
  */
+import { reportedCostUsd } from '../lib/usage-primitives.mjs';
+import { normalizeServerToolUse } from '../lib/anthropic-server-tool-usage.mjs';
 
 export function createAnthropicTurnState() {
   return {
@@ -16,6 +18,9 @@ export function createAnthropicTurnState() {
     usage: { inputTokens: 0, outputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, raw: null },
     stopReason: null,
     stopDetails: undefined,
+    // The custom stop sequence that ended the turn (message_delta
+    // delta.stop_sequence); stays undefined unless the API reports one.
+    stopSequence: undefined,
     fallbackEvents: [],
     // Set when a terminal frame (message_delta stop_reason / message_stop)
     // arrived while tool input was still in flight — used only to word the
@@ -35,6 +40,15 @@ export function updateTurnUsage(usage, raw) {
   if (raw.cache_creation?.ephemeral_1h_input_tokens != null) {
     usage.cacheWrite1hTokens = raw.cache_creation.ephemeral_1h_input_tokens;
   }
+  // A gateway's reported cost (OpenRouter puts `cost` on the final usage). It
+  // rides the turn usage itself, so a success, an abandoned attempt and a
+  // failure's partial usage all carry it to the provider-boundary ledger.
+  const costUsd = reportedCostUsd(raw.cost);
+  if (costUsd !== undefined) usage.costUsd = costUsd;
+  // Server-tool counters are cumulative in message_delta; a later report
+  // replaces the earlier one, an absent one preserves it.
+  const serverToolUse = normalizeServerToolUse(raw);
+  if (serverToolUse) usage.serverToolUse = serverToolUse;
   usage.raw = { ...(usage.raw || {}), ...raw };
   // Input excludes cache; all three slots contribute to prompt volume.
   usage.promptTokens = usage.inputTokens + usage.cachedTokens + usage.cacheWriteTokens;

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

@@ -75,9 +75,11 @@ const ANTHROPIC_SSE_ERROR_TYPE_STATUS = new Map([
   ['authentication_error', 401],
   ['permission_error', 403],
   ['not_found_error', 404],
+  ['conflict_error', 409],
   ['request_too_large', 413],
   ['rate_limit_error', 429],
   ['api_error', 500],
+  ['timeout_error', 504],
   ['overloaded_error', 529],
 ]);
 
@@ -109,6 +111,13 @@ function _anthropicSseError(event, labels) {
     err.httpStatus = status;
     err.status = status;
   }
+  // Provider-boundary contract: `code` is the lowercased Anthropic error type
+  // (an overload carries `overloaded_error` + 529, which the overload counter
+  // reads); an untyped `error` frame keeps the generic SSE code. A 413 is a
+  // byte-size refusal, never a prompt-token one.
+  const wireType = typeof type === 'string' ? type.trim().toLowerCase() : '';
+  if (status === 413) err.code = 'request_too_large';
+  else if (wireType && wireType !== 'error') err.code = wireType;
   // Wire-error marker: an error type OUTSIDE the documented enumeration
   // (no status resolved above) default-retries under the shared wire-error
   // contract instead of failing the turn as 'unknown'. Typed statuses and
@@ -162,7 +171,7 @@ function applyAnthropicSseEvent(framedEvent, { turn, watchdogs, state, progress,
         return false;
     }
   } catch (err) {
-    if (err?.code === 'EANTHROPIC_SSE_ERROR') throw err;
+    if (err?.name === 'AnthropicSseError') throw err;
     /* skip malformed events */
     return false;
   }

package/src/runtime/agent/orchestrator/providers/anthropic-turn-result.mjs

@@ -10,6 +10,7 @@
  * account for usage identically.
  */
 import { traceAgentUsage } from '../agent-trace.mjs';
+import { reportedCostUsd } from './lib/usage-primitives.mjs';
 
 /**
  * @param {object} parseResult  the assembled turn (streaming or normalized non-streaming)
@@ -26,6 +27,7 @@ export function buildAnthropicTurnResult(parseResult, { provider, useModel, opts
   const output = parseResult.usage?.outputTokens || 0;
   const promptTokens = parseResult.usage?.promptTokens ?? input + cacheRead + cacheWrite;
   const liveModel = parseResult.model || useModel;
+  const costUsd = parseResult.usage?.costUsd ?? reportedCostUsd(usageRaw?.cost);
 
   if (usageRaw || input || output || cacheRead || cacheWrite) {
     traceAgentUsage({
@@ -53,6 +55,8 @@ export function buildAnthropicTurnResult(parseResult, { provider, useModel, opts
     model: liveModel,
     toolCalls: parseResult.toolCalls,
     stopReason: parseResult.stopReason || null,
+    ...(parseResult.stopDetails != null ? { stopDetails: parseResult.stopDetails } : {}),
+    ...(parseResult.stopSequence != null ? { stopSequence: parseResult.stopSequence } : {}),
     hasThinkingContent: !!parseResult.hasThinkingContent,
     contentBlockTypes: Array.isArray(parseResult.contentBlockTypes) ? parseResult.contentBlockTypes : [],
     // Round-trip adaptive-thinking blocks (verbatim thinking +
@@ -84,6 +88,11 @@ export function buildAnthropicTurnResult(parseResult, { provider, useModel, opts
       cacheWriteTokens: cacheWrite,
       ...(parseResult.usage?.cacheWrite1hTokens ? { cacheWrite1hTokens: parseResult.usage.cacheWrite1hTokens } : {}),
       promptTokens,
+      // A gateway-reported cost (OpenRouter `usage.cost`), when the turn has one.
+      ...(costUsd !== undefined ? { costUsd } : {}),
+      ...(parseResult.usage?.serverToolUse ? { serverToolUse: parseResult.usage.serverToolUse } : {}),
+      // Raw provider usage (incl. server_tool_use counters), as on the OAuth path.
+      ...(usageRaw ? { raw: usageRaw } : {}),
     },
   };
 }