opencode-anthropic-fix 0.1.28 → 0.1.30

package/index.mjs

@@ -4,7 +4,7 @@ import { randomBytes, randomUUID, createHash as createHashCrypto } from "node:cr
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve, basename } from "node:path";
 import xxhashInit from "xxhash-wasm";
-import { AccountManager } from "./lib/accounts.mjs";
+import { AccountManager, RATE_LIMIT_KEY_FAST } from "./lib/accounts.mjs";
 import {
   authorize as oauthAuthorize,
   exchange as oauthExchange,
@@ -37,6 +37,11 @@ import { callHaiku } from "./lib/haiku-call.mjs";
 import { summarize as rollingSummarize } from "./lib/rolling-summarizer.mjs";
 import { staleReadEviction, perToolClassPrune } from "./lib/message-transform.mjs";
 
+// Max times a single logical request may fall back from fast->standard speed on
+// the same account before giving up the fast attempt entirely. 1 is enough: one
+// fast 429 => one standard retry on the same account.
+const MAX_FAST_FALLBACKS = 1;
+
 // ---------------------------------------------------------------------------
 // Account management CLI prompts
 // ---------------------------------------------------------------------------
@@ -2461,7 +2466,10 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
             if (
               config.override_model_limits.enabled &&
               !isTruthyEnv(process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT) &&
-              (hasOneMillionContext(model.id) || isOpus46Model(model.id) || isOpus47Model(model.id))
+              (hasOneMillionContext(model.id) ||
+                isOpus46Model(model.id) ||
+                isOpus47Model(model.id) ||
+                isOpus48Model(model.id))
             ) {
               model.limit = {
                 ...(model.limit ?? {}),
@@ -2642,6 +2650,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
               let serviceWideRetryCount = 0; // Track 529/503 retries (max 2 per RE doc §5.5)
               let shouldRetryCount = 0; // Track x-should-retry forced retries (cap at 3)
               let consecutive529Count = 0;
+              let fastFallbackCount = 0; // Track fast->standard same-account fallbacks (cap below)
               // Classify request for retry budget (A8)
               const requestClass =
                 config.request_classification?.enabled !== false ? classifyApiRequest(requestInit.body) : "foreground";
@@ -2682,7 +2691,17 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                       "No enabled Anthropic accounts available. Enable one with 'opencode-anthropic-auth enable <N>'.",
                     );
                   }
-                  // All accounts excluded (transient refresh failures) — give up
+                  // All accounts excluded (transient refresh failures) — give up.
+                  // Diagnostic: surface WHICH accounts were skipped and why, so the
+                  // "No available account" symptom is debuggable (e.g. it can be a
+                  // downstream effect of an OAuth refresh failure, not a true
+                  // exhaustion). transientRefreshSkips holds account indices that
+                  // failed/were-rate-limited during refresh this request.
+                  debugLog("No available account — all candidates transiently skipped", {
+                    enabledCount,
+                    transientRefreshSkips: Array.from(transientRefreshSkips),
+                    attempt,
+                  });
                   throw new Error("No available Anthropic account for request.");
                 }
 
@@ -2847,6 +2866,12 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                 // suppress context-hint for non-main-thread requests so we don't
                 // opt subagent/title/tool one-shots into a server retry loop.
                 const _requestRole = classifyRequestRole(_parsedBodyOnce);
+                // opencode tags subagent requests with the x-parent-session-id header
+                // (set in its request builder only when a parent session exists).
+                // This is a reliable subagent signal; body-shape classification alone
+                // sees subagents as "main" (real messages + large max_tokens). Used
+                // only to pick the cheaper 5m cache tier for one-shot subagents.
+                const _isSubagent = getIncomingHeader(input, requestInit, "x-parent-session-id") != null;
                 const _baseTE = config.token_economy || {};
                 const _disableCtxHint = contextHintState.disabled || _requestRole !== "main";
                 const _tokenEconomy = _disableCtxHint
@@ -2979,6 +3004,10 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     provider: _reqProvider,
                     cachePolicy: effectiveCachePolicy,
                     fastMode: config.fast_mode || false,
+                    // When the account's fast pool is cooling down, suppress
+                    // speed:"fast" so this turn runs at standard speed on the same
+                    // account instead of re-hitting the exhausted fast pool.
+                    fastRateLimited: accountManager.isFastRateLimited(account),
                     strategy: getEffectiveStrategy(),
                     toolDeferral: config.token_economy_strategies?.tool_deferral,
                     toolDescriptionCompaction: config.token_economy_strategies?.tool_description_compaction,
@@ -2995,6 +3024,15 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     usedTools: sessionMetrics.usedTools,
                     tokenEconomySession,
                     requestRole: _requestRole,
+                    isSubagent: _isSubagent,
+                    // Adaptive cache-breakpoint placement: pass the per-boundary
+                    // stability snapshot so transformRequestBody can anchor the
+                    // cache_control marker on the most-stable boundary instead of
+                    // the (possibly thrashing) last tool. Only populated once the
+                    // detector is enabled and has a baseline.
+                    cacheBoundaryStability: config.cache_break_detection?.adaptive_breakpoint
+                      ? cacheBreakState.boundaryStability
+                      : null,
                   },
                   computedBetaHeader,
                   config,
@@ -3018,6 +3056,16 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                 if (config.cache_break_detection?.enabled && typeof body === "string") {
                   const currentHashes = extractCacheSourceHashes(body);
                   if (currentHashes.size > 0) {
+                    // Update per-boundary structural stability BEFORE staging the
+                    // new hashes, diffing against the prior turn's baseline. This
+                    // feeds the adaptive breakpoint placer on the NEXT turn.
+                    if (cacheBreakState.sourceHashes.size > 0) {
+                      updateBoundaryStability(
+                        currentHashes,
+                        cacheBreakState.sourceHashes,
+                        cacheBreakState.boundaryStability,
+                      );
+                    }
                     cacheBreakState._pendingHashes = currentHashes;
                   }
                 }
@@ -3665,8 +3713,14 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                   // Check x-should-retry header first — server override
                   const shouldRetry = parseShouldRetryHeader(response);
                   if (shouldRetry === false) {
-                    // Server says DO NOT retry — return error directly
-                    debugLog("x-should-retry: false — not retrying", { status: response.status });
+                    // Server says DO NOT retry — return error directly.
+                    // Include a snippet of the error body so 4xx causes (e.g. the
+                    // thinking-block "cannot be modified" 400, or an unsupported
+                    // manual-thinking 400 on adaptive models) are visible in debug.
+                    debugLog("x-should-retry: false — not retrying", {
+                      status: response.status,
+                      errorBody: typeof errorBody === "string" ? errorBody.slice(0, 600) : errorBody,
+                    });
                     return transformResponse(response);
                   }
 
@@ -3713,6 +3767,44 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                       continue;
                     }
 
+                    // Fast-mode pool isolation: if THIS request used speed:"fast"
+                    // and the limit is a plain rate limit, the FAST pool was
+                    // exhausted — not the account's standard quota. Per Anthropic,
+                    // fast has a separate pool and should fall back to standard
+                    // speed, NOT block the account. So: cool down only the fast
+                    // bucket, then retry on the SAME account at standard speed
+                    // (the next transformRequestBody omits speed:"fast" because
+                    // isFastRateLimited(account) is now true). We do NOT flip the
+                    // global config.fast_mode flag — other accounts/turns can still
+                    // use fast mode.
+                    const requestWasFast = typeof body === "string" && body.includes('"speed":"fast"');
+                    if (
+                      requestWasFast &&
+                      response.status === 429 &&
+                      reason === "RATE_LIMIT_EXCEEDED" &&
+                      fastFallbackCount < MAX_FAST_FALLBACKS
+                    ) {
+                      fastFallbackCount++;
+                      const fastBackoff = accountManager.markRateLimited(
+                        account,
+                        reason,
+                        retryAfterMs,
+                        RATE_LIMIT_KEY_FAST,
+                      );
+                      _fastModeAppliedToast = false;
+                      toast("⚡ Fast pool limited — falling back to standard speed", "info", {
+                        debounceKey: "fast-fallback",
+                      }).catch(() => {});
+                      debugLog("fast pool rate-limited; falling back to standard on same account", {
+                        account: account.email || `Account ${account.index + 1}`,
+                        fastBackoffMs: fastBackoff,
+                        fastFallbackCount,
+                      });
+                      // Retry same account at standard speed without consuming a slot.
+                      attempt--;
+                      continue;
+                    }
+
                     accountManager.markRateLimited(account, reason, retryAfterMs);
 
                     // On auth failures, clear token so next selection forces refresh
