mixdog 1.3.1 → 1.3.3

package/src/runtime/agent/orchestrator/providers/anthropic-api-request.mjs

@@ -10,6 +10,7 @@
  * anthropic-turn-result.mjs); nothing here touches the socket.
  */
 import { prepareAnthropicImages } from './lib/anthropic-image-input.mjs';
+import { anthropicPrefixFingerprint, recordAnthropicPrefix } from './lib/anthropic-prefix-trace.mjs';
 import { buildAnthropicBetaHeaders, supportsAnthropicFastMode } from './anthropic-betas.mjs';
 import { applyAnthropicServerFallback } from './anthropic-server-fallback.mjs';
 import { fastModeAvailable } from './anthropic-fast-mode.mjs';
@@ -17,6 +18,7 @@ import { applyAnthropicEffortToBody, shouldIncludeEffortBeta } from './anthropic
 import { isCustomProviderName, resolveCustomReasoning } from './custom-reasoning.mjs';
 import {
   anthropicThinkingActive,
+  appendAnthropicTailReminder,
   applyAnthropicCacheMarkers,
   clampAnthropicThinkingBudget as clampThinkingBudgetTokens,
   resolveAnthropicCacheTtls as resolveCacheTtls,
@@ -24,6 +26,7 @@ import {
   sharedCachePrefixBoundary,
   toAnthropicToolChoice,
 } from './lib/anthropic-request-utils.mjs';
+import { splitTailReminder } from './lib/tail-reminder-split.mjs';
 import {
   buildSystemBlocks,
   resolveMaxTokens,
@@ -50,7 +53,7 @@ import {
 export async function buildAnthropicApiRequest({
   name,
   config,
-  messages,
+  messages: requestMessages,
   useModel,
   tools,
   opts,
@@ -67,7 +70,11 @@ export async function buildAnthropicApiRequest({
   // the global by-model-id capability index and the Claude-id ladders are
   // first-party knowledge and must not leak onto (or from) a custom endpoint.
   const isCustom = isCustomProviderName(name);
-  const maxTokens = resolveMaxTokens(capabilityModel, { modelMaxOutputTokens });
+  const { messages, reminder } = splitTailReminder(requestMessages);
+  const maxTokens = resolveMaxTokens(capabilityModel, {
+    modelMaxOutputTokens,
+    override: opts?.maxOutputTokensOverride,
+  });
   const effortOptions = { ...config, ...opts, disableBetaHeaders: config?.disableBetaHeaders };
   const gatewayEffort = typeof config?.messagesEffort === 'function' ? config.messagesEffort(opts) : null;
   const effortProjection = projectEffortConfiguration(messages, name, useModel, effortOptions);
@@ -108,7 +115,9 @@ export async function buildAnthropicApiRequest({
     model: useModel,
     max_tokens: maxTokens,
     system: systemBlocks.length ? systemBlocks : undefined,
-    messages: await prepareAnthropicImages(anthropicMessages, { signal: opts.signal }),
+    messages: await prepareAnthropicImages(appendAnthropicTailReminder(anthropicMessages, reminder), {
+      signal: opts.signal,
+    }),
   };
   // Server-side fallback and fast mode are decided from Claude model ids:
   // first-party knowledge, never applied to a custom endpoint.
@@ -135,6 +144,55 @@ export async function buildAnthropicApiRequest({
       .map((t) => (t && typeof t.name === 'string' ? t.name : null))
       .filter(Boolean)
   );
+  applyRequestReasoning(params, {
+    isCustom,
+    name,
+    config,
+    opts,
+    modelInfo,
+    capabilityModel,
+    maxTokens,
+    gatewayEffort,
+    effortProjection,
+  });
+  if (params.tools) resolveRequestToolChoice(params, opts, config);
+  // Fast mode → speed: "fast" on models Anthropic marks as speed-capable.
+  // Suppressed while the fast capacity pool is cooling down.
+  let fastLatched = fastModeLatched;
+  if (!isCustom && opts.fast === true && supportsAnthropicFastMode(useModel) && fastModeAvailable()) {
+    params.speed = 'fast';
+    fastLatched = true;
+  }
+  // NOTE: do NOT sanitize here. params.messages was already sanitized
+  // once inside toAnthropicMessages and then had cache markers applied.
+  // Re-sanitizing after marking could drop/reorder a marked block and
+  // move the provider-visible cache breakpoint off the cached one — the
+  // exact COLD-turn bug this change fixes. Order: build → sanitize
+  // (once) → mark → prepare image bytes → send.
+  params.stream = true;
+  // Diagnostic: per-block prefix hashes of exactly what is sent.
+  recordAnthropicPrefix(opts.sessionId || opts.session?.id || null, anthropicPrefixFingerprint(params));
+
+  const requestHeaders = requestHeadersFor(params, {
+    config,
+    opts,
+    isCustom,
+    fastLatched,
+    hasDeferredTools,
+    capabilityModel,
+    effortProjection,
+  });
+
+  return { params, requestHeaders, knownToolNames, fastModeLatched: fastLatched };
+}
+
+/** The turn's thinking/effort fields on `params` (in place): a custom
+ *  provider's from its own model row, else the turn effort (or a gateway's
+ *  own `messagesEffort`; 'none' sends no thinking at all). */
+function applyRequestReasoning(
+  params,
+  { isCustom, name, config, opts, modelInfo, capabilityModel, maxTokens, gatewayEffort, effortProjection }
+) {
   if (isCustom) {
     const { fields } = resolveCustomReasoning({
       protocol: 'anthropic',
@@ -156,32 +214,29 @@ export async function buildAnthropicApiRequest({
       progressUpdates: config?.disableBetaHeaders !== true,
     });
   }
-  if (params.tools) {
-    const toolChoice = toAnthropicToolChoice(opts.toolChoice, {
-      thinking: anthropicThinkingActive(params),
-      disableParallelToolUse: opts.disableParallelToolUse === true,
-      // A gateway that cannot honour disable_parallel_tool_use declares so.
-      supportsDisableParallelToolUse: config?.supportsDisableParallelToolUse !== false,
-      onThinkingConflict: opts.toolChoiceThinkingConflict,
-    });
-    if (toolChoice) params.tool_choice = toolChoice;
-    else delete params.tool_choice;
-  }
-  // Fast mode → speed: "fast" on models Anthropic marks as speed-capable.
-  // Suppressed while the fast capacity pool is cooling down.
-  let fastLatched = fastModeLatched;
-  if (!isCustom && opts.fast === true && supportsAnthropicFastMode(useModel) && fastModeAvailable()) {
-    params.speed = 'fast';
-    fastLatched = true;
-  }
-  // NOTE: do NOT sanitize here. params.messages was already sanitized
-  // once inside toAnthropicMessages and then had cache markers applied.
-  // Re-sanitizing after marking could drop/reorder a marked block and
-  // move the provider-visible cache breakpoint off the cached one — the
-  // exact COLD-turn bug this change fixes. Order: build → sanitize
-  // (once) → mark → prepare image bytes → send.
-  params.stream = true;
+}
 
+/** The reserved `tool_choice` of a request with tools, resolved once
+ *  thinking is known (forced any/tool is invalid while thinking is on);
+ *  dropped when none applies. */
+function resolveRequestToolChoice(params, opts, config) {
+  const toolChoice = toAnthropicToolChoice(opts.toolChoice, {
+    thinking: anthropicThinkingActive(params),
+    disableParallelToolUse: opts.disableParallelToolUse === true,
+    // A gateway that cannot honour disable_parallel_tool_use declares so.
+    supportsDisableParallelToolUse: config?.supportsDisableParallelToolUse !== false,
+    onThinkingConflict: opts.toolChoiceThinkingConflict,
+  });
+  if (toolChoice) params.tool_choice = toolChoice;
+  else delete params.tool_choice;
+}
+
+/** The per-request headers of the final body `params`: the anthropic-beta
+ *  set it needs, then the caller's `opts.requestHeaders`; null when none. */
+function requestHeadersFor(
+  params,
+  { config, opts, isCustom, fastLatched, hasDeferredTools, capabilityModel, effortProjection }
+) {
   // Per-call headers override the client defaultHeaders, so the
   // constructor-level disableBetaHeaders opt-out must be honoured here
   // too — otherwise opencode-go's anthropic-compatible routing
@@ -205,8 +260,5 @@ export async function buildAnthropicApiRequest({
     ].filter(Boolean);
     if (betas.length) betaHeaders = { 'anthropic-beta': betas.join(',') };
   }
-  const requestHeaders =
-    betaHeaders || opts.requestHeaders ? { ...(betaHeaders || {}), ...(opts.requestHeaders || {}) } : null;
-
-  return { params, requestHeaders, knownToolNames, fastModeLatched: fastLatched };
+  return betaHeaders || opts.requestHeaders ? { ...(betaHeaders || {}), ...(opts.requestHeaders || {}) } : null;
 }

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

@@ -59,16 +59,11 @@ function sharedCatalogOutputTokens(model) {
   return Number.isFinite(declared) && declared > 0 ? declared : null;
 }
 
-// catalogLookup(model) -> number|null. Providers supply their own strategy
-// for sourcing the catalog array (in-memory mirror + disk fallback for OAuth,
-// plain disk read for the API-key twin — see anthropic.mjs).
-//
-// `modelMaxOutputTokens` (number|null): a gateway-supplied model limit. When
-// positive it takes precedence over every catalog lookup. A declared model
-// maximum is a ceiling: it is never raised to the floor, and the env override
-// is capped by it.
-export function resolveAnthropicMaxTokens(model, { catalogLookup, modelMaxOutputTokens = null } = {}) {
-  const isLimit = (value) => Number.isFinite(value) && value > 0;
+const isLimit = (value) => Number.isFinite(value) && value > 0;
+
+// The model's declared output limit (gateway value, then catalogs), unclamped
+// by the safety cap; null when nothing declares one.
+function declaredOutputLimit(model, { catalogLookup, modelMaxOutputTokens }) {
   let declared = Number(modelMaxOutputTokens);
   if (!isLimit(declared)) {
     declared = null;
@@ -81,7 +76,39 @@ export function resolveAnthropicMaxTokens(model, { catalogLookup, modelMaxOutput
     }
     if (!isLimit(declared)) declared = sharedCatalogOutputTokens(model);
   }
-  declared = isLimit(declared) ? Math.floor(declared) : null;
+  return isLimit(declared) ? Math.floor(declared) : null;
+}
+
+/**
+ * The larger max_tokens to retry a turn with after it spent the whole normal
+ * budget: the model's declared output limit when it exceeds what a normal
+ * request carries, else null (nothing higher to try). An explicit env override
+ * is the user's chosen ceiling and is never escalated past.
+ */
+export function resolveAnthropicEscalatedMaxTokens(model, { catalogLookup, modelMaxOutputTokens = null } = {}) {
+  if (envAnthropicMaxOutputOverride() != null) return null;
+  const declared = declaredOutputLimit(model, { catalogLookup, modelMaxOutputTokens });
+  if (declared == null) return null;
+  const current = resolveAnthropicMaxTokens(model, { catalogLookup, modelMaxOutputTokens });
+  return declared > current ? declared : null;
+}
+
+// catalogLookup(model) -> number|null. Providers supply their own strategy
+// for sourcing the catalog array (in-memory mirror + disk fallback for OAuth,
+// plain disk read for the API-key twin — see anthropic.mjs).
+//
+// `modelMaxOutputTokens` (number|null): a gateway-supplied model limit. When
+// positive it takes precedence over every catalog lookup. A declared model
+// maximum is a ceiling: it is never raised to the floor, and the env override
+// is capped by it.
+//
+// `override` (number|null): a one-shot request for a specific max_tokens (the
+// loop's output-limit escalation). When positive it wins outright; the caller
+// derives it from resolveAnthropicEscalatedMaxTokens, which already respects
+// the declared model limit.
+export function resolveAnthropicMaxTokens(model, { catalogLookup, modelMaxOutputTokens = null, override = null } = {}) {
+  if (isLimit(Number(override))) return Math.floor(Number(override));
+  const declared = declaredOutputLimit(model, { catalogLookup, modelMaxOutputTokens });
   const envOverride = envAnthropicMaxOutputOverride();
   if (envOverride != null) return declared == null ? envOverride : Math.min(envOverride, declared);
   if (declared != null) return Math.min(declared, DEFAULT_SAFETY_CAP);

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

@@ -2,7 +2,7 @@
 import { createRequire } from 'node:module';
 import { effortValuesForModel, thinkingTypesFromCapabilities } from './anthropic-effort.mjs';
 import { makeModelCache } from './model-cache.mjs';
-import { resolveAnthropicMaxTokens } from './anthropic-max-tokens.mjs';
+import { resolveAnthropicEscalatedMaxTokens, resolveAnthropicMaxTokens } from './anthropic-max-tokens.mjs';
 import {
   deferredAnthropicTools as sharedDeferredAnthropicTools,
   requestAnthropicTools as sharedRequestAnthropicTools,
@@ -130,8 +130,20 @@ function _catalogOutputTokensFromSharedCache(model) {
   }
 }
 
-export function resolveMaxTokens(model, { modelMaxOutputTokens = null } = {}) {
-  return resolveAnthropicMaxTokens(model, { catalogLookup: _catalogOutputTokensFromSharedCache, modelMaxOutputTokens });
+export function resolveMaxTokens(model, { modelMaxOutputTokens = null, override = null } = {}) {
+  return resolveAnthropicMaxTokens(model, {
+    catalogLookup: _catalogOutputTokensFromSharedCache,
+    modelMaxOutputTokens,
+    override,
+  });
+}
+
+// The higher max_tokens an output-limit retry may use for `model`, or null.
+export function resolveEscalatedMaxTokens(model, { modelMaxOutputTokens = null } = {}) {
+  return resolveAnthropicEscalatedMaxTokens(model, {
+    catalogLookup: _catalogOutputTokensFromSharedCache,
+    modelMaxOutputTokens,
+  });
 }
 
 // Test-only escape hatch for the provider contract scripts

package/src/runtime/agent/orchestrator/providers/anthropic-model-resolve.mjs

@@ -149,7 +149,7 @@ function _markLatestByFamily(models) {
   for (const m of byFamily.values()) m.latest = true;
 }
 
-function _compareVersion(a, b) {
+export function _compareVersion(a, b) {
   const na = (a.match(/^claude-[a-z]+-(\d+)(?:-(\d+))?/i) || []).slice(1).map(Number);
   const nb = (b.match(/^claude-[a-z]+-(\d+)(?:-(\d+))?/i) || []).slice(1).map(Number);
   for (let i = 0; i < Math.max(na.length, nb.length); i++) {

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.304';
+export const DEFAULT_CLI_VERSION = '2.1.308';
 export const CLAUDE_CLI_NPM_PACKAGE = '@anthropic-ai/claude-code';
 
 const CACHE_SCHEMA_VERSION = 1;

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

@@ -6,8 +6,13 @@
  * from anthropic.mjs. agent-trace instrumented.
  */
 import { traceAgentSse, traceAgentUsage } from '../agent-trace.mjs';
+import {
+  anthropicPrefixFingerprint,
+  latestAnthropicPrefix,
+  recordAnthropicPrefix,
+} from './lib/anthropic-prefix-trace.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
-import { resolveAnthropicMaxTokens } from './anthropic-max-tokens.mjs';
+import { resolveAnthropicEscalatedMaxTokens, resolveAnthropicMaxTokens } from './anthropic-max-tokens.mjs';
 import { MODELS } from './lib/anthropic-models.mjs';
 import { systemBlockItems, systemBlockTtl } from './lib/anthropic-system-blocks.mjs';
 import { prepareAnthropicImages } from './lib/anthropic-image-input.mjs';
@@ -56,6 +61,7 @@ import { ANTHROPIC_EFFORT_LEVELS, withEffortRejectionFallback } from './effort-r
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import {
   anthropicThinkingActive,
+  appendAnthropicTailReminder,
   applyAnthropicCacheMarkers,
   clampAnthropicThinkingBudget as clampThinkingBudgetTokens,
   deferredAnthropicTools as sharedDeferredAnthropicTools,
@@ -67,6 +73,7 @@ import {
   toAnthropicMessages,
   toAnthropicToolChoice,
 } from './lib/anthropic-request-utils.mjs';
+import { splitTailReminder } from './lib/tail-reminder-split.mjs';
 import {
   EFFORT_CONFIGURATION_BETA,
   isEffortConfigurationRejection,
@@ -169,8 +176,8 @@ function buildSystemBlocks(systemMsgs, systemTtl, tier3Ttl) {
 //      clamped to [MAX_TOKENS_FLOOR, safetyCap].
 //   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 });
+function resolveMaxTokens(model, { modelMaxOutputTokens = null, override = null } = {}) {
+  return resolveAnthropicMaxTokens(model, { catalogLookup: _catalogOutputTokens, modelMaxOutputTokens, override });
 }
 
 // --- Message conversion ---
@@ -189,11 +196,15 @@ function requestAnthropicTools(tools, messages, opts) {
 // the tier3 1h cache_control to that block; BP1/BP2 take the system TTL. No
 // `<system-reminder>` user message / sentinel scan is involved anymore.
 
-function buildRequestBody(messages, model, tools, sendOpts) {
+function buildRequestBody(requestMessages, model, tools, sendOpts) {
+  const { messages, reminder } = splitTailReminder(requestMessages);
   const systemMsgs = messages.filter((m) => m.role === 'system');
   const chatMsgs = messages.filter((m) => m.role !== 'system');
   const opts = sendOpts || {};
-  const maxTokens = resolveMaxTokens(model, { modelMaxOutputTokens: opts.modelMaxOutputTokens });
+  const maxTokens = resolveMaxTokens(model, {
+    modelMaxOutputTokens: opts.modelMaxOutputTokens,
+    override: opts.maxOutputTokensOverride,
+  });
   const effortProjection = projectEffortConfiguration(messages, 'anthropic-oauth', model, opts);
   const ttls = resolveCacheTtls(opts);
   // Each system message becomes its own Anthropic content block with its own
@@ -229,7 +240,7 @@ function buildRequestBody(messages, model, tools, sendOpts) {
   const body = {
     model,
     max_tokens: maxTokens,
-    messages: anthropicMessages,
+    messages: appendAnthropicTailReminder(anthropicMessages, reminder),
     stream: true,
   };
   applyAnthropicServerFallback(body, model, {
@@ -304,6 +315,16 @@ export class AnthropicOAuthProvider {
     preconnect('https://api.anthropic.com');
   }
 
+  // The larger max_tokens the loop may retry a max_tokens-truncated turn with
+  // (one-shot, via opts.maxOutputTokensOverride), or null when the model has
+  // nothing above the normal request.
+  escalatedMaxTokens(model, opts = {}) {
+    return resolveAnthropicEscalatedMaxTokens(model, {
+      catalogLookup: _catalogOutputTokens,
+      modelMaxOutputTokens: opts.modelMaxOutputTokens,
+    });
+  }
+
   async ensureAuth({ forceRefresh = false, reason = 'preemptive' } = {}) {
     await warmCliVersion();
     if (!this.credentials) {
@@ -463,6 +484,8 @@ export class AnthropicOAuthProvider {
     const useModel = model || (await ensureLatestAnthropicModel(this));
     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));
     if (body.speed === 'fast') {
       this.fastModeBetaHeaderLatched = true;
     }
@@ -544,42 +567,15 @@ export class AnthropicOAuthProvider {
     let maxTokensAdjusted = false;
     try {
       for (let attemptIndex = 0; attemptIndex <= ANTHROPIC_MAX_MIDSTREAM_RETRIES; attemptIndex++) {
-        let response, controller, cancelHandler;
-        ({ 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.
-        let rejectedAuthBody = null;
-        if (response.status === 401 || response.status === 403) {
-          rejectedAuthBody = await response.text().catch(() => '');
-        }
-        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
-          // resources before the credential-refresh replay.
-          try {
-            controller?.abort?.();
-          } catch {}
-          auth.creds = await this.ensureAuth({ forceRefresh: true, reason: String(response.status) });
-          ({ response, controller, cancelHandler } = await requestWithRetry(auth.creds.accessToken));
-          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;
-          }
-        }
+        const opened = await this._openResponse({
+          requestWithRetry,
+          cleanupCancelHandler,
+          auth,
+          body,
+          maxTokensAdjusted,
+        });
+        const { response, controller, cancelHandler, rejectedAuthBody } = opened;
+        maxTokensAdjusted = opened.maxTokensAdjusted;
         if (!response.ok) {
           cleanupCancelHandler(cancelHandler);
           return await this._resendAfterRejection({
@@ -657,6 +653,51 @@ export class AnthropicOAuthProvider {
     }
   }
 
+  // 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
+  // (`maxTokensAdjusted`). `rejectedAuthBody`: the drained text of a final
+  // rejected response, null when none was read.
+  async _openResponse({ requestWithRetry, cleanupCancelHandler, auth, body, maxTokensAdjusted }) {
+    let response, controller, cancelHandler;
+    ({ 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.
+    let rejectedAuthBody = null;
+    if (response.status === 401 || response.status === 403) {
+      rejectedAuthBody = await response.text().catch(() => '');
+    }
+    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
+      // resources before the credential-refresh replay.
+      try {
+        controller?.abort?.();
+      } catch {}
+      auth.creds = await this.ensureAuth({ forceRefresh: true, reason: String(response.status) });
+      ({ response, controller, cancelHandler } = await requestWithRetry(auth.creds.accessToken));
+      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;
+      }
+    }
+    return { response, controller, cancelHandler, rejectedAuthBody, maxTokensAdjusted };
+  }
+
   // A non-OK initial response: quota errors surface as-is; a CLI-version
   // floor or an unknown/retired model replays the turn ONCE through send().
   async _resendAfterRejection({ response, rejectedAuthBody, messages, model, useModel, tools, opts, onStageChange }) {
@@ -780,6 +821,7 @@ export class AnthropicOAuthProvider {
       rawUsage: result.usage?.raw || null,
       provider: 'anthropic-oauth',
       requestKind,
+      prefixBlocks: latestAnthropicPrefix(sessionId),
     });
 
     // Phase I: if the live response surfaced a model id we don't know

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

@@ -11,6 +11,7 @@
  */
 import { traceAgentUsage } from '../agent-trace.mjs';
 import { reportedCostUsd } from './lib/usage-primitives.mjs';
+import { latestAnthropicPrefix } from './lib/anthropic-prefix-trace.mjs';
 
 /**
  * @param {object} parseResult  the assembled turn (streaming or normalized non-streaming)
@@ -47,6 +48,7 @@ export function buildAnthropicTurnResult(parseResult, { provider, useModel, opts
       // Anthropic usage is additive at this inner transport
       // boundary, even when OpenCode Go supplies the provider id.
       inputTokensInclusive: false,
+      prefixBlocks: latestAnthropicPrefix(opts.sessionId || opts.session?.id || null),
     });
   }
 

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

@@ -27,7 +27,12 @@ import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 
-import { loadAnthropic, _normalizeAnthropicModel, _setApiKeyCatalogMirror } from './anthropic-messages.mjs';
+import {
+  loadAnthropic,
+  resolveEscalatedMaxTokens,
+  _normalizeAnthropicModel,
+  _setApiKeyCatalogMirror,
+} from './anthropic-messages.mjs';
 import { ANTHROPIC_VERSION, MODELS } from './lib/anthropic-models.mjs';
 import { streamCallbacks } from './lib/send-callbacks.mjs';
 import { preparePdfTextForProvider } from './media-normalization.mjs';
@@ -92,6 +97,14 @@ export class AnthropicProvider {
   _capabilityModel(model) {
     return model;
   }
+  // The larger max_tokens the loop may retry a max_tokens-truncated turn with
+  // (one-shot, via opts.maxOutputTokensOverride), or null when the model has
+  // nothing above the normal request.
+  escalatedMaxTokens(model, opts = {}) {
+    return resolveEscalatedMaxTokens(this._capabilityModel(model), {
+      modelMaxOutputTokens: opts.modelMaxOutputTokens ?? null,
+    });
+  }
   reloadApiKey() {
     try {
       const newKey = reloadProviderApiKey(this.name, this.config);

package/src/runtime/agent/orchestrator/providers/antigravity-request.mjs

@@ -3,6 +3,7 @@ import { createProviderReplay, providerReplayItems } from './lib/provider-replay
 import { toGeminiContents, toGeminiRequestTools, toGeminiToolConfig } from './gemini-schema.mjs';
 import { geminiThinkingConfig } from './gemini-thinking.mjs';
 import { isGeminiFamilyModel } from './gemini-family.mjs';
+import { splitTailReminder } from './lib/tail-reminder-split.mjs';
 
 const THOUGHT_SIGNATURE_SENTINEL = 'skip_thought_signature_validator';
 const CLAUDE_MAX_OUTPUT_TOKENS = 64000;
@@ -219,7 +220,10 @@ function antigravityGeminiThinkingConfig(model, opts) {
   });
 }
 
-export function buildAntigravityRequest(messages, model, tools, opts = {}, projectId) {
+export function buildAntigravityRequest(requestMessages, model, tools, opts = {}, projectId) {
+  // The tail reminder is not history: the tool-loop closure below must see the
+  // real tail, so the reminder is appended to the wire contents last.
+  const { messages, reminder } = splitTailReminder(requestMessages);
   const systemText = messages
     .filter((message) => message.role === 'system')
     .map((message) => message.content)
@@ -234,7 +238,7 @@ export function buildAntigravityRequest(messages, model, tools, opts = {}, proje
     ...(claude ? { maxOutputTokens: CLAUDE_MAX_OUTPUT_TOKENS } : {}),
     ...(thinkingConfig ? { thinkingConfig } : {}),
   };
-  const request = { contents };
+  const request = { contents: reminder ? [...contents, { role: 'user', parts: [{ text: reminder }] }] : contents };
   if (systemText) request.systemInstruction = { role: 'user', parts: [{ text: systemText }] };
   const requestTools = claude
     ? claudeRequestTools(tools, opts.nativeTools, opts.onToolExcluded)

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

@@ -3,24 +3,43 @@
 // Every turn starts again from the base, so a run of hard turns never
 // ratchets the effort upward.
 //
-// The base is `medium` on every model: raised only when the request needs it,
-// lowered when it is easy. The ladder is the model's supported efforts from
+// The base is the global "Auto reasoning base" setting (`autoEffortBase` in the
+// agent config; low / medium / high, default `medium`), the same on every model
+// and independent of the effort last chosen: raised only when the request needs
+// it, lowered when it is easy. The ladder is the model's supported efforts from
 // `low` up to the tier below the top: `none`/`minimal` switch thinking off and
-// `max`/`ultra` are reserved for an explicit user choice, so auto never picks
-// them. A chosen `max`/`ultra` is left untouched.
+// `max`/`ultra` are reserved for an explicit (fixed, Auto off) user choice, so
+// auto never picks them. A base the model does not offer is clamped to the
+// nearest ladder level.
 
 const EFFORT_ORDER = Object.freeze(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
 const FLOOR_INDEX = EFFORT_ORDER.indexOf('low');
 const RESERVED_TOP = new Set(['max', 'ultra']);
 
 export const AUTO_EFFORT_BASE = 'medium';
+/** The "Auto reasoning base" choices: the levels Auto can work around. */
+export const AUTO_EFFORT_BASES = Object.freeze(['low', 'medium', 'high']);
 
-/** The effort auto moves from: `medium`, unless the user chose `max`/`ultra`. */
-export function autoEffortBase(chosen) {
-  const effort = String(chosen ?? '')
+/** The effort auto moves from: the global "Auto reasoning base" setting
+ *  (`autoEffortBase` in the agent config); absent or invalid is `medium`. */
+export function autoEffortBase(setting) {
+  const effort = String(setting ?? '')
     .trim()
     .toLowerCase();
-  return RESERVED_TOP.has(effort) ? effort : AUTO_EFFORT_BASE;
+  return AUTO_EFFORT_BASES.includes(effort) ? effort : AUTO_EFFORT_BASE;
+}
+
+/** The base on the model's ladder: the setting itself, else the nearest
+ *  ladder level (the lower one on a tie); null when the ladder is empty. */
+export function clampAutoEffortBase({ base, options }) {
+  const ladder = autoEffortLadder(options);
+  if (!ladder.length) return null;
+  const want = EFFORT_ORDER.indexOf(autoEffortBase(base));
+  let best = ladder[0];
+  for (const level of ladder) {
+    if (Math.abs(EFFORT_ORDER.indexOf(level) - want) < Math.abs(EFFORT_ORDER.indexOf(best) - want)) best = level;
+  }
+  return best;
 }
 
 export const AUTO_EFFORT_MODES = Object.freeze(['off', 'observe', 'on']);

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

@@ -4,7 +4,7 @@ import { createRemoteVersionSource } from './npm-cli-version.mjs';
 // documented version endpoint; the official installer script embeds the
 // current build (…/lab/<build>/…), parsed best-effort. Any format change or
 // failure falls back to the floor.
-export const CURSOR_CLIENT_VERSION_FLOOR = 'cli-2026.10.19-6bbf2c4';
+export const CURSOR_CLIENT_VERSION_FLOOR = 'cli-2026.10.22-27dcf5f';
 const BUILD_PATTERN = /downloads\.cursor\.com\/lab\/(\d{4}\.\d{2}\.\d{2}-[0-9a-f]{6,40})\//;
 export const CURSOR_INSTALL_URL = 'https://cursor.com/install';