@@ -3724,7 +3816,10 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     // Strategy adaptation: record account-specific throttling signal
                     recordRateLimitForStrategy();
 
-                    // Graceful degradation: disable fast mode on rate limits
+                    // Graceful degradation: disable fast mode on rate limits.
+                    // Note: a fast-pool-only 429 is handled by the fast-fallback
+                    // branch above and never reaches here, so this global disable
+                    // only fires for standard-pool limits or 529 overloads.
                     if (config.fast_mode && (response.status === 429 || response.status === 529)) {
                       config.fast_mode = false;
                       _fastModeAppliedToast = false;
@@ -4372,8 +4467,40 @@ const cacheBreakState = {
   prevCacheRead: 0,
   sourceHashes: new Map(),
   lastAlertTurn: 0,
+  /**
+   * Per-boundary structural stability: how many consecutive turns each cache
+   * source ("system_prompt", "tools", "messages_prefix") has been unchanged.
+   * Used by the adaptive breakpoint placer to anchor the cache_control marker
+   * on the most-stable boundary instead of blindly on the last tool (which
+   * thrashes when the host reorders/adds tools between turns).
+   * @type {Map<string, number>}
+   */
+  boundaryStability: new Map(),
 };
 
+/**
+ * Update per-boundary stability counters by diffing the current request's cache
+ * source hashes against the previous turn's. A boundary that is unchanged gets
+ * its counter incremented; a changed (or newly-appeared) boundary resets to 0.
+ *
+ * @param {Map<string,string>} current - hashes for this turn (source -> hash)
+ * @param {Map<string,string>} previous - hashes from the prior turn
+ * @param {Map<string,number>} stability - mutated in place
+ */
+function updateBoundaryStability(current, previous, stability) {
+  for (const [source, hash] of current) {
+    if (previous.get(source) === hash) {
+      stability.set(source, (stability.get(source) || 0) + 1);
+    } else {
+      stability.set(source, 0);
+    }
+  }
+  // Drop boundaries that no longer appear so stale entries don't linger.
+  for (const source of [...stability.keys()]) {
+    if (!current.has(source)) stability.delete(source);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Microcompact state (Phase 3, Task 3.4)
 // ---------------------------------------------------------------------------
@@ -4603,6 +4730,116 @@ function tryQuotaAwareAccountSwitch(account, accountManager, config) {
  * @param {string} bodyStr - JSON request body
  * @returns {Map<string, string>} source_id → hash
  */
+/**
+ * Resolve the prompt-cache TTL for tool/message breakpoints, mirroring the
+ * decompiled Claude Code 2.1.154 `REH(querySource)` precedence.
+ *
+ * Precedence (highest first):
+ *   1. FORCE_PROMPT_CACHING_5M truthy  -> "5m"
+ *   2. ENABLE_PROMPT_CACHING_1H truthy -> "1h"
+ *   3. role-scoping on AND not the main role -> "5m" (side-queries are cheap)
+ *   4. otherwise -> configuredTtl (main interactive thread, default "1h")
+ *
+ * @param {object} args
+ * @param {string} args.configuredTtl - Default TTL when 1h is eligible (usually "1h").
+ * @param {boolean} args.roleScopedTtl - Whether role-scoped 5m downgrade is enabled.
+ * @param {boolean} args.isMainForCache - True when the request is the main/interactive role.
+ * @param {boolean} [args.isSubagent] - True when the request is an opencode subagent
+ *   (detected via the `x-parent-session-id` header). One-shot subagents prefer 5m.
+ * @param {Record<string, string | undefined>} [args.env] - Environment (defaults to process.env).
+ * @returns {string} The TTL string ("5m" or "1h"/configuredTtl).
+ */
+function resolveCacheTtl({ configuredTtl, roleScopedTtl, isMainForCache, isSubagent = false, env = process.env }) {
+  // Env overrides (exact CC REH() behavior). isTruthyEnv mirrors CC's uH().
+  if (isTruthyEnv(env.FORCE_PROMPT_CACHING_5M)) return "5m";
+  if (isTruthyEnv(env.ENABLE_PROMPT_CACHING_1H)) return "1h";
+  // Subagent requests (opencode marks them with the x-parent-session-id header)
+  // are usually one-shot, and opencode runs them sequentially with a DIFFERENT
+  // system prompt than the main thread, so they rarely re-hit a 1h cache. Prefer
+  // the cheap 5m write tier (~1.25x base) over the 1h tier (~2x base) to avoid
+  // paying the long-cache write premium on a prefix that won't be reused. Gated
+  // on the same role-scoped master switch as the side-query downgrade below.
+  if (roleScopedTtl && isSubagent) return "5m";
+  // Role-scoped downgrade: non-main (side-query) requests use the cheap 5m tier.
+  if (roleScopedTtl && !isMainForCache) return "5m";
+  return configuredTtl;
+}
+
+/**
+ * Read a single incoming request header by name (case-insensitive) from either a
+ * `Request` input or a fetch `init.headers` (Headers | array | plain object).
+ * Returns the trimmed value or null. Used to detect opencode's subagent marker
+ * `x-parent-session-id` without consuming/normalizing the full header set.
+ * @param {any} input
+ * @param {any} requestInit
+ * @param {string} name
+ * @returns {string | null}
+ */
+function getIncomingHeader(input, requestInit, name) {
+  const lower = name.toLowerCase();
+  const pick = (v) => (v != null && String(v).trim() !== "" ? String(v).trim() : null);
+  try {
+    if (input && typeof input === "object" && input.headers && typeof input.headers.get === "function") {
+      const v = pick(input.headers.get(name));
+      if (v) return v;
+    }
+  } catch {
+    // malformed Request — fall through to init.headers
+  }
+  const h = requestInit?.headers;
+  if (!h) return null;
+  try {
+    if (typeof h.get === "function") return pick(h.get(name));
+    if (Array.isArray(h)) {
+      for (const pair of h) {
+        if (Array.isArray(pair) && String(pair[0]).toLowerCase() === lower) return pick(pair[1]);
+      }
+      return null;
+    }
+    for (const [k, v] of Object.entries(h)) {
+      if (k.toLowerCase() === lower) return pick(v);
+    }
+  } catch {
+    // unexpected header shape — treat as absent
+  }
+  return null;
+}
+
+/**
+ * Decide whether to place the prompt-cache breakpoint on the last tool.
+ *
+ * Default (no stability data, or detector disabled): TRUE — exact Claude Code
+ * behavior (breakpoint on the last tool).
+ *
+ * Adaptive override: returns FALSE only when there is concrete evidence that the
+ * tool boundary is thrashing (a `tool:*` source changed within the last turn,
+ * i.e. stability 0) WHILE the system-prompt boundary is stable (unchanged for
+ * >= STABLE_TURNS turns). In that case the stable system-prompt breakpoint is a
+ * better cache anchor than a tool array that moves every turn.
+ *
+ * @param {Map<string, number> | null | undefined} stability - source -> consecutive-unchanged turns
+ * @returns {boolean} whether to stamp cache_control on the last tool
+ */
+function shouldPlaceToolBreakpoint(stability) {
+  if (!stability || stability.size === 0) return true; // no data -> CC behavior
+  const STABLE_TURNS = 2;
+  const systemStability = stability.get("system_prompt");
+  const systemIsStable = typeof systemStability === "number" && systemStability >= STABLE_TURNS;
+  if (!systemIsStable) return true; // system not proven stable -> keep CC behavior
+
+  // Is any tool boundary thrashing right now (changed within the last turn)?
+  let toolThrashing = false;
+  for (const [source, turns] of stability) {
+    if (source.startsWith("tool:") && turns === 0) {
+      toolThrashing = true;
+      break;
+    }
+  }
+  // Skip the last-tool breakpoint only when tools thrash AND system is the
+  // stable anchor. Otherwise fall back to CC behavior.
+  return !toolThrashing;
+}
+
 function extractCacheSourceHashes(bodyStr, parsedBody = undefined) {
   const hashes = new Map();
   try {
@@ -5141,6 +5378,11 @@ function forceEscalateAdaptiveContext() {
 }
 
 const MODEL_PRICING = {
+  // Opus 4.8 (launched 2026-05-28): $5/$25 per 1M (input/output), notably
+  // cheaper than 4.6/4.7. cacheRead = 0.1x input, cacheWrite = 1.25x input
+  // (Anthropic's standard 5m-write ratio).
+  "claude-opus-4-8": { input: 5.0, output: 25.0, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-4-7": { input: 15.0, output: 75.0, cacheRead: 1.5, cacheWrite: 18.75 },
   "claude-opus-4-6": { input: 15.0, output: 75.0, cacheRead: 1.5, cacheWrite: 18.75 },
   "claude-sonnet-4-6": { input: 3.0, output: 15.0, cacheRead: 0.3, cacheWrite: 3.75 },
   "claude-haiku-4-5": { input: 0.8, output: 4.0, cacheRead: 0.08, cacheWrite: 1.0 },
@@ -6247,7 +6489,7 @@ function extractFirstUserMessageText(messages) {
 const CLAUDE_CODE_BETA_FLAG = "claude-code-20250219";
 const _EFFORT_BETA_FLAG = "effort-2025-11-24";
 const _ADVANCED_TOOL_USE_BETA_FLAG = "advanced-tool-use-2025-11-20";
-const _FAST_MODE_BETA_FLAG = "fast-mode-2026-02-01";
+const FAST_MODE_BETA_FLAG = "fast-mode-2026-02-01";
 const TOKEN_COUNTING_BETA_FLAG = "token-counting-2024-11-01";
 const CLAUDE_CODE_IDENTITY_STRING = "You are Claude Code, Anthropic's official CLI for Claude.";
 const KNOWN_IDENTITY_STRINGS = new Set([
@@ -6481,6 +6723,20 @@ function isOpus47Model(model) {
   return /claude-opus-4[._-]7|opus[._-]4[._-]7/i.test(model);
 }
 
+/**
+ * Detects claude-opus-4.8 / claude-opus-4-8 model IDs.
+ * Opus 4.8 (launched 2026-05-28) is an adaptive-thinking model: manual
+ * `thinking: {type: "enabled", budget_tokens}` returns a 400 — it MUST use
+ * `thinking: {type: "adaptive"}` + the effort parameter. It also supports
+ * `speed: "fast"` (fast-mode research preview) and 1M context by default.
+ * @param {string | undefined} model
+ * @returns {boolean}
+ */
+function isOpus48Model(model) {
+  if (!model) return false;
+  return /claude-opus-4[._-]8|opus[._-]4[._-]8/i.test(model);
+}
+
 /**
  * Models eligible for the "simple system prompt" mode that real CC ships in
  * v2.1.133+ under GrowthBook flag `tengu_vellum_lantern` (or forced via
@@ -6495,7 +6751,7 @@ function isOpus47Model(model) {
  */
 function isSimpleSystemPromptEligible(model) {
   if (!model) return false;
-  if (isOpus47Model(model)) return true;
+  if (isOpus47Model(model) || isOpus48Model(model)) return true;
   // -eap suffix variant, e.g. "claude-opus-4-7-eap" or "claude-opus-4-7-eap[1m]"
   if (/-eap(?:\[|$|-)/i.test(model)) return true;
   return false;
@@ -6513,12 +6769,12 @@ function isSonnet46Model(model) {
 
 /**
  * Detects models that support adaptive thinking ({type: "adaptive"}).
- * Currently: Opus 4.6, Opus 4.7, and Sonnet 4.6.
+ * Currently: Opus 4.6, Opus 4.7, Opus 4.8, and Sonnet 4.6.
  * @param {string | undefined} body
  * @returns {boolean}
  */
 function isAdaptiveThinkingModel(model) {
-  return isOpus46Model(model) || isOpus47Model(model) || isSonnet46Model(model);
+  return isOpus46Model(model) || isOpus47Model(model) || isOpus48Model(model) || isSonnet46Model(model);
 }
 
 /**
@@ -6533,8 +6789,11 @@ function isEligibleFor1MContext(model) {
   // Explicit 1m suffix/tag in model name
   if (/(^|[-_ ])1m($|[-_ ])|context[-_]?1m|\[1m\]/i.test(model)) return true;
   // CC v2.1.97 U01: claude-sonnet-4* (any Sonnet 4.x) or opus-4-6.
-  // Opus 4.7 (successor to 4.6) is also 1M-context eligible.
-  return /claude-sonnet-4|sonnet[._-]4/i.test(model) || isOpus46Model(model) || isOpus47Model(model);
+  // Opus 4.7 / 4.8 (successors to 4.6) are also 1M-context eligible.
+  // Opus 4.8 ships with 1M context by default on the Claude API.
+  return (
+    /claude-sonnet-4|sonnet[._-]4/i.test(model) || isOpus46Model(model) || isOpus47Model(model) || isOpus48Model(model)
+  );
 }
 
 /**
@@ -7309,6 +7568,11 @@ function buildSystemPromptBlocks(system, signature) {
  * @param {string} [requestPath]
  * @param {boolean} [hasFileReferences]
  * @param {{ use1MContext?: boolean }} [adaptiveOverride] - When set, overrides the static hasOneMillionContext() check.
+ * @param {boolean} [fastModeActive] - When true, emits FAST_MODE_BETA_FLAG (fast-mode-2026-02-01).
+ *   Must be derived structurally from the already-transformed outgoing body (body.includes('"speed":"fast"')).
+ *   Only passed from the buildRequestHeaders call site (after body transform). The pre-transform
+ *   computedBetaHeader call site (index.mjs:2905) leaves this undefined so the latch never
+ *   accumulates fast-mode independently of actual body content.
  * @returns {string}
  */
 function buildAnthropicBetaHeader(
@@ -7323,6 +7587,7 @@ function buildAnthropicBetaHeader(
   adaptiveOverride,
   tokenEconomy,
   microcompactBetas, // NEW 11th param
+  fastModeActive, // NEW 12th param — see @param above
 ) {
   const incomingBetasList = incomingBeta
     .split(",")
@@ -7471,6 +7736,16 @@ function buildAnthropicBetaHeader(
     }
   }
 
+  // Fast-mode beta — the PLUGIN injects speed:"fast" into the body, not the host.
+  // Because the host never sends speed:"fast", it also never sends the matching beta.
+  // We must add it here, derived structurally from the already-transformed body so
+  // it is always in lockstep with the speed field. Added BEFORE the dedupe merge so
+  // any duplicate (e.g. via incoming passthrough) is collapsed without duplication.
+  // Unlike effort-2025-11-24 / advanced-tool-use / tool-search-tool (which arrive via
+  // incoming-header passthrough because the HOST sets those body features), fast-mode
+  // is plugin-only and requires this explicit push.
+  if (fastModeActive) betas.push(FAST_MODE_BETA_FLAG);
+
   // Merge incoming betas from the original request, filtering out host-injected
   // betas (e.g. fine-grained-tool-streaming-2025-05-14, structured-outputs-2025-11-13)
   // that OpenCode's Anthropic SDK adds but real Claude Code never sends.
@@ -7523,7 +7798,9 @@ function budgetTokensToEffort(budgetTokens) {
 
 /**
  * Normalise the `thinking` block in the request body for the target model:
- * - Opus 4.6 / Sonnet 4.6 (adaptive thinking): produces `{ type: "adaptive" }`
+ * - Opus 4.6 / 4.7 / 4.8 / Sonnet 4.6 (adaptive thinking): produces
+ *   `{ type: "adaptive" }`. This is REQUIRED for Opus 4.7/4.8 — manual
+ *   `{ type: "enabled", budget_tokens }` returns a 400 on those models.
  * - Older models: passes the existing thinking block through unchanged.
  *
  * @param {any} thinking
@@ -7656,6 +7933,14 @@ function buildRequestHeaders(
   const incomingBeta = requestHeaders.get("anthropic-beta") || "";
   const { model, tools, messages, hasFileReferences } = parseRequestBodyMetadata(requestBody);
   const provider = detectProvider(requestUrl);
+  // Detect fast mode structurally from the already-transformed body string.
+  // transformRequestBody runs before buildRequestHeaders (see index.mjs:2986 vs 3039),
+  // so speed:"fast" is already present when fast mode fired. Same detection idiom as the
+  // toast check (~line 3018). This is the correct call site for fast-mode: the
+  // computedBetaHeader call at index.mjs:2905 runs BEFORE body transform, so fastModeActive
+  // is always false/absent there, keeping the latch free of fast-mode. The
+  // requestHeaders.set("anthropic-beta", mergedBetas) call below is what reaches the wire.
+  const fastModeActive = typeof requestBody === "string" && requestBody.includes('"speed":"fast"');
   const mergedBetas = buildAnthropicBetaHeader(
     incomingBeta,
     signature.enabled,
@@ -7667,6 +7952,8 @@ function buildRequestHeaders(
     hasFileReferences,
     adaptiveOverride,
     tokenEconomy,
+    undefined, // microcompactBetas: not available at this call site (handled via computedBetaHeader path at 2905)
+    fastModeActive, // NEW 12th param: emit fast-mode-2026-02-01 beta when body contains speed:"fast"
   );
 
   const authTokenOverride = process.env.ANTHROPIC_AUTH_TOKEN?.trim();
@@ -7781,6 +8068,21 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
 
   try {
     const parsed = JSON.parse(body);
+    // Diagnostic: log the incoming model + thinking/speed shape so model-routing
+    // issues (e.g. an unrecognized fast variant, or "No available account"
+    // symptoms tied to a specific model) are observable with /anthropic set debug on.
+    // NOTE: transformRequestBody is a top-level function outside the plugin
+    // closure where debugLog() lives, so we mirror debugLog's behaviour directly
+    // (console.error + same prefix, gated on config.debug).
+    if (config?.debug) {
+      console.error("[opencode-anthropic-auth]", "transformRequestBody: incoming model", {
+        model: parsed.model,
+        adaptive: isAdaptiveThinkingModel(parsed.model || ""),
+        thinkingType: parsed.thinking?.type,
+        hasEffort: parsed.effort !== undefined || parsed.output_config?.effort !== undefined,
+        speed: parsed.speed,
+      });
+    }
     // Output cap: resolve max_tokens before any other body transforms
     if (config?.output_cap?.enabled) {
       parsed.max_tokens = resolveMaxTokens(parsed, config);
@@ -7852,10 +8154,19 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
       // Anthropic API rejects temperature when thinking is enabled
       delete parsed.temperature;
 
-      // Claude Code v2.1.84: inject context_management body field when thinking
-      // is active and context-management beta is in use. This tells the API how
-      // to handle thinking blocks during context management operations.
-      if (!parsed.context_management) {
+      // Claude Code v2.1.84: inject the context_management body field ONLY when the
+      // context-management beta is actually enabled (token_economy.context_management,
+      // the SAME flag that gates the beta in buildAnthropicBetaHeader). A top-level
+      // context_management field WITHOUT the beta is rejected by the API with
+      // "context_management: Extra inputs are not permitted". Keeping the field and
+      // the anthropic-beta header in lockstep prevents that 400 — previously the
+      // field was injected on every thinking turn regardless of the beta, which only
+      // worked if the beta happened to be forced on via custom_betas/ANTHROPIC_BETAS.
+      if (
+        config?.token_economy?.context_management &&
+        !/claude-3-/i.test(parsed.model || "") &&
+        !parsed.context_management
+      ) {
         parsed.context_management = {
           edits: [{ type: "clear_thinking_20251015", keep: "all" }],
         };
@@ -7982,9 +8293,34 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
     const modelId = parsed.model || "";
     // Extract first user message text for billing hash computation (cch)
     const firstUserMessage = extractFirstUserMessageText(parsed.messages);
+    // Resolve the prompt-cache TTL ONCE so system blocks, tools, and messages
+    // all share the SAME ttl. Anthropic processes cache_control blocks in the
+    // order tools → system → messages and rejects any ttl='1h' block that comes
+    // AFTER a ttl='5m' block. Before this fix the role-scoped 5m downgrade was
+    // applied only to tools/messages (resolveCacheTtl in the breakpoint loop)
+    // while the system blocks kept the configured 1h — so subagent requests
+    // (5m tools, then 1h system) tripped:
+    //   "system.1.cache_control.ttl: a ttl='1h' cache_control block must not
+    //    come after a ttl='5m' cache_control block".
+    // Threading it through buildSystemPromptBlocks keeps every cache_control ttl
+    // consistent (real CC derives the ttl uniformly from querySource).
+    const baseCachePolicy = signature.cachePolicy || { ttl: "1h", ttl_supported: true };
+    const cachingEnabledForTtl = baseCachePolicy.ttl !== "off" && baseCachePolicy.ttl_supported !== false;
+    const resolvedCacheTtl = cachingEnabledForTtl
+      ? resolveCacheTtl({
+          configuredTtl: baseCachePolicy.ttl || "1h",
+          roleScopedTtl: config?.token_economy?.role_scoped_cache_ttl !== false,
+          isMainForCache: runtime?.requestRole === "main" || runtime?.requestRole == null,
+          isSubagent: runtime?.isSubagent === true,
+          env: process.env,
+        })
+      : baseCachePolicy.ttl;
     const signatureWithModel = {
       ...signature,
       modelId,
+      // Override cachePolicy.ttl with the role/subagent-resolved ttl so the
+      // system blocks match the tool/message breakpoint ttl (see comment above).
+      cachePolicy: { ...baseCachePolicy, ttl: resolvedCacheTtl },
       firstUserMessage,
       antiVerbosity: config?.anti_verbosity,
       // Role-aware system-prompt leaning: for non-main-thread requests (title,
@@ -8073,31 +8409,61 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
       // our system prompt ttl=1h). Then add our own to the last user message
       // (matching real CC behavior seen in proxy capture).
       //
-      // Role-scoped TTL: real CC's MoY(querySource) gates the `ttl:"1h"` field
-      // on an allowlist of query sources (`repl_main_thread*`, `sdk`,
-      // `auto_mode`). Non-matching requests fall back to the default 5m tier
-      // — which is cheaper to write. We match this via classifyRequestRole
-      // (main → configured TTL, usually 1h; everything else → 5m).
-      const configuredTtl = signature.cachePolicy?.ttl || "1h";
-      const roleScopedTtl = config?.token_economy?.role_scoped_cache_ttl !== false;
-      const isMainForCache = runtime?.requestRole === "main" || runtime?.requestRole == null;
-      const ccTtl = roleScopedTtl && !isMainForCache ? "5m" : configuredTtl;
+      // Role-scoped TTL: real CC's REH(querySource) decides the `ttl:"1h"` field.
+      // Decompiled from CC 2.1.154 (function REH, offset 225174828), precedence:
+      //   1. FORCE_PROMPT_CACHING_5M  => 5m (highest priority)
+      //   2. ENABLE_PROMPT_CACHING_1H => 1h
+      //   3. no tengu support / overage => 5m
+      //   4. querySource ∈ allowlist [repl_main_thread*, sdk, auto_mode, ...] => 1h, else 5m
+      // We map step 4 via classifyRequestRole: main (interactive/auto_mode thread)
+      // → 1h; side-queries (title-gen, etc.) → 5m. The env vars are honored
+      // exactly as CC does, giving the user a manual override + mimicry fidelity.
+      // Reuse the request-wide resolved ttl (computed above where
+      // signatureWithModel is built) so tools/messages match the system blocks
+      // and never trip the 1h-after-5m ordering rule on subagent requests.
+      const ccTtl = resolvedCacheTtl;
       if (Array.isArray(parsed.tools) && parsed.tools.length > 0) {
         for (const tool of parsed.tools) {
           if (tool.cache_control) delete tool.cache_control;
         }
-        // Add cache_control to last tool as prompt-cache breakpoint (CC does this)
-        parsed.tools[parsed.tools.length - 1].cache_control = { type: "ephemeral", ttl: ccTtl };
+        // Adaptive breakpoint placement (opt-in, runtime-driven). Real CC always
+        // pins the breakpoint on the last tool because CC controls a STABLE tool
+        // array. opencode may reorder/add/remove tools between turns, which moves
+        // the "last tool" and invalidates the cached prefix after it. When the
+        // detector reports the tool boundary is thrashing while the system prompt
+        // is stable, we SKIP the volatile last-tool breakpoint and let the stable
+        // system-prompt breakpoint (added by buildSystemPromptBlocks) anchor the
+        // cache. Falls back to exact CC behavior when no stability data exists.
+        const placeToolBreakpoint = shouldPlaceToolBreakpoint(runtime?.cacheBoundaryStability);
+        if (placeToolBreakpoint) {
+          parsed.tools[parsed.tools.length - 1].cache_control = { type: "ephemeral", ttl: ccTtl };
+        }
       }
       if (Array.isArray(parsed.messages)) {
         for (const msg of parsed.messages) {
           if (Array.isArray(msg.content)) {
             for (const block of msg.content) {
+              // CONTRACT GUARD: `thinking` / `redacted_thinking` blocks MUST be
+              // round-tripped byte-identical to the model's original response
+              // (Anthropic extended-thinking rules). ANY mutation — including
+              // `delete block.cache_control` — triggers the 400 error
+              // "thinking or redacted_thinking blocks in the latest assistant
+              // message cannot be modified". `cache_control` is not even a valid
+              // field on a thinking block, so we never strip nor add it here;
+              // we leave the block exactly as received. This is required for
+              // adaptive-thinking models (Opus 4.6/4.7/4.8, Sonnet 4.6) on
+              // tool-continuation turns. See docs/mimese-http-header-system-prompt.md.
+              if (!block || typeof block !== "object") continue;
+              if (block.type === "thinking" || block.type === "redacted_thinking") {
+                continue;
+              }
               if (block.cache_control) delete block.cache_control;
             }
           }
         }
-        // Add cache_control to last user message (real CC does this)
+        // Add cache_control to last user message (real CC does this).
+        // (User messages never contain thinking blocks, so the guard above
+        // does not affect this breakpoint.)
         for (let i = parsed.messages.length - 1; i >= 0; i--) {
           const msg = parsed.messages[i];
           if (msg.role !== "user" || !Array.isArray(msg.content) || msg.content.length === 0) continue;
@@ -8228,12 +8594,18 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
       parsed.context_hint = { enabled: true };
     }
 
-    // Fast mode: inject speed parameter for Opus 4.6 only (v2.1.97 restriction).
-    // Real CC v2.1.97 xJ() checks: model.includes("opus-4-6") — Sonnet is NOT eligible.
-    // NOTE: Deliberately NOT extended to Opus 4.7. xJ() is a fingerprint-sensitive
-    // check tied to the exact real-CC version we mirror; blindly enabling
-    // speed:"fast" for 4.7 could diverge from real CC's behavior for that model.
-    // Revisit once a real-CC dump confirms xJ() matches opus-4-7.
+    // Fast mode: inject speed parameter for fast-mode-eligible models.
+    // Per Anthropic fast-mode docs, `speed: "fast"` (beta fast-mode-2026-02-01) is
+    // supported on Opus 4.6, Opus 4.7, and Opus 4.8 (research preview). Opus 4.7
+    // is the /fast default in real Claude Code v2.1.142+. Sonnet is NOT eligible.
+    // NOTE: switching speed invalidates system + message prompt caches (per
+    // Anthropic fast-mode docs), so only flip it deliberately.
+    // When the selected account's fast pool is cooling down (a prior fast 429),
+    // suppress speed:"fast" entirely so this turn runs at standard speed on the
+    // same account rather than re-hitting the exhausted fast pool.
+    const fastPoolAvailable = !signature.fastRateLimited;
+    const isFastModeEligibleModel = (m) =>
+      fastPoolAvailable && (isOpus46Model(m) || isOpus47Model(m) || isOpus48Model(m));
     const fastModeEnabled = signature.fastMode && !isFalsyEnv(process.env.OPENCODE_ANTHROPIC_DISABLE_FAST_MODE);
     let fastModeAutoApplied = false;
     if (
@@ -8241,7 +8613,7 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
       te.fast_mode_auto === true &&
       isMainRole &&
       parsed.model &&
-      isOpus46Model(parsed.model) &&
+      isFastModeEligibleModel(parsed.model) &&
       Array.isArray(parsed.messages) &&
       parsed.messages.length >= 2
     ) {
@@ -8264,7 +8636,7 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
         }
       }
     }
-    if ((fastModeEnabled || fastModeAutoApplied) && parsed.model && isOpus46Model(parsed.model)) {
+    if ((fastModeEnabled || fastModeAutoApplied) && parsed.model && isFastModeEligibleModel(parsed.model)) {
       parsed.speed = "fast";
     }
 
@@ -8572,6 +8944,32 @@ function stripMcpPrefixFromParsedEvent(parsed) {
   return modified;
 }
 
+/**
+ * Resolve the byte-stream idle timeout in milliseconds.
+ *
+ * Parity with Claude Code's `tengu_byte_stream_idle_timeout_ms`: a watchdog that
+ * fires when the upstream SSE stream produces no bytes for N ms, so a stalled /
+ * half-dead connection surfaces as a fast error instead of an indefinite hang.
+ *
+ * Resolution order: env `OPENCODE_ANTHROPIC_STREAM_IDLE_TIMEOUT_MS` →
+ * `config.streaming.idle_timeout_ms` → 0 (disabled). Disabled by default because
+ * a too-aggressive value could abort a legitimate long generation; Anthropic SSE
+ * emits periodic `ping` events, so a multi-minute silence is the safe signal.
+ *
+ * @param {any} cfg
+ * @returns {number} timeout in ms, or 0 to disable
+ */
+function resolveStreamIdleTimeoutMs(cfg) {
+  const envRaw = process.env.OPENCODE_ANTHROPIC_STREAM_IDLE_TIMEOUT_MS;
+  if (envRaw != null && envRaw !== "") {
+    const n = Number(envRaw);
+    if (Number.isFinite(n) && n >= 0) return Math.floor(n);
+  }
+  const c = cfg?.streaming?.idle_timeout_ms;
+  if (typeof c === "number" && Number.isFinite(c) && c >= 0) return Math.floor(c);
+  return 0;
+}
+
 /**
  * Wrap a response body stream to strip mcp_ prefix from tool names,
  * extract token usage stats from SSE events, and detect mid-stream
@@ -8592,6 +8990,10 @@ function transformResponse(response, onUsage, onAccountError) {
   const encoder = new TextEncoder();
   const EMPTY_CHUNK = new Uint8Array();
 
+  // Byte-stream idle-timeout watchdog (parity with CC tengu_byte_stream_idle_timeout_ms).
+  // 0 = disabled (default). See resolveStreamIdleTimeoutMs.
+  const idleTimeoutMs = resolveStreamIdleTimeoutMs(_pluginConfig);
+
   /** @type {UsageStats} */
   const stats = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
   let sseBuffer = "";
@@ -8671,7 +9073,38 @@ function transformResponse(response, onUsage, onAccountError) {
 
   const stream = new ReadableStream({
     async pull(controller) {
-      const { done, value } = await reader.read();
+      let readResult;
+      if (idleTimeoutMs > 0) {
+        /** @type {ReturnType<typeof setTimeout> | undefined} */
+        let idleTimer;
+        try {
+          readResult = await Promise.race([
+            reader.read(),
+            new Promise((_resolve, reject) => {
+              idleTimer = setTimeout(
+                () => reject(new Error(`stream idle timeout: no bytes for ${idleTimeoutMs}ms`)),
+                idleTimeoutMs,
+              );
+            }),
+          ]);
+        } catch (err) {
+          // Idle timeout (or read error): cancel the upstream reader and surface a
+          // clear error so the consumer can retry instead of waiting on a dead
+          // connection. Mirrors CC's stream-idle watchdog (no silent hang).
+          try {
+            await reader.cancel();
+          } catch {
+            // Reader may already be released; nothing to do.
+          }
+          controller.error(err instanceof Error ? err : new Error(String(err)));
+          return;
+        } finally {
+          clearTimeout(idleTimer);
+        }
+      } else {
+        readResult = await reader.read();
+      }
+      const { done, value } = readResult;
       if (done) {
         processSSEBuffer(true);
 
@@ -9023,6 +9456,8 @@ AnthropicAuthPlugin.__testing__ = {
   buildSystemPromptBlocks,
   stripMcpPrefixFromParsedEvent,
   CORE_TOOL_NAMES,
+  // exposed for subagent-detection tests (x-parent-session-id header extraction)
+  getIncomingHeader,
   // exposed for determinism regression tests (phase C1)
   applyContextHintCompaction,
   // exposed for session-dedupe regression tests (phase C3)
@@ -9058,4 +9493,19 @@ AnthropicAuthPlugin.__testing__ = {
   },
 };
 
+/**
+ * Internal cache helpers exposed for unit testing only. Not part of the public
+ * plugin API. Attached as a PROPERTY of the function for the SAME reason as
+ * `__testing__` above: a bare `export const __cacheInternals = {...}` object
+ * export breaks Opencode's plugin loader, which iterates `Object.values(mod)`
+ * and throws "Plugin export is not a function" on ANY non-function export —
+ * silently disabling the whole plugin (no slash command, no OAuth). Tests reach
+ * these via `AnthropicAuthPlugin.__cacheInternals`.
+ */
+AnthropicAuthPlugin.__cacheInternals = {
+  resolveCacheTtl,
+  shouldPlaceToolBreakpoint,
+  updateBoundaryStability,
+};
+
 export default AnthropicAuthPlugin;

package/lib/accounts.mjs

@@ -47,6 +47,16 @@ function hashTokenFragment(token) {
 
 const MAX_ACCOUNTS = 10;
 const RATE_LIMIT_KEY = "anthropic";
+// Fast mode (speed:"fast") has a SEPARATE rate-limit pool from standard Opus
+// per Anthropic docs. We track it under a distinct bucket so that exhausting the
+// fast pool does NOT block standard-speed requests on the same account (it should
+// only trigger a fallback to standard speed). The key lives in the same
+// rateLimitResetTimes record, so no schema migration is needed — existing
+// accounts simply won't have this key until they hit a fast-mode rate limit, and
+// #clearExpiredRateLimits already iterates all keys generically.
+const RATE_LIMIT_KEY_FAST = "anthropic:fast";
+
+export { RATE_LIMIT_KEY, RATE_LIMIT_KEY_FAST };
 
 /**
  * @typedef {object} StatsDelta
@@ -351,16 +361,29 @@ export class AccountManager {
   }
 
   /**
-   * Check if an account is currently rate-limited.
+   * Check if an account is currently rate-limited for the given bucket.
+   * Defaults to the STANDARD bucket so that a fast-only rate limit never makes
+   * an account look unavailable for standard requests.
    * @param {ManagedAccount} account
+   * @param {string} [bucket] - Rate-limit bucket key (default: standard).
    * @returns {boolean}
    */
-  #isRateLimited(account) {
+  #isRateLimited(account, bucket = RATE_LIMIT_KEY) {
     this.#clearExpiredRateLimits(account);
-    const resetTime = account.rateLimitResetTimes[RATE_LIMIT_KEY];
+    const resetTime = account.rateLimitResetTimes[bucket];
     return resetTime !== undefined && Date.now() < resetTime;
   }
 
+  /**
+   * Public check: is this account rate-limited for the fast-mode pool?
+   * Used to decide whether to inject speed:"fast" on a request.
+   * @param {ManagedAccount} account
+   * @returns {boolean}
+   */
+  isFastRateLimited(account) {
+    return this.#isRateLimited(account, RATE_LIMIT_KEY_FAST);
+  }
+
   /**
    * Select the best account for the current request.
    * @param {Set<number>} [excludedIndices] - Temporary per-request exclusions
@@ -408,27 +431,43 @@ export class AccountManager {
 
   /**
    * Mark an account as rate-limited.
+   *
+   * When `bucket` is the FAST pool (RATE_LIMIT_KEY_FAST), this is a soft marker:
+   * it only cools down the fast pool and does NOT increment consecutiveFailures
+   * or apply a health penalty, because the standard pool is still fully usable
+   * (the request can simply fall back to standard speed). Marking the whole
+   * account unhealthy for a fast-only limit would defeat Anthropic's separate
+   * fast pool and waste standard quota.
    * @param {ManagedAccount} account
    * @param {RateLimitReason} reason
    * @param {number | null} [retryAfterMs]
+   * @param {string} [bucket] - Rate-limit bucket key (default: standard).
    * @returns {number} The backoff duration in ms
    */
-  markRateLimited(account, reason, retryAfterMs) {
+  markRateLimited(account, reason, retryAfterMs, bucket = RATE_LIMIT_KEY) {
     const now = Date.now();
+    const isFastBucket = bucket === RATE_LIMIT_KEY_FAST;
 
-    // Reset consecutive failures if TTL has expired
-    if (account.lastFailureTime !== null && now - account.lastFailureTime > this.#config.failure_ttl_seconds * 1000) {
-      account.consecutiveFailures = 0;
-    }
+    if (!isFastBucket) {
+      // Reset consecutive failures if TTL has expired
+      if (account.lastFailureTime !== null && now - account.lastFailureTime > this.#config.failure_ttl_seconds * 1000) {
+        account.consecutiveFailures = 0;
+      }
 
-    account.consecutiveFailures += 1;
-    account.lastFailureTime = now;
+      account.consecutiveFailures += 1;
+      account.lastFailureTime = now;
+    }
 
-    const backoffMs = calculateBackoffMs(reason, account.consecutiveFailures - 1, retryAfterMs);
+    // Fast bucket does not track consecutiveFailures, so use index 0 to avoid a
+    // negative array index in calculateBackoffMs (QUOTA_EXHAUSTED path).
+    const failureIndex = isFastBucket ? 0 : account.consecutiveFailures - 1;
+    const backoffMs = calculateBackoffMs(reason, failureIndex, retryAfterMs);
 
-    account.rateLimitResetTimes[RATE_LIMIT_KEY] = now + backoffMs;
+    account.rateLimitResetTimes[bucket] = now + backoffMs;
 
-    this.#healthTracker.recordRateLimit(account.index);
+    if (!isFastBucket) {
+      this.#healthTracker.recordRateLimit(account.index);
+    }
 
     this.requestSaveToDisk();
 

package/lib/accounts.test.mjs

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { AccountManager } from "./accounts.mjs";
+import { AccountManager, RATE_LIMIT_KEY_FAST } from "./accounts.mjs";
 import { DEFAULT_CONFIG } from "./config.mjs";
 
 // Mock storage module — pass through pure helpers, mock I/O
@@ -331,6 +331,41 @@ describe("AccountManager rate limiting", () => {
     manager.markRateLimited(account, "RATE_LIMIT_EXCEEDED", null);
     expect(account.consecutiveFailures).toBe(1); // Reset to 0, then +1
   });
+
+  // ── Fast-mode pool isolation (Anthropic: fast has a SEPARATE rate-limit pool) ──
+  it("fast-bucket rate limit does NOT block standard requests on the same account", () => {
+    const account = manager.getCurrentAccount();
+    manager.markRateLimited(account, "RATE_LIMIT_EXCEEDED", null, RATE_LIMIT_KEY_FAST);
+    // Fast pool is limited...
+    expect(manager.isFastRateLimited(account)).toBe(true);
+    // ...but the account is still selectable for standard requests (standard
+    // bucket untouched, so getCurrentAccount still returns it).
+    expect(manager.getCurrentAccount()).not.toBeNull();
+  });
+
+  it("fast-bucket rate limit does NOT increment consecutiveFailures or set lastFailureTime", () => {
+    const account = manager.getCurrentAccount();
+    manager.markRateLimited(account, "RATE_LIMIT_EXCEEDED", null, RATE_LIMIT_KEY_FAST);
+    expect(account.consecutiveFailures).toBe(0);
+    expect(account.lastFailureTime).toBeNull();
+    expect(manager.isFastRateLimited(account)).toBe(true);
+  });
+
+  it("standard rate limit does NOT mark the fast bucket as limited", () => {
+    const account = manager.getCurrentAccount();
+    manager.markRateLimited(account, "RATE_LIMIT_EXCEEDED", null);
+    expect(manager.isFastRateLimited(account)).toBe(false);
+  });
+
+  it("fast-bucket backoff returns a positive duration and expires independently", () => {
+    const account = manager.getCurrentAccount();
+    const backoffMs = manager.markRateLimited(account, "RATE_LIMIT_EXCEEDED", null, RATE_LIMIT_KEY_FAST);
+    expect(backoffMs).toBeGreaterThan(0);
+    expect(manager.isFastRateLimited(account)).toBe(true);
+    // After the backoff expires, the fast pool is available again.
+    vi.advanceTimersByTime(backoffMs + 1000);
+    expect(manager.isFastRateLimited(account)).toBe(false);
+  });
 });
 
 // ---------------------------------------------------------------------------

package/lib/config.mjs

@@ -97,7 +97,7 @@ import { randomBytes } from "node:crypto";
  * @property {{ enabled: boolean, default_max_tokens: number, escalated_max_tokens: number }} output_cap
  * @property {{ enabled: boolean, timeout_ms: number }} preconnect
  * @property {{ enabled: boolean, safety_margin: number }} overflow_recovery
- * @property {{ enabled: boolean, alert_threshold: number }} cache_break_detection
+ * @property {{ enabled: boolean, alert_threshold: number, adaptive_breakpoint: boolean }} cache_break_detection
  * @property {{ enabled: boolean, background_max_service_retries: number, background_max_should_retries: number }} request_classification
  * @property {{ enabled: boolean, default: number, completion_threshold: number }} token_budget
  * @property {{ enabled: boolean, threshold_percent: number }} microcompact
@@ -191,6 +191,16 @@ export const DEFAULT_CONFIG = {
      *  (no point suggesting reset at the start of a session). */
     min_turns_before_suggest: 3,
   },
+  /** SSE response streaming behavior. */
+  streaming: {
+    /** Byte-stream idle-timeout watchdog (ms). Parity with Claude Code's
+     *  `tengu_byte_stream_idle_timeout_ms`: if the upstream produces no bytes for
+     *  this long, the reader is cancelled and the stream errors instead of hanging.
+     *  0 = disabled (default — Anthropic SSE sends periodic pings, so only set a
+     *  multi-minute value to catch genuinely dead connections). Env override:
+     *  `OPENCODE_ANTHROPIC_STREAM_IDLE_TIMEOUT_MS`. */
+    idle_timeout_ms: 0,
+  },
   /** Token economy optimizations. */
   token_economy: {
     /** [DEPRECATED] token-efficient-tools-2026-03-28 was removed in CC v2.1.90.
@@ -276,15 +286,18 @@ export const DEFAULT_CONFIG = {
      *  `ttl:"1h"` on an allowlist of query sources (`repl_main_thread*`, `sdk`,
      *  `auto_mode`). Everything else falls back to the 5m tier, which is
      *  cheaper to write. Matches by classifying request role: main → 1h (or
-     *  whatever signature.cachePolicy.ttl is configured as), else → 5m. */
-    role_scoped_cache_ttl: false,
+     *  whatever signature.cachePolicy.ttl is configured as), else → 5m.
+     *  Default ON: this MATCHES real CC behaviour (main thread 1h, side-queries
+     *  5m) and only makes non-main cache writes cheaper — no fingerprint risk. */
+    role_scoped_cache_ttl: true,
 
     /** Lean system prompt for non-main requests. For title-gen / small /
      *  subagent-shaped requests, strip billing identity + CC identity
-     *  injection. Saves ~1-2kB per request. Opt-in: changes the system-prompt
-     *  shape that downstream observers (billing/telemetry) may rely on, so
-     *  enable deliberately rather than by default. */
-    lean_system_non_main: false,
+     *  injection. Saves ~1-2kB per request. Default ON: only affects non-main
+     *  (title-gen / subagent) requests where the CC identity/billing block is
+     *  not load-bearing for the main-thread fingerprint; the main interactive
+     *  thread is untouched. */
+    lean_system_non_main: true,
 
     /** Simple system prompt mode (real CC v2.1.133+ `tengu_vellum_lantern`
      *  equivalent). When enabled AND the request model is eligible
@@ -294,8 +307,11 @@ export const DEFAULT_CONFIG = {
      *  Conservative implementation: gates ONLY anti-verbosity. Identity
      *  preamble, billing block, user instructions, and `<system-reminder>`
      *  blocks are all preserved so the CC fingerprint match still holds.
-     *  Saves ~600-1500 tokens per request on eligible models. Opt-in. */
-    simple_system_prompt: false,
+     *  Saves ~600-1500 tokens per request on eligible models. Default ON:
+     *  gates ONLY the anti-verbosity boilerplate (which real CC v2.1.133+ also
+     *  drops for eligible Opus 4.x via tengu_vellum_lantern); identity, billing
+     *  and system-reminders are preserved, so the fingerprint match holds. */
+    simple_system_prompt: true,
 
     // NOTE: identical-tool-call short-circuit was considered but requires SSE
     // response-stream rewriting that breaks normal tool-execution semantics.
@@ -361,6 +377,17 @@ export const DEFAULT_CONFIG = {
   cache_break_detection: {
     enabled: true,
     alert_threshold: 2_000,
+    /**
+     * Adaptive breakpoint placement (opt-in). When true, the prompt-cache
+     * breakpoint is anchored on the most-stable boundary (e.g. the system
+     * prompt) instead of always on the last tool. This is a DELIBERATE
+     * divergence from Claude Code, useful for hosts (like opencode) whose tool
+     * array order/count is less stable than CC's. Default true (opencode's tool
+     * presentation is less stable than CC's, so adaptive anchoring improves cache
+     * hit rate). Set false to force exact CC behavior. Safe either way: with no
+     * stability baseline (first turns) it falls back to CC's last-tool breakpoint.
+     */
+    adaptive_breakpoint: true,
   },
   /** Request classification: reduced retry budget for background requests. */
   request_classification: {
@@ -885,6 +912,10 @@ function validateConfig(raw) {
         1_000_000,
         DEFAULT_CONFIG.cache_break_detection.alert_threshold,
       ),
+      adaptive_breakpoint:
+        typeof cbd.adaptive_breakpoint === "boolean"
+          ? cbd.adaptive_breakpoint
+          : DEFAULT_CONFIG.cache_break_detection.adaptive_breakpoint,
     };
   }
 

package/lib/request-headers.mjs

@@ -16,9 +16,15 @@
 // Version / build / SDK constants
 // ---------------------------------------------------------------------------
 
-export const FALLBACK_CLAUDE_CLI_VERSION = "2.1.150";
+export const FALLBACK_CLAUDE_CLI_VERSION = "2.1.159";
 export const CLAUDE_CODE_NPM_LATEST_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
-export const CLAUDE_CODE_BUILD_TIME = "2026-05-15T17:39:39Z";
+// Real build markers extracted from the 2.1.159 linux-x64 native binary
+// (Bun-embedded JS): `BUILD_TIME:"2026-05-31T16:22:50Z"`,
+// `GIT_SHA:"dd8c11fc8d05cea0b2b9fc8f5a99a5c5c5dffc9b"`.
+// (Prior 2.1.154 win32-x64: BUILD_TIME 2026-05-28T12:27:24Z,
+//  GIT_SHA b84d2da9ada13121515426fc644786a303e9ac53.)
+export const CLAUDE_CODE_BUILD_TIME = "2026-05-31T16:22:50Z";
+export const CLAUDE_CODE_GIT_SHA = "dd8c11fc8d05cea0b2b9fc8f5a99a5c5c5dffc9b";
 
 // The @anthropic-ai/sdk version bundled with Claude Code.
 // This is distinct from the CLI version and goes in X-Stainless-Package-Version.
@@ -32,6 +38,22 @@ export const ANTHROPIC_SDK_VERSION = "0.94.0";
 
 // Map of CLI version to bundled SDK version (update when CLI version changes)
 export const CLI_TO_SDK_VERSION = new Map([
+  // 2.1.155-2.1.159: only wire change is the revival of
+  // summarize-connector-text-2026-03-13 (label narration_summaries), gated by
+  // GrowthBook pewter_owl_header (default-off) — not always-on. SDK still 0.94.0
+  // (binary-verified: x-stainless-package-version NQ="0.94.0" in 2.1.159).
+  ["2.1.159", "0.94.0"],
+  ["2.1.158", "0.94.0"],
+  ["2.1.157", "0.94.0"],
+  ["2.1.156", "0.94.0"],
+  ["2.1.155", "0.94.0"],
+  // 2.1.151-2.1.154: Opus 4.8 launch (2026-05-28). npm now ships a native
+  // binary (no JS bundle), so the bundled SDK version can't be string-extracted;
+  // no SDK bump was observed across 2.1.150->2.1.154, so we carry 0.94.0 forward.
+  ["2.1.154", "0.94.0"],
+  ["2.1.153", "0.94.0"],
+  ["2.1.152", "0.94.0"],
+  ["2.1.151", "0.94.0"],
   ["2.1.150", "0.94.0"],
   ["2.1.143", "0.81.0"],
   ["2.1.142", "0.81.0"],
@@ -114,6 +136,9 @@ export const EXPERIMENTAL_BETA_FLAGS = new Set([
   "advisor-tool-2026-03-01",
   "afk-mode-2026-01-31",
   "cache-diagnosis-2026-04-07",
+  // CCR bring-your-own-cloud beta. Registered in the 2.1.154 binary's _W() table
+  // but not emitted on /v1/messages; kept here for the disable-experimental guard.
+  "ccr-byoc-2025-07-29",
   "code-execution-2025-08-25",
   "compact-2026-01-12",
   "context-1m-2025-08-07",
@@ -124,6 +149,9 @@ export const EXPERIMENTAL_BETA_FLAGS = new Set([
   "fast-mode-2026-02-01",
   "files-api-2025-04-14",
   "interleaved-thinking-2025-05-14",
+  // Registered in the 2.1.154 binary's _W() table (mcp_servers label). Plugin
+  // proxies MCP tool calls inline and does not emit this on chat completions.
+  "mcp-servers-2025-12-04",
   // Registered in CC v2.1.143 but NOT in real CC's always-on emission set
   // (master registry only, not in the always-on subset). Likely GrowthBook-gated
   // pending server rollout. Paired telemetry: tengu_mid_conv_system_fallback_retry.
@@ -131,6 +159,11 @@ export const EXPERIMENTAL_BETA_FLAGS = new Set([
   "prompt-caching-scope-2026-01-05",
   "redact-thinking-2026-02-12",
   "structured-outputs-2025-12-15",
+  // Revived in CC 2.1.159 as registry label `narration_summaries` (it was a dead
+  // slot from v2.1.90-2.1.154). Real CC emits it only when GrowthBook flag
+  // `pewter_owl_header` is on (default-off), first-party, and NOT in fast-mode.
+  // Listed here for the disable-guard + manual opt-in ONLY; never emitted always-on.
+  "summarize-connector-text-2026-03-13",
   "task-budgets-2026-03-13",
   "tool-search-tool-2025-10-19",
   // SDK admin route beta (used for /v1/user_profiles* endpoints). Registered for
@@ -172,6 +205,9 @@ export const BETA_SHORTCUTS = new Map([
   ["advisor-tool", "advisor-tool-2026-03-01"],
   ["mcp-servers", "mcp-servers-2025-12-04"],
   ["ccr-byoc", "ccr-byoc-2025-07-29"],
+  ["connector-text", "summarize-connector-text-2026-03-13"],
+  ["narration-summaries", "summarize-connector-text-2026-03-13"],
+  ["summarize-connector-text", "summarize-connector-text-2026-03-13"],
 ]);
 
 // ---------------------------------------------------------------------------

package/lib/request-headers.test.mjs

@@ -13,8 +13,8 @@ import {
 } from "./request-headers.mjs";
 
 describe("request-headers constants", () => {
-  it("FALLBACK_CLAUDE_CLI_VERSION is 2.1.150", () => {
-    expect(FALLBACK_CLAUDE_CLI_VERSION).toBe("2.1.150");
+  it("FALLBACK_CLAUDE_CLI_VERSION is 2.1.159", () => {
+    expect(FALLBACK_CLAUDE_CLI_VERSION).toBe("2.1.159");
   });
 
   it("ANTHROPIC_SDK_VERSION matches expected value", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "license": "GPL-3.0-or-later",
   "repository": {
     "type": "git",