opencode-anthropic-fix 0.1.32 → 0.2.0

package/index.mjs

@@ -37,6 +37,62 @@ import {
 import { callHaiku } from "./lib/haiku-call.mjs";
 import { summarize as rollingSummarize } from "./lib/rolling-summarizer.mjs";
 import { staleReadEviction, perToolClassPrune } from "./lib/message-transform.mjs";
+import {
+  estimatePromptTokensFromParsed,
+  applySessionToolResultDedupe,
+  maybeApplySessionToolResultDedupe,
+  applyContextHintCompaction,
+} from "./lib/token-economy/transforms.mjs";
+import { shouldMicrocompact, buildMicrocompactBetas } from "./lib/token-economy/microcompact.mjs";
+import { redactSecrets, redactString } from "./lib/redact.mjs";
+import {
+  createTransformedSSEStream,
+  resolveStreamIdleTimeoutMs,
+  stripMcpPrefixFromParsedEvent,
+} from "./lib/mimicry/response-stream.mjs";
+import { transformRequestBody, CORE_TOOL_NAMES } from "./lib/mimicry/request-body.mjs";
+import { isFalsyEnv, isTruthyEnv } from "./lib/env.mjs";
+import { sessionMetrics, createInitialSessionMetrics, getAverageCacheHitRate } from "./lib/session-metrics.mjs";
+import { repairOrphanedToolUseBlocks } from "./lib/mimicry/request-helpers.mjs";
+import { resolveCacheTtl, shouldPlaceToolBreakpoint, updateBoundaryStability } from "./lib/mimicry/cache.mjs";
+import { SERVICE_WIDE_MAX_RETRIES, CONSECUTIVE_529_FALLBACK_THRESHOLD } from "./lib/tuning.mjs";
+import {
+  computeServiceRetrySleepMs,
+  selectFallbackModel,
+  shouldServiceRetry,
+  isTransientRateLimit,
+} from "./lib/retry/overload-loop.mjs";
+import {
+  buildRequestHeaders,
+  buildAnthropicBetaHeader,
+  parseRequestBodyMetadata,
+  detectProvider,
+  extractFileIds,
+} from "./lib/mimicry/headers.mjs";
+import {
+  buildSystemPromptBlocks,
+  compactSystemText,
+  compactToolDescription,
+  dedupeSystemBlocks,
+  getCachedCCPrompt,
+  isTitleGeneratorSystemBlocks,
+  normalizeSystemTextBlocks,
+  resetCachedCCPrompt,
+  sanitizeSystemText,
+  CLAUDE_CODE_IDENTITY_STRING,
+  SUBAGENT_CC_ANCHOR,
+} from "./lib/mimicry/system-prompt.mjs";
+import {
+  CLAUDE_3_MODEL_RE,
+  hasOneMillionContext,
+  isEligibleFor1MContext,
+  isOpus46Model,
+  isOpus47Model,
+  isOpus48Model,
+  isSonnet46Model,
+} from "./lib/mimicry/models.mjs";
+
+export { isFable5Model, isMythos5Model, isAdaptiveThinkingModel } from "./lib/mimicry/models.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
@@ -2658,7 +2714,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
               const maxServiceRetries =
                 requestClass === "background"
                   ? (config.request_classification?.background_max_service_retries ?? 0)
-                  : 2;
+                  : SERVICE_WIDE_MAX_RETRIES;
               const maxShouldRetries =
                 requestClass === "background" ? (config.request_classification?.background_max_should_retries ?? 1) : 3;
               let _adaptiveDecisionMade = false; // Ensure adaptive context decision is made only once per logical request
@@ -3095,12 +3151,14 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                 // mutates system[0] each turn, invalidating the prompt cache.
                 const finalBody = body;
 
+                const correlationId = createDebugCorrelationId();
+
                 // Opt-in: dump the OUTGOING body (post-cch) so diagnostics reflect
                 // exactly what went on the wire. Previously dumped `body` which
                 // still had the cch=00000 placeholder — that confused debugging.
                 // Rotates at 10 files to cap disk usage. Files live under
                 // ~/.opencode/opencode-anthropic-fix/request-dumps/.
-                if (config.token_economy?.debug_dump_bodies === true && typeof finalBody === "string") {
+                if (isDebugSinkEnabled(config, "body") && typeof finalBody === "string") {
                   try {
                     const fs = await import("node:fs");
                     const path = await import("node:path");
@@ -3116,7 +3174,8 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                       fs.unlinkSync(path.join(dir, existing.shift()));
                     }
                     const ts = new Date().toISOString().replace(/[:.]/g, "-");
-                    fs.writeFileSync(path.join(dir, `req-${ts}.json`), finalBody);
+                    const dump = createDebugRequestDump(correlationId, ts, finalBody);
+                    fs.writeFileSync(path.join(dir, dump.filename), dump.content);
                   } catch {
                     // Disk full, permissions, whatever — never block the request.
                   }
@@ -3125,6 +3184,23 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                 // Execute the request
                 let response;
                 try {
+                  if (isDebugSinkEnabled(config, "headers")) {
+                    try {
+                      const { existsSync, renameSync, statSync, unlinkSync, writeFileSync } = await import("node:fs");
+                      const { join } = await import("node:path");
+                      const debugFile = join(getConfigDir(), "debug-headers.log");
+                      const rotatedFile = `${debugFile}.1`;
+                      if (existsSync(debugFile) && statSync(debugFile).size > 2 * 1024 * 1024) {
+                        if (existsSync(rotatedFile)) unlinkSync(rotatedFile);
+                        renameSync(debugFile, rotatedFile);
+                      }
+                      const ts = new Date().toISOString();
+                      const entry = createDebugOutgoingHeadersEntry(correlationId, ts, requestHeaders);
+                      writeFileSync(debugFile, entry, { flag: "a" });
+                    } catch (e) {
+                      debugLog("failed to write outgoing request headers to debug-headers.log", e);
+                    }
+                  }
                   response = await fetch(requestInput, {
                     ...requestInit,
                     body: finalBody,
@@ -3183,7 +3259,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
 
                 // Debug: log all response headers to file for diagnosis
                 // Placed BEFORE the response.ok guard so we capture headers on ALL responses
-                if (config.debug) {
+                if (isDebugSinkEnabled(config, "headers")) {
                   const rlHeaders = {};
                   const allHeaders = {};
                   response.headers.forEach((value, key) => {
@@ -3192,6 +3268,8 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                       rlHeaders[key] = value;
                     }
                   });
+                  const redactedRlHeaders = redactSecrets(rlHeaders);
+                  const redactedAllHeaders = redactSecrets(allHeaders);
                   debugLog(
                     "response status:",
                     response.status,
@@ -3202,19 +3280,24 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     "accountManager:",
                     !!accountManager,
                   );
-                  debugLog("ALL response headers:", allHeaders);
+                  debugLog("ALL response headers:", redactedAllHeaders);
                   // Write to file for reliable access
                   try {
-                    const { writeFileSync } = await import("node:fs");
+                    const { existsSync, renameSync, statSync, unlinkSync, writeFileSync } = await import("node:fs");
                     const { join } = await import("node:path");
                     const debugFile = join(getConfigDir(), "debug-headers.log");
+                    const rotatedFile = `${debugFile}.1`;
+                    if (existsSync(debugFile) && statSync(debugFile).size > 2 * 1024 * 1024) {
+                      if (existsSync(rotatedFile)) unlinkSync(rotatedFile);
+                      renameSync(debugFile, rotatedFile);
+                    }
                     const ts = new Date().toISOString();
-                    const entry = [
-                      `\n=== ${ts} | status=${response.status} ok=${response.ok} account=${!!account} mgr=${!!accountManager} ===`,
-                      `Rate-limit headers: ${JSON.stringify(rlHeaders, null, 2)}`,
-                      `All headers: ${JSON.stringify(allHeaders, null, 2)}`,
-                      "",
-                    ].join("\n");
+                    const entry = createDebugResponseHeadersEntry(correlationId, ts, response, {
+                      account: !!account,
+                      accountManager: !!accountManager,
+                      rateLimitHeaders: redactedRlHeaders,
+                      allHeaders: redactedAllHeaders,
+                    });
                     writeFileSync(debugFile, entry, { flag: "a" });
                   } catch (e) {
                     debugLog("failed to write debug-headers.log", e);
@@ -3722,7 +3805,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                       status: response.status,
                       errorBody: typeof errorBody === "string" ? errorBody.slice(0, 600) : errorBody,
                     });
-                    return transformResponse(response);
+                    return transformResponse(response, undefined, undefined, correlationId);
                   }
 
                   const accountSpecific = isAccountSpecificError(response.status, errorBody);
@@ -3754,13 +3837,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     // Transient 429: short retry-after (<=10s) is a burst throttle.
                     // Retry on the SAME account instead of rotating — avoids wasting
                     // the account pool on momentary rate spikes.
-                    if (
-                      response.status === 429 &&
-                      reason === "RATE_LIMIT_EXCEEDED" &&
-                      retryAfterMs != null &&
-                      retryAfterMs > 0 &&
-                      retryAfterMs <= TRANSIENT_RETRY_THRESHOLD_MS
-                    ) {
+                    if (isTransientRateLimit(response.status, reason, retryAfterMs, TRANSIENT_RETRY_THRESHOLD_MS)) {
                       debugLog("transient 429: sleeping before same-account retry", {
                         retryAfterMs,
                         account: account.email || `Account ${account.index + 1}`,
@@ -3851,26 +3928,19 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
 
                   // 529 (overloaded) and 503 (service unavailable) — brief sleep-and-retry
                   // per RE doc u00a75.5 (Stainless SDK retries 500+ codes up to maxServiceRetries times)
-                  if (
-                    (response.status === 529 || response.status === 503) &&
-                    serviceWideRetryCount < maxServiceRetries
-                  ) {
+                  if (shouldServiceRetry(response.status, serviceWideRetryCount, maxServiceRetries)) {
                     serviceWideRetryCount++;
 
                     // Track consecutive 529s for model fallback
                     if (response.status === 529) {
                       consecutive529Count++;
-                      if (consecutive529Count >= 3 && requestInit.body) {
+                      if (consecutive529Count >= CONSECUTIVE_529_FALLBACK_THRESHOLD && requestInit.body) {
                         try {
                           // QA fix: parse from requestInit.body (pre-transform) to avoid
                           // double-transformation (mcp_ prefix, system blocks, metadata).
                           const parsedForFallback = JSON.parse(requestInit.body);
                           const currentModel = parsedForFallback.model || "";
-                          let fallbackModel = null;
-                          if (/opus-4-6|opus-4/i.test(currentModel))
-                            fallbackModel = currentModel.replace(/opus/i, "sonnet");
-                          else if (/sonnet-4-6|sonnet-4/i.test(currentModel))
-                            fallbackModel = currentModel.replace(/sonnet/i, "haiku");
+                          const fallbackModel = selectFallbackModel(currentModel);
 
                           if (fallbackModel) {
                             parsedForFallback.model = fallbackModel;
@@ -3895,9 +3965,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                       consecutive529Count = 0;
                     }
 
-                    const baseDelay = Math.min(0.5 * Math.pow(2, serviceWideRetryCount), 3);
-                    const jitter = 1 - Math.random() * 0.25;
-                    const sleepMs = Math.round(baseDelay * jitter * 1000);
+                    const sleepMs = computeServiceRetrySleepMs(serviceWideRetryCount);
                     const retryLabel = response.status === 529 ? "overloaded" : "unavailable";
                     debugLog(`service-wide ${retryLabel} error, sleeping before retry`, {
                       status: response.status,
@@ -3963,7 +4031,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                       status: response.status,
                     });
                   }
-                  return transformResponse(response);
+                  return transformResponse(response, undefined, undefined, correlationId);
                 }
 
                 // Success
@@ -4149,7 +4217,17 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     }
                   : null;
 
-                return transformResponse(response, usageCallback, accountErrorCallback);
+                return transformResponse(
+                  response,
+                  usageCallback
+                    ? (stats) => {
+                        usageCallback(stats);
+                        if (stats.lastStopReason) sessionMetrics.lastStopReason = stats.lastStopReason;
+                      }
+                    : null,
+                  accountErrorCallback,
+                  correlationId,
+                );
               }
 
               // All accounts tried
@@ -4375,63 +4453,63 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
 // Session-level cache & cost tracking (Phase 4)
 // ---------------------------------------------------------------------------
 
-/** @type {{turns: number, totalInput: number, totalOutput: number, totalCacheRead: number, totalCacheWrite: number, totalWebSearchRequests: number, recentCacheRates: number[], sessionCostUsd: number, costBreakdown: {input: number, output: number, cacheRead: number, cacheWrite: number}, sessionStartTime: number, lastQuota: {tokens: number, requests: number, inputTokens: number, updatedAt: number, fiveHour: {utilization: number, resets_at: string|null, status: string|null, surpassedThreshold: number|null}, sevenDay: {utilization: number, resets_at: string|null, status: string|null, surpassedThreshold: number|null}, overallStatus: string|null, representativeClaim: string|null, fallback: string|null, fallbackPercentage: number|null, overageStatus: string|null, overageReason: string|null, lastPollAt: number}, lastStopReason: string | null, perModel: Record<string, {input: number, output: number, cacheRead: number, cacheWrite: number, costUsd: number, turns: number}>, lastModelId: string | null, lastRequestBody: string | null, tokenBudget: {limit: number, used: number, continuations: number, outputHistory: number[]}}} */
 /** Module-level config ref for functions outside AnthropicAuthPlugin closure. */
 let _pluginConfig = null;
 
-/**
- * Factory for the initial sessionMetrics shape. Returns a fresh object each
- * call so the reset helper (and any future test hook) doesn't alias nested
- * state (lastQuota, perModel, costBreakdown, tokenBudget, usedTools Set).
- * Keep this in sync with the type annotation above.
- */
-function createInitialSessionMetrics() {
+const _debugSessionId = randomUUID().slice(0, 8);
+let _debugReqSeq = 0;
+
+export function createDebugCorrelationId() {
+  return `${_debugSessionId}-${(++_debugReqSeq).toString(36).padStart(4, "0")}`;
+}
+
+export function isDebugSinkEnabled(config, sink) {
+  return sink === "body" ? config.token_economy?.debug_dump_bodies === true : Boolean(config.debug);
+}
+
+export function createDebugRequestDump(correlationId, timestamp, finalBody) {
   return {
-    turns: 0,
-    totalInput: 0,
-    totalOutput: 0,
-    totalCacheRead: 0,
-    totalCacheWrite: 0,
-    totalWebSearchRequests: 0,
-    recentCacheRates: [], // rolling window of last 5 turns
-    sessionCostUsd: 0,
-    costBreakdown: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    sessionStartTime: Date.now(),
-    lastQuota: {
-      tokens: 0,
-      requests: 0,
-      inputTokens: 0,
-      updatedAt: 0,
-      // Window-based unified headers from response
-      fiveHour: { utilization: 0, resets_at: null, status: null, surpassedThreshold: null },
-      sevenDay: { utilization: 0, resets_at: null, status: null, surpassedThreshold: null },
-      // Overall/fallback/overage from response headers
-      overallStatus: null,
-      representativeClaim: null,
-      fallback: null,
-      fallbackPercentage: null,
-      overageStatus: null,
-      overageReason: null,
-      // Usage endpoint polling (A6)
-      lastPollAt: 0,
-    },
-    lastStopReason: null, // tracks most recent stop_reason for output cap escalation
-    perModel: {}, // Map<modelId, { input, output, cacheRead, cacheWrite, costUsd, turns }>
-    lastModelId: null,
-    lastRequestBody: null, // Last intercepted request body (JSON string, capped 2MB) for /anthropic context
-    /** Token budget tracking (A9) */
-    tokenBudget: {
-      limit: 0, // 0 = unset
-      used: 0, // accumulated output tokens
-      continuations: 0,
-      outputHistory: [], // last 5 output token deltas
-    },
-    /** Tools used in this session (populated from assistant tool_use blocks in messages) */
-    usedTools: new Set(),
+    filename: `req-${timestamp}-${correlationId}.json`,
+    content: JSON.stringify({ correlationId, timestamp, bodyRedacted: redactString(finalBody) }),
   };
 }
 
-const sessionMetrics = createInitialSessionMetrics();
+async function writeSseCapture(correlationId, buf, truncated) {
+  const fs = await import("node:fs");
+  const path = await import("node:path");
+  const os = await import("node:os");
+  const dir = path.join(os.homedir(), ".opencode", "opencode-anthropic-fix", "request-dumps");
+  fs.mkdirSync(dir, { recursive: true });
+  const existing = fs
+    .readdirSync(dir)
+    .filter((f) => f.startsWith("res-") && f.endsWith(".sse"))
+    .sort();
+  while (existing.length >= 10) {
+    fs.unlinkSync(path.join(dir, existing.shift()));
+  }
+  const ts = new Date().toISOString().replace(/[:.]/g, "-");
+  fs.writeFileSync(
+    path.join(dir, `res-${ts}-${correlationId}.sse`),
+    redactString(buf) + (truncated ? "\n[capture truncated at 256KB]" : ""),
+  );
+}
+
+export function createDebugOutgoingHeadersEntry(correlationId, timestamp, requestHeaders) {
+  return [
+    `\n=== ${timestamp} | corr=${correlationId} | OUTGOING request headers ===`,
+    JSON.stringify(redactSecrets(requestHeaders), null, 2),
+    "",
+  ].join("\n");
+}
+
+export function createDebugResponseHeadersEntry(correlationId, timestamp, response, debugHeaders) {
+  return [
+    `\n=== ${timestamp} | corr=${correlationId} | status=${response.status} ok=${response.ok} account=${debugHeaders.account} mgr=${debugHeaders.accountManager} ===`,
+    `Rate-limit headers: ${JSON.stringify(debugHeaders.rateLimitHeaders, null, 2)}`,
+    `All headers: ${JSON.stringify(debugHeaders.allHeaders, null, 2)}`,
+    "",
+  ].join("\n");
+}
 
 // ---------------------------------------------------------------------------
 // Adaptive 1M context state
@@ -4482,29 +4560,6 @@ const cacheBreakState = {
   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)
 // ---------------------------------------------------------------------------
@@ -4518,31 +4573,6 @@ const microcompactState = {
   lastActivatedTurn: 0,
 };
 
-/**
- * Determine if microcompact betas should be injected based on estimated token usage.
- * @param {number} estimatedTokens - Estimated prompt token count
- * @param {object} config - Plugin config
- * @returns {boolean}
- */
-function shouldMicrocompact(estimatedTokens, config) {
-  if (!config.microcompact?.enabled) return false;
-  const thresholdPct = config.microcompact.threshold_percent ?? 80;
-  // Use the model's context window. Default to 200K if unknown.
-  // Adaptive context may escalate to 1M, but we use the base 200K for threshold
-  // to be conservative (microcompact at 160K tokens is still valuable).
-  const contextWindow = 200_000;
-  const threshold = contextWindow * (thresholdPct / 100);
-  return estimatedTokens >= threshold;
-}
-
-/**
- * Build the list of microcompact betas to inject.
- * @returns {string[]} Array of beta flag strings
- */
-function buildMicrocompactBetas() {
-  return ["clear_tool_uses_20250919", "clear_thinking_20251015"];
-}
-
 /**
  * Hash a string for cache source fingerprinting.
  * @param {string} content
@@ -4734,41 +4764,6 @@ 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).
@@ -4809,41 +4804,6 @@ function getIncomingHeader(input, requestInit, name) {
   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 {
@@ -5020,88 +4980,6 @@ function classifyApiRequest(body) {
   }
 }
 
-// ---------------------------------------------------------------------------
-// Token Budget Parsing & Enforcement (A9)
-// ---------------------------------------------------------------------------
-
-/**
- * Parse natural-language budget expressions from user messages.
- * Supports: +500k, 500,000, 2M, 2 million, "spend 500k", "use 2M tokens", "budget: 1M".
- * Only scans the last user message to avoid re-triggering from history.
- *
- * @param {Array<{role: string, content: string | Array<{type: string, text?: string}>}>} messages
- * @returns {number} Parsed token count, or 0 if no budget expression found
- */
-function parseNaturalLanguageBudget(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return 0;
-
-  // Find the last user message
-  let lastUserText = "";
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === "user") {
-      const content = messages[i].content;
-      if (typeof content === "string") {
-        lastUserText = content;
-      } else if (Array.isArray(content)) {
-        lastUserText = content
-          .filter((b) => b.type === "text" && typeof b.text === "string")
-          .map((b) => b.text)
-          .join(" ");
-      }
-      break;
-    }
-  }
-  if (!lastUserText) return 0;
-
-  // Patterns ordered from most specific to least
-  const patterns = [
-    /\buse\s+(\d[\d,]*)\s*([mk])\s*tokens?\b/i,
-    /\bspend\s+(\d[\d,]*)\s*([mk])?\b/i,
-    /\bbudget[:\s]+(\d[\d,]*)\s*([mk])?\b/i,
-    /\+(\d[\d,]*)\s*([mk])\b/i,
-    /\b(\d[\d,]*)\s*million\s*tokens?\b/i,
-  ];
-
-  for (const re of patterns) {
-    const m = lastUserText.match(re);
-    if (m) {
-      const num = parseFloat(m[1].replace(/,/g, ""));
-      if (isNaN(num) || num <= 0) continue;
-      const suffix = (m[2] || "").toLowerCase();
-      if (re === patterns[4]) {
-        // "N million tokens" — the regex has no suffix group
-        return num * 1_000_000;
-      }
-      if (suffix === "m") return num * 1_000_000;
-      if (suffix === "k") return num * 1_000;
-      // No suffix — treat as absolute count
-      return num;
-    }
-  }
-  return 0;
-}
-
-/**
- * Inject a token budget status block into the system prompt.
- * Prepends a text block with budget progress and threshold info.
- *
- * @param {Array<{type: string, text?: string, [k: string]: any}>} systemBlocks
- * @param {{limit: number, used: number, continuations: number}} budget
- * @param {number} threshold - Completion threshold (0-1, e.g. 0.9)
- * @returns {Array<{type: string, text?: string, [k: string]: any}>}
- */
-function injectTokenBudgetBlock(systemBlocks, budget, threshold) {
-  if (!budget || budget.limit <= 0) return systemBlocks;
-  const pct = ((budget.used / budget.limit) * 100).toFixed(0);
-  const thresholdTokens = Math.round(budget.limit * threshold);
-  const remaining = Math.max(0, budget.limit - budget.used);
-  const block = {
-    type: "text",
-    text: `Token budget: ${budget.used.toLocaleString()}/${budget.limit.toLocaleString()} tokens used (${pct}%). Stop generating at ${thresholdTokens.toLocaleString()} tokens. Remaining: ${remaining.toLocaleString()} tokens.`,
-  };
-  return [block, ...(systemBlocks || [])];
-}
-
 /**
  * Detect diminishing returns: ≥3 continuations AND last 3 output deltas all < 500 tokens.
  *
@@ -5131,54 +5009,6 @@ function estimatePromptTokens(bodyString) {
   }
 }
 
-/**
- * Estimate prompt tokens from an already-parsed request body object.
- * Avoids redundant JSON.parse when the caller already has the parsed object.
- * @param {object} parsed - The parsed request body
- * @returns {number} Estimated token count
- */
-function estimatePromptTokensFromParsed(parsed) {
-  if (!parsed || typeof parsed !== "object") return 0;
-  let charCount = 0;
-
-  // Count system prompt text
-  if (Array.isArray(parsed.system)) {
-    for (const block of parsed.system) {
-      if (block.type === "text" && typeof block.text === "string") {
-        charCount += block.text.length;
-      }
-    }
-  } else if (typeof parsed.system === "string") {
-    charCount += parsed.system.length;
-  }
-
-  // Count messages content (text blocks, tool results) — skip tool definitions
-  if (Array.isArray(parsed.messages)) {
-    for (const msg of parsed.messages) {
-      if (typeof msg.content === "string") {
-        charCount += msg.content.length;
-      } else if (Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === "text" && typeof block.text === "string") {
-            charCount += block.text.length;
-          } else if (block.type === "tool_result" && typeof block.content === "string") {
-            charCount += block.content.length;
-          } else if (block.type === "tool_use") {
-            // Count serialized input as tokens
-            charCount += JSON.stringify(block.input || {}).length;
-          } else if (block.type === "image" || block.type === "image_url") {
-            // Images: ~2000 tokens per image (Anthropic tile-based counting)
-            charCount += 8000; // 2000 tokens * 4 chars/token
-          }
-        }
-      }
-    }
-  }
-
-  // 4 chars/token heuristic for text content (reasonable for English + code + JSON)
-  return Math.ceil(charCount / 4);
-}
-
 /**
  * Analyze a request body to produce a token breakdown by role and tool.
  * Used by `/anthropic context` command.
@@ -5499,16 +5329,6 @@ function updateSessionMetrics(usage, model) {
   }
 }
 
-/**
- * Get rolling average cache hit rate over last 5 turns.
- * @returns {number} 0-1
- */
-function getAverageCacheHitRate() {
-  const rates = sessionMetrics.recentCacheRates;
-  if (rates.length === 0) return 0;
-  return rates.reduce((a, b) => a + b, 0) / rates.length;
-}
-
 /**
  * Write cache transparency stats to a well-known JSON file for TUI consumption.
  * The OpenCode TUI watches this file to display cache metrics in the status bar.
@@ -5752,9 +5572,6 @@ process.once("beforeExit", _beforeExitHandler);
 // Request building helpers (extracted from original fetch interceptor)
 // ---------------------------------------------------------------------------
 
-const BILLING_HASH_SALT = "59cf53e54c78";
-const BILLING_HASH_INDICES = [4, 7, 20];
-
 // cch attestation: RE-ENABLED with xxHash64 (matching Bun binary's Attestation.zig).
 // The compiled Bun binary computes cch dynamically: xxHash64(body, seed) & 0xFFFFF.
 // Captured real CC v2.1.107 request shows cch=6d00f (5-hex-char, 20-bit masked hash).
@@ -5783,19 +5600,6 @@ async function computeAndReplaceCCH(body) {
   return body.replace("cch=00000", `cch=${cch}`);
 }
 
-/**
- * Compute the billing cache hash (cch) matching Claude Code's NP1() function.
- * SHA256(salt + chars_at_indices[4,7,20]_from_first_user_msg + version).slice(0,3)
- * @param {string} firstUserMessage
- * @param {string} version
- * @returns {string}
- */
-function computeBillingCacheHash(firstUserMessage, version) {
-  const chars = BILLING_HASH_INDICES.map((i) => firstUserMessage[i] || "0").join("");
-  const input = `${BILLING_HASH_SALT}${chars}${version}`;
-  return createHashCrypto("sha256").update(input).digest("hex").slice(0, 3);
-}
-
 /**
  * Extract the text content of the first user message for billing hash computation.
  * @param {any[] | undefined} messages
@@ -5839,2921 +5643,316 @@ function computeBillingCacheHash(firstUserMessage, version) {
  * @param {Array} messages — The messages array from the parsed request body
  * @returns {Array} — Repaired messages array
  */
+
+const _ADVANCED_TOOL_USE_BETA_FLAG = "advanced-tool-use-2025-11-20";
+// OpenCode SDK betas that leak through the host's Anthropic SDK but are NOT
+// part of CC's beta vocabulary. Filtered out when signature emulation is on.
+const USER_ID_STORAGE_FILE = "anthropic-signature-user-id";
+const DEBUG_SYSTEM_PROMPT_ENV = "OPENCODE_ANTHROPIC_DEBUG_SYSTEM_PROMPT";
 /**
- * Apply context-hint compaction to a message array. Mirrors real CC's
- * `applyHintEdits` (d85) + `qD4` microcompact: clears thinking/redacted_thinking
- * blocks from assistant messages and replaces old tool_result content with a
- * placeholder, keeping the last few tool results intact. Used on 422/424
- * responses before retrying.
- *
- * @param {Array} messages — Parsed messages array
- * @param {object} [opts]
- * @param {number} [opts.keepRecentToolResults=8] — How many most-recent tool_result blocks to preserve verbatim
- * @param {string} [opts.clearedPlaceholder] — Replacement content for older tool_result blocks
- * @returns {{ messages: Array, changed: boolean, stats: { thinkingCleared: number, toolResultsCleared: number } }}
+ * Returns the persistent device ID (64-char hex string).
+ * Migrates legacy UUID-format values to the new 64-hex format automatically.
+ * @returns {string}
  */
-function applyContextHintCompaction(messages, opts = {}) {
-  if (!Array.isArray(messages) || messages.length === 0) {
-    return { messages, changed: false, stats: { thinkingCleared: 0, toolResultsCleared: 0 } };
-  }
-  const keepRecent = opts.keepRecentToolResults ?? 8;
-  const placeholder = opts.clearedPlaceholder ?? "[Old tool result content cleared]";
-
-  // First pass: count tool_result blocks so we know which are "old" vs "recent".
-  const toolResultRefs = [];
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
-    for (let j = 0; j < msg.content.length; j++) {
-      if (msg.content[j]?.type === "tool_result") {
-        toolResultRefs.push({ msgIdx: i, blockIdx: j });
-      }
+function getOrCreateDeviceId() {
+  const configDir = getConfigDir();
+  const userIdPath = join(configDir, USER_ID_STORAGE_FILE);
+
+  try {
+    if (existsSync(userIdPath)) {
+      const existing = readFileSync(userIdPath, "utf-8").trim();
+      if (existing && /^[0-9a-f]{64}$/.test(existing)) return existing;
     }
+  } catch {
+    // fall through and generate a new id
   }
-  const oldCutoff = Math.max(0, toolResultRefs.length - keepRecent);
-  const oldSet = new Set(toolResultRefs.slice(0, oldCutoff).map((r) => `${r.msgIdx}:${r.blockIdx}`));
-
-  let thinkingCleared = 0;
-  let toolResultsCleared = 0;
-  const out = messages.map((msg, i) => {
-    if (!Array.isArray(msg.content)) return msg;
-    if (msg.role === "assistant") {
-      const newContent = msg.content.filter((block) => {
-        if (block?.type === "thinking" || block?.type === "redacted_thinking") {
-          thinkingCleared += 1;
-          return false;
-        }
-        return true;
-      });
-      if (newContent.length !== msg.content.length) {
-        return { ...msg, content: newContent };
-      }
-      return msg;
-    }
-    if (msg.role === "user") {
-      let mutated = false;
-      const newContent = msg.content.map((block, j) => {
-        if (block?.type !== "tool_result") return block;
-        const key = `${i}:${j}`;
-        if (!oldSet.has(key)) return block;
-        toolResultsCleared += 1;
-        mutated = true;
-        // Replace content with placeholder, preserve tool_use_id
-        return {
-          ...block,
-          content: placeholder,
-        };
-      });
-      return mutated ? { ...msg, content: newContent } : msg;
-    }
-    return msg;
-  });
 
-  return {
-    messages: out,
-    changed: thinkingCleared > 0 || toolResultsCleared > 0,
-    stats: { thinkingCleared, toolResultsCleared },
-  };
+  const generated = randomBytes(32).toString("hex");
+  try {
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(userIdPath, `${generated}\n`, { encoding: "utf-8", mode: 0o600 });
+  } catch {
+    // Ignore filesystem errors; caller still gets generated ID for this runtime.
+  }
+  return generated;
 }
 
 /**
- * Tools whose output is trivially reproducible by re-running with the same
- * arguments. Stateful tools (bash, edit, write, etc.) never dedupe — their
- * outputs may reflect non-idempotent side effects that the transcript needs
- * to preserve.
+ * @returns {boolean}
  */
-const REPRODUCIBLE_TOOL_NAMES = new Set(["read", "grep", "glob", "ls", "list", "find"]);
+function shouldDebugSystemPrompt() {
+  return isTruthyEnv(process.env[DEBUG_SYSTEM_PROMPT_ENV]);
+}
 
 /**
- * Title-case a tool name for the stub string ("read" → "Read", "grep" → "Grep").
- * Pure; no locale.
+ * @param {string | undefined} value
+ * @returns {boolean}
  */
-function titleCaseToolName(name) {
-  if (typeof name !== "string" || name.length === 0) return "";
-  return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
-}
-
 /**
- * Minimal deterministic stable-stringify for args canonicalization.
- * Sorts object keys at every depth before serialization so that
- * `{a:1,b:2}` and `{b:2,a:1}` produce the same string.
- *
- * Arrays are traversed in order. Non-plain objects (Date, Map, etc.) fall
- * through to `JSON.stringify` — we don't expect them in tool args, but the
- * fallback keeps the function total.
+ * @param {string | undefined} value
+ * @returns {boolean}
  */
-function stableStringifyForDedupe(value) {
-  if (value === null || typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) {
-    return "[" + value.map((v) => stableStringifyForDedupe(v)).join(",") + "]";
-  }
-  const keys = Object.keys(value).sort();
-  const parts = [];
-  for (const k of keys) {
-    parts.push(JSON.stringify(k) + ":" + stableStringifyForDedupe(value[k]));
-  }
-  return "{" + parts.join(",") + "}";
-}
-
 /**
- * Session-wide tool-result dedupe. Pure over `messages`.
- *
- * Walks the conversation once to collect every `tool_use` + `tool_result`
- * pair where the tool is in `REPRODUCIBLE_TOOL_NAMES` (case-insensitive).
- * Groups them by `(toolName, stableStringify(args))`. For every group
- * containing more than one call, keeps the LATEST result verbatim and
- * replaces each earlier result's `content` with a stub:
- *
- *   `[<ToolTitleCase> of <argsKey> superseded by later read at msg #<N>]`
- *
- * where `N` is the message index of the latest call's user-message.
- *
- * `tool_use_id` and any other `tool_result` fields are preserved. Assistant
- * `tool_use` blocks are NEVER modified — only the paired user `tool_result`.
- *
- * Cache-stable: decision is a pure function of message history, so rerunning
- * over an unchanged prefix yields byte-identical output.
- *
- * @param {Array} messages — Parsed messages array
- * @returns {{ messages: Array, changed: boolean, stats: { deduped: number } }}
+ * @returns {boolean}
  */
-function applySessionToolResultDedupe(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) {
-    return { messages, changed: false, stats: { deduped: 0 } };
-  }
-
-  // Pass 1: build tool_use_id → { name, argsKey } for reproducible tools.
-  const idToMeta = new Map();
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg?.role !== "assistant" || !Array.isArray(msg.content)) continue;
-    for (const block of msg.content) {
-      if (block?.type !== "tool_use") continue;
-      const name = typeof block.name === "string" ? block.name : "";
-      if (!REPRODUCIBLE_TOOL_NAMES.has(name.toLowerCase())) continue;
-      const argsKey = stableStringifyForDedupe(block.input ?? {});
-      idToMeta.set(block.id, { name, argsKey });
-    }
-  }
-
-  // Pass 2: collect tool_result locations by group key, preserving order.
-  /** @type {Map<string, Array<{msgIdx: number, blockIdx: number, toolUseId: string, name: string, argsKey: string}>>} */
-  const groups = new Map();
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg?.role !== "user" || !Array.isArray(msg.content)) continue;
-    for (let j = 0; j < msg.content.length; j++) {
-      const block = msg.content[j];
-      if (block?.type !== "tool_result") continue;
-      const meta = idToMeta.get(block.tool_use_id);
-      if (!meta) continue;
-      const groupKey = meta.name.toLowerCase() + "\u0000" + meta.argsKey;
-      let arr = groups.get(groupKey);
-      if (!arr) {
-        arr = [];
-        groups.set(groupKey, arr);
-      }
-      arr.push({
-        msgIdx: i,
-        blockIdx: j,
-        toolUseId: block.tool_use_id,
-        name: meta.name,
-        argsKey: meta.argsKey,
-      });
-    }
-  }
-
-  // Build supersede map: "msgIdx:blockIdx" → stub string.
-  const supersedeStubs = new Map();
-  let deduped = 0;
-  // Deterministic iteration: sort group entries by group key before processing.
-  const sortedEntries = Array.from(groups.entries()).sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-  for (const [, occurrences] of sortedEntries) {
-    if (occurrences.length < 2) continue;
-    const latest = occurrences[occurrences.length - 1];
-    const stub =
-      "[" +
-      titleCaseToolName(latest.name) +
-      " of " +
-      latest.argsKey +
-      " superseded by later read at msg #" +
-      latest.msgIdx +
-      "]";
-    for (let k = 0; k < occurrences.length - 1; k++) {
-      const occ = occurrences[k];
-      supersedeStubs.set(occ.msgIdx + ":" + occ.blockIdx, stub);
-      deduped += 1;
-    }
-  }
-
-  if (deduped === 0) {
-    return { messages, changed: false, stats: { deduped: 0 } };
-  }
-
-  // Pass 3: rewrite. Preserve tool_use_id and other fields.
-  const out = messages.map((msg, i) => {
-    if (msg?.role !== "user" || !Array.isArray(msg.content)) return msg;
-    let mutated = false;
-    const newContent = msg.content.map((block, j) => {
-      if (block?.type !== "tool_result") return block;
-      const stub = supersedeStubs.get(i + ":" + j);
-      if (!stub) return block;
-      mutated = true;
-      return { ...block, content: stub };
-    });
-    return mutated ? { ...msg, content: newContent } : msg;
-  });
 
-  return { messages: out, changed: true, stats: { deduped } };
-}
+/**
+ * @returns {Record<string, string>}
+ */
 
 /**
- * Dispatch wrapper: only apply `applySessionToolResultDedupe` when the
- * `token_economy_strategies.tool_result_dedupe_session_wide` flag is true.
- * When disabled, returns the input `messages` by identity (not a copy) so
- * callers can cheaply detect "no-op" with reference equality.
- *
- * @param {Array} messages
- * @param {object} [config]
- * @returns {Array}
+ * @returns {string}
  */
-function maybeApplySessionToolResultDedupe(messages, config) {
-  const flag = config?.token_economy_strategies?.tool_result_dedupe_session_wide;
-  if (flag !== true) return messages;
-  const result = applySessionToolResultDedupe(messages);
-  return result.messages;
+function getClaudeEntrypoint() {
+  return process.env.CLAUDE_CODE_ENTRYPOINT || "cli";
 }
 
 /**
- * TTL-based thinking strip. When the time since the last strip exceeds the
- * cache TTL (roughly the point at which the prompt prefix cache would expire),
- * remove all `thinking` / `redacted_thinking` blocks from prior assistant
- * messages. Mirrors CC's `logThinkingClearLatched("ttl", ...)`.
- *
- * We keep the MOST RECENT assistant's thinking intact — chain-of-thought
- * continuity for the current turn matters; older ones don't.
- *
- * @param {Array} messages
- * @param {{ lastClearMs: number, ttlMs: number, now?: number }} ctx
- * @returns {{ messages: Array, changed: boolean, cleared: number, ranStripAt: number }}
+ * @param {string | undefined} model
+ * @returns {string | undefined}
  */
-function applyTtlThinkingStrip(messages, ctx) {
-  const now = ctx.now ?? Date.now();
-  if (!Array.isArray(messages) || messages.length === 0) {
-    return { messages, changed: false, cleared: 0, ranStripAt: ctx.lastClearMs };
-  }
-  if (ctx.lastClearMs > 0 && now - ctx.lastClearMs < ctx.ttlMs) {
-    return { messages, changed: false, cleared: 0, ranStripAt: ctx.lastClearMs };
-  }
+function logTransformedSystemPrompt(body) {
+  if (!shouldDebugSystemPrompt()) return;
+  if (!body || typeof body !== "string") return;
 
-  // Find the last assistant message index — preserve its thinking.
-  let lastAsstIdx = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i]?.role === "assistant") {
-      lastAsstIdx = i;
-      break;
-    }
+  try {
+    const parsed = JSON.parse(body);
+    if (!Object.prototype.hasOwnProperty.call(parsed, "system")) return;
+    if (isTitleGeneratorSystemBlocks(normalizeSystemTextBlocks(parsed.system))) return;
+    console.error(
+      "[opencode-anthropic-auth][system-debug] transformed system:",
+      JSON.stringify(parsed.system, null, 2),
+    );
+  } catch {
+    // Ignore parse errors in debug logging path.
   }
-
-  let cleared = 0;
-  const out = messages.map((msg, i) => {
-    if (msg.role !== "assistant" || i === lastAsstIdx || !Array.isArray(msg.content)) {
-      return msg;
-    }
-    const newContent = msg.content.filter((b) => {
-      if (b?.type === "thinking" || b?.type === "redacted_thinking") {
-        cleared += 1;
-        return false;
-      }
-      return true;
-    });
-    return newContent.length !== msg.content.length ? { ...msg, content: newContent } : msg;
-  });
-
-  return { messages: out, changed: cleared > 0, cleared, ranStripAt: cleared > 0 ? now : ctx.lastClearMs };
 }
 
 /**
- * Proactive microcompact — client-side, runs BEFORE the request goes out.
- * At or above `percent` of the model's context window, replace old
- * tool_result.content with a placeholder (keeping last `keepRecent` verbatim).
- *
- * Returns the new messages array + change stats.
- *
- * @param {Array} messages
- * @param {{ estimatedTokens: number, contextWindow: number, percent: number, keepRecent: number }} ctx
- * @returns {{ messages: Array, changed: boolean, cleared: number, triggered: boolean }}
+ * @param {string | undefined} body
+ * @returns {boolean}
  */
-function applyProactiveMicrocompact(messages, ctx) {
-  const threshold = ctx.contextWindow * (ctx.percent / 100);
-  if (ctx.estimatedTokens < threshold) {
-    return { messages, changed: false, cleared: 0, triggered: false };
-  }
-  const result = applyContextHintCompaction(messages, { keepRecentToolResults: ctx.keepRecent });
-  return {
-    messages: result.messages,
-    changed: result.changed,
-    cleared: result.stats.toolResultsCleared,
-    triggered: true,
-  };
-}
 
 /**
- * Stable tool ordering — sort tools by name so the system-prompt prefix stays
- * cache-stable across turns. Safe: tool semantics are name-based, not index-based.
- *
- * @param {any[]} tools
- * @returns {any[]}
+ * @param {string | undefined} body
+ * @returns {boolean}
  */
-function applyStableToolOrdering(tools) {
-  if (!Array.isArray(tools) || tools.length < 2) return tools;
-  // Preserve a pinned "first" for tools whose position is load-bearing (none today).
-  return [...tools].sort((a, b) => {
-    const an = typeof a?.name === "string" ? a.name : "";
-    const bn = typeof b?.name === "string" ? b.name : "";
-    return an < bn ? -1 : an > bn ? 1 : 0;
-  });
+function supportsThinking(model) {
+  if (!model) return true;
+  return /claude|sonnet|opus|haiku/i.test(model);
 }
 
 /**
- * Tool schema deferral — replace the `input_schema` of deferred tools with a
- * minimal placeholder until the tool has been invoked in this session.
- *
- * @param {any[]} tools
- * @param {{ deferred: Set<string>, invoked: Set<string> }} ctx
- * @returns {{ tools: any[], deferredCount: number }}
+ * @param {string | undefined} body
+ * @returns {boolean}
  */
-function applyToolSchemaDeferral(tools, ctx) {
-  if (!Array.isArray(tools) || ctx.deferred.size === 0) {
-    return { tools, deferredCount: 0 };
-  }
-  let deferredCount = 0;
-  const out = tools.map((t) => {
-    const name = typeof t?.name === "string" ? t.name : "";
-    if (!ctx.deferred.has(name) || ctx.invoked.has(name)) return t;
-    deferredCount += 1;
-    // Minimal schema — `type:object` with no properties is accepted by the API.
-    return {
-      ...t,
-      input_schema: { type: "object", properties: {}, additionalProperties: true },
-    };
-  });
-  return { tools: out, deferredCount };
-}
 
 /**
- * Adaptive thinking — zero the thinking budget for trivially simple follow-ups.
- * "Simple" heuristic: most recent user message is short (<200 chars), no file
- * references, and the conversation is past turn 1 (so we have context).
- *
- * @param {any} parsed Parsed request body (mutated in place if simple)
- * @returns {{ applied: boolean, previousBudget: number | null }}
+ * @param {string | undefined} body
+ * @returns {boolean}
  */
-function applyAdaptiveThinkingZero(parsed) {
-  if (!parsed || !parsed.thinking || parsed.thinking.type !== "enabled") {
-    return { applied: false, previousBudget: null };
-  }
-  const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
-  if (messages.length < 2) return { applied: false, previousBudget: null };
-  const last = messages[messages.length - 1];
-  if (!last || last.role !== "user") return { applied: false, previousBudget: null };
-
-  let userText = "";
-  if (typeof last.content === "string") userText = last.content;
-  else if (Array.isArray(last.content)) {
-    for (const b of last.content) {
-      if (b?.type === "text" && typeof b.text === "string") userText += b.text;
-      if (b?.type === "tool_result") return { applied: false, previousBudget: null };
-    }
-  }
-  if (userText.length > 200) return { applied: false, previousBudget: null };
-  if (/\b(analyze|refactor|design|review|audit|plan)\b/i.test(userText)) {
-    return { applied: false, previousBudget: null };
-  }
-
-  const previousBudget = typeof parsed.thinking.budget_tokens === "number" ? parsed.thinking.budget_tokens : null;
-  // "Zero" means remove thinking entirely — API disallows budget_tokens:0.
-  delete parsed.thinking;
-  if (typeof parsed.temperature !== "number") parsed.temperature = 1;
-  return { applied: true, previousBudget };
-}
 
 /**
- * Cross-turn tool_result dedupe — when the same (tool name, input) pair
- * appeared earlier in the conversation, replace the later result content
- * with a pointer string. Safe-set only: Read, Grep, Glob, LS.
- *
- * @param {Array} messages
- * @param {{ seen: Map<string, string>, safeTools: Set<string> }} ctx
- * @returns {{ messages: Array, changed: boolean, deduped: number }}
+ * @param {URL | null} requestUrl
+ * @returns {"anthropic" | "bedrock" | "vertex" | "foundry" | "anthropicAws" | "mantle"}
  */
-function applyToolResultDedupe(messages, ctx) {
-  if (!Array.isArray(messages) || messages.length === 0) {
-    return { messages, changed: false, deduped: 0 };
-  }
-  // First pass: build map of tool_use_id → { name, inputHash } from assistant messages.
-  const idToKey = new Map();
-  for (const msg of messages) {
-    if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
-    for (const b of msg.content) {
-      if (b?.type !== "tool_use") continue;
-      if (!ctx.safeTools.has(b.name)) continue;
-      const inputStr = JSON.stringify(b.input ?? {});
-      idToKey.set(b.id, `${b.name}::${inputStr}`);
-    }
-  }
-
-  let deduped = 0;
-  const out = messages.map((msg) => {
-    if (msg.role !== "user" || !Array.isArray(msg.content)) return msg;
-    let mutated = false;
-    const newContent = msg.content.map((b) => {
-      if (b?.type !== "tool_result") return b;
-      const key = idToKey.get(b.tool_use_id);
-      if (!key) return b;
-      const firstSeen = ctx.seen.get(key);
-      if (firstSeen && firstSeen !== b.tool_use_id) {
-        deduped += 1;
-        mutated = true;
-        return { ...b, content: `[Identical to tool_use_id=${firstSeen}]` };
-      }
-      if (!firstSeen) ctx.seen.set(key, b.tool_use_id);
-      return b;
-    });
-    return mutated ? { ...msg, content: newContent } : msg;
-  });
-
-  return { messages: out, changed: deduped > 0, deduped };
-}
 
 /**
- * Trailing-summary trimmer — strip the final text block of past assistant
- * messages if it looks like a summary (ends with "...done" / "summary" /
- * numbered list / "I've X'd Y"). Only applies to messages past the last one.
+ * Classify a request by inferred role, mirroring CC's `querySource` gate.
+ * CC gates features like context-hint on `querySource.startsWith("repl_main_thread")`.
+ * We don't have that string on the wire, so we infer from body shape.
+ *
+ * Returns one of:
+ *   - "main"   → interactive main thread (long system, normal max_tokens, messages present)
+ *   - "title"  → title / name generation (tiny max_tokens, 1 message)
+ *   - "small"  → short background query (small max_tokens but not title)
+ *   - "empty"  → pre-warm / no messages
+ *   - "unknown" → treat as main for safety
  *
- * @param {Array} messages
- * @returns {{ messages: Array, changed: boolean, trimmed: number }}
+ * @param {any} parsed Parsed request body
+ * @returns {"main"|"title"|"small"|"empty"|"unknown"}
  */
-function applyTrailingSummaryTrim(messages) {
-  if (!Array.isArray(messages) || messages.length < 2) {
-    return { messages, changed: false, trimmed: 0 };
-  }
-  const SUMMARY_PATTERNS = [
-    /\b(summary|summar(y|ised|ized)):/i,
-    /\bto summari[sz]e\b/i,
-    /^\s*in (summary|short|brief)/im,
-    /\bi['']ve (done|completed|implemented|added|updated|fixed) /i,
-    /\bthat's it\b/i,
-  ];
-
-  let lastAsstIdx = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i]?.role === "assistant") {
-      lastAsstIdx = i;
-      break;
-    }
-  }
-
-  let trimmed = 0;
-  const out = messages.map((msg, i) => {
-    if (msg.role !== "assistant" || i === lastAsstIdx) return msg;
-    if (!Array.isArray(msg.content)) return msg;
-
-    const last = msg.content[msg.content.length - 1];
-    if (!last || last.type !== "text" || typeof last.text !== "string") return msg;
-    const text = last.text;
-    if (text.length < 80) return msg;
-    const isSummary = SUMMARY_PATTERNS.some((p) => p.test(text));
-    if (!isSummary) return msg;
-
-    trimmed += 1;
-    const newContent = msg.content.slice(0, -1);
-    if (newContent.length === 0) return msg; // keep at least one block
-    return { ...msg, content: newContent };
-  });
-
-  return { messages: out, changed: trimmed > 0, trimmed };
-}
-
-function repairOrphanedToolUseBlocks(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return messages;
-
-  const repaired = [];
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    repaired.push(msg);
-
-    // Only check assistant messages with array content
-    if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
-
-    // Collect tool_use IDs from this assistant message
-    const toolUseIds = [];
-    for (const block of msg.content) {
-      if (block.type === "tool_use" && block.id) {
-        toolUseIds.push(block.id);
-      }
-    }
-    if (toolUseIds.length === 0) continue;
-
-    // Check if the next message is a user message with matching tool_results
-    const next = messages[i + 1];
-    if (next && next.role === "user" && Array.isArray(next.content)) {
-      // Collect tool_result IDs present in the next user message
-      const resultIds = new Set();
-      for (const block of next.content) {
-        if (block.type === "tool_result" && block.tool_use_id) {
-          resultIds.add(block.tool_use_id);
-        }
-      }
-
-      // Find which tool_use IDs are missing from the tool_results
-      const missingIds = toolUseIds.filter((id) => !resultIds.has(id));
-      if (missingIds.length === 0) continue; // All paired, nothing to fix
-
-      // There are missing tool_results — inject them into the existing user message.
-      // Clone the next message to avoid mutating the original.
-      const patchedNext = {
-        ...next,
-        content: [
-          ...missingIds.map((id) => ({
-            type: "tool_result",
-            tool_use_id: id,
-            content: "[Result unavailable — tool execution was interrupted]",
-          })),
-          ...next.content,
-        ],
-      };
-      // Replace the next message in-place by skipping it and pushing the patched version
-      i++; // skip original next
-      repaired.push(patchedNext);
-    } else {
-      // Next message is missing or is not a user message — synthesize a full
-      // tool_result user message for all tool_use IDs.
-      repaired.push({
-        role: "user",
-        content: toolUseIds.map((id) => ({
-          type: "tool_result",
-          tool_use_id: id,
-          content: "[Result unavailable — tool execution was interrupted]",
-        })),
-      });
-    }
-  }
-
-  return repaired;
-}
-
-function stripSlashCommandMessages(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return messages;
-
-  // Pattern: /anthropic followed by optional subcommand
-  const CMD_RE = /^\s*\/anthropic\b/i;
-  // Pattern: ▣ Anthropic — prefix used by all sendCommandMessage outputs
-  const RESP_RE = /^▣\s*Anthropic/;
-
-  /**
-   * Extract the first text content from a message's content field.
-   * Handles both string content and array-of-blocks content.
-   */
-  function getFirstText(msg) {
-    if (typeof msg.content === "string") return msg.content;
-    if (Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if (block.type === "text" && typeof block.text === "string") return block.text;
-      }
-    }
-    return "";
-  }
-
-  /**
-   * Check if a user message is a /anthropic command.
-   * A message is a command if its text content starts with /anthropic.
-   */
-  function isCommandMessage(msg) {
-    if (msg.role !== "user") return false;
-    const text = getFirstText(msg);
-    return CMD_RE.test(text);
-  }
+function classifyRequestRole(parsed) {
+  if (!parsed || typeof parsed !== "object") return "unknown";
+  const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+  const maxTokens = typeof parsed.max_tokens === "number" ? parsed.max_tokens : null;
 
-  /**
-   * Check if an assistant message is a sendCommandMessage response.
-   * These always start with ▣ Anthropic.
-   */
-  function isCommandResponse(msg) {
-    if (msg.role !== "assistant") return false;
-    const text = getFirstText(msg);
-    return RESP_RE.test(text);
+  if (messages.length === 0) return "empty";
+  if (maxTokens != null) {
+    if (maxTokens <= 256 && messages.length <= 2) return "title";
+    if (maxTokens <= 1024) return "small";
   }
-
-  const filtered = [];
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-
-    // Drop /anthropic command messages
-    if (isCommandMessage(msg)) {
-      // Also drop the immediately following assistant response if it's a command response
-      if (i + 1 < messages.length && isCommandResponse(messages[i + 1])) {
-        i++; // Skip the response too
-      }
-      continue;
-    }
-
-    // Drop orphaned command responses (in case the command message was already removed
-    // or the ordering is different)
-    if (isCommandResponse(msg)) {
-      continue;
+  // System prompt length heuristic
+  let sysLen = 0;
+  if (typeof parsed.system === "string") {
+    sysLen = parsed.system.length;
+  } else if (Array.isArray(parsed.system)) {
+    for (const s of parsed.system) {
+      if (s && typeof s.text === "string") sysLen += s.text.length;
     }
-
-    filtered.push(msg);
   }
-
-  // Safety: if filtering removed ALL messages, return the original to avoid sending
-  // an empty messages array to the API.
-  if (filtered.length === 0) return messages;
-
-  return filtered;
-}
-
-function extractFirstUserMessageText(messages) {
-  if (!Array.isArray(messages)) return "";
-  for (const msg of messages) {
-    if (msg.role !== "user") continue;
-    if (typeof msg.content === "string") return msg.content;
-    if (Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if (block.type === "text" && typeof block.text === "string") return block.text;
-      }
-    }
-    return "";
+  if (sysLen < 200 && messages.length <= 2 && (maxTokens == null || maxTokens <= 2048)) {
+    return "small";
   }
-  return "";
+  return "main";
 }
 
-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 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([
-  CLAUDE_CODE_IDENTITY_STRING,
-  "You are Claude Code, Anthropic's official CLI for Claude, running within the Claude Agent SDK.",
-  "You are a Claude agent, built on Anthropic's Claude Agent SDK.",
-]);
-const BEDROCK_UNSUPPORTED_BETAS = new Set([
-  "interleaved-thinking-2025-05-14",
-  "context-1m-2025-08-07",
-  "tool-search-tool-2025-10-19",
-]);
-// OpenCode SDK betas that leak through the host's Anthropic SDK but are NOT
-// part of CC's beta vocabulary. Filtered out when signature emulation is on.
-// Core tool names (CC PascalCase) that are always eager-loaded.
-const CORE_TOOL_NAMES = new Set([
-  "Bash",
-  "Read",
-  "Glob",
-  "Grep",
-  "Edit",
-  "Write",
-  "WebFetch",
-  "TodoWrite",
-  "Skill",
-  "Task",
-  "Compress",
-]);
-const HOST_SDK_BETAS_BLOCKLIST = new Set(["fine-grained-tool-streaming-2025-05-14", "structured-outputs-2025-11-13"]);
-const STAINLESS_HELPER_KEYS = [
-  "x_stainless_helper",
-  "x-stainless-helper",
-  "stainless_helper",
-  "stainlessHelper",
-  "_stainless_helper",
-];
-const USER_ID_STORAGE_FILE = "anthropic-signature-user-id";
-const DEBUG_SYSTEM_PROMPT_ENV = "OPENCODE_ANTHROPIC_DEBUG_SYSTEM_PROMPT";
-const SYSTEM_PROMPT_DYNAMIC_BOUNDARY = "__SYSTEM_PROMPT_DYNAMIC_BOUNDARY__";
-const COMPACT_TITLE_GENERATOR_SYSTEM_PROMPT = [
-  "You are a title generator. You output ONLY a thread title. Nothing else.",
-  "",
-  "Rules:",
-  "- Use the same language as the user message.",
-  "- Output exactly one line.",
-  "- Keep the title at or below 50 characters.",
-  "- No explanations, prefixes, or suffixes.",
-  "- Keep important technical terms, numbers, and filenames when present.",
-].join("\n");
-
 /**
- * Anti-verbosity system prompt text.
- * Extracted from CC v2.1.100 (gated on quiet_salted_ember A/B test for Opus 4.6).
- * Significantly reduces output token count by instructing the model to be concise.
+ * @param {any} body
+ * @returns {{model: string, tools: any[], messages: any[], hasFileReferences: boolean}}
  */
-const ANTI_VERBOSITY_SYSTEM_PROMPT = [
-  "# Communication style",
-  "Assume users can't see most tool calls or thinking — only your text output. Before your first tool call, state in one sentence what you're about to do. While working, give short updates at key moments: when you find something, when you change direction, or when you hit a blocker. Brief is good — silent is not. One sentence per update is almost always enough.",
-  "",
-  "Don't narrate your internal deliberation. User-facing text should be relevant communication to the user, not a running commentary on your thought process. State results and decisions directly, and focus user-facing text on relevant updates for the user.",
-  "",
-  "When you do write updates, write so the reader can pick up cold: complete sentences, no unexplained jargon or shorthand from earlier in the session. But keep it tight — a clear sentence is better than a clear paragraph.",
-  "",
-  "End-of-turn summary: one or two sentences. What changed and what's next. Nothing else.",
-  "",
-  "Match responses to the task: a simple question gets a direct answer, not headers and sections.",
-  "",
-  "In code: default to writing no comments. Never write multi-paragraph docstrings or multi-line comment blocks — one short line max. Don't create planning, decision, or analysis documents unless the user asks for them — work from conversation context, not intermediate files.",
-].join("\n");
 
 /**
- * Numeric length anchors text.
- * Extracted from CC v2.1.100. Hard word-count limits for output.
+ * @param {any[]} tools
+ * @param {any[]} messages
+ * @returns {string}
  */
-const NUMERIC_LENGTH_ANCHORS_PROMPT =
-  "Length limits: keep text between tool calls to ≤25 words. Keep final responses to ≤100 words unless the task requires more detail.";
 
 /**
- * Returns the persistent device ID (64-char hex string).
- * Migrates legacy UUID-format values to the new 64-hex format automatically.
+ * @param {{id?: string, accountUuid?: string} | null | undefined} account
  * @returns {string}
  */
-function getOrCreateDeviceId() {
-  const configDir = getConfigDir();
-  const userIdPath = join(configDir, USER_ID_STORAGE_FILE);
-
-  try {
-    if (existsSync(userIdPath)) {
-      const existing = readFileSync(userIdPath, "utf-8").trim();
-      if (existing && /^[0-9a-f]{64}$/.test(existing)) return existing;
-    }
-  } catch {
-    // fall through and generate a new id
-  }
-
-  const generated = randomBytes(32).toString("hex");
-  try {
-    mkdirSync(configDir, { recursive: true });
-    writeFileSync(userIdPath, `${generated}\n`, { encoding: "utf-8", mode: 0o600 });
-  } catch {
-    // Ignore filesystem errors; caller still gets generated ID for this runtime.
+function getAccountIdentifier(account) {
+  // Prefer env-provided account UUID (v2.1.51+), then account record fields
+  const envUuid = process.env.CLAUDE_CODE_ACCOUNT_UUID?.trim();
+  if (envUuid) return envUuid;
+  if (account?.accountUuid && typeof account.accountUuid === "string") {
+    return account.accountUuid;
   }
-  return generated;
-}
-
-/**
- * @returns {boolean}
- */
-function shouldDebugSystemPrompt() {
-  return isTruthyEnv(process.env[DEBUG_SYSTEM_PROMPT_ENV]);
-}
-
-/**
- * @param {string | undefined} value
- * @returns {boolean}
- */
-function isTruthyEnv(value) {
-  if (!value) return false;
-  const normalized = value.trim().toLowerCase();
-  return normalized === "1" || normalized === "true" || normalized === "yes";
-}
-
-/**
- * @param {string | undefined} value
- * @returns {boolean}
- */
-function isFalsyEnv(value) {
-  if (!value) return false;
-  const normalized = value.trim().toLowerCase();
-  return normalized === "0" || normalized === "false" || normalized === "no";
-}
-
-/**
- * @returns {boolean}
- */
-function isNonInteractiveMode() {
-  if (isTruthyEnv(process.env.CI)) return true;
-  return !process.stdout.isTTY;
-}
-
-/**
- * @returns {Record<string, string>}
- */
-function parseAnthropicCustomHeaders() {
-  const raw = process.env.ANTHROPIC_CUSTOM_HEADERS;
-  if (!raw) return {};
-
-  /** @type {Record<string, string>} */
-  const headers = {};
-  for (const line of raw.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    const sep = trimmed.indexOf(":");
-    if (sep <= 0) continue;
-    const key = trimmed.slice(0, sep).trim();
-    const value = trimmed.slice(sep + 1).trim();
-    if (!key || !value) continue;
-    headers[key] = value;
+  if (account?.id && typeof account.id === "string") {
+    return account.id;
   }
-
-  return headers;
+  return "";
 }
 
 /**
- * @returns {string}
+ * @param {{persistentUserId: string, accountId: string, sessionId: string}} input
+ * @returns {{user_id: string}}
  */
-function getClaudeEntrypoint() {
-  return process.env.CLAUDE_CODE_ENTRYPOINT || "cli";
-}
 
 /**
- * @param {string | undefined} model
- * @returns {string | undefined}
+ * Return the cache_control object appropriate for the given cache policy.
+ * @param {{ttl: string, ttl_supported: boolean, boundary_marker?: boolean} | undefined} cachePolicy
+ * @returns {{type: string, ttl?: string}}
  */
-function logTransformedSystemPrompt(body) {
-  if (!shouldDebugSystemPrompt()) return;
-  if (!body || typeof body !== "string") return;
-
-  try {
-    const parsed = JSON.parse(body);
-    if (!Object.prototype.hasOwnProperty.call(parsed, "system")) return;
-    if (isTitleGeneratorSystemBlocks(normalizeSystemTextBlocks(parsed.system))) return;
-    console.error(
-      "[opencode-anthropic-auth][system-debug] transformed system:",
-      JSON.stringify(parsed.system, null, 2),
-    );
-  } catch {
-    // Ignore parse errors in debug logging path.
+function getCacheControlForPolicy(cachePolicy) {
+  if (!cachePolicy) return { type: "ephemeral" };
+  if (cachePolicy.ttl === "off" || cachePolicy.ttl_supported === false) {
+    return { type: "ephemeral" };
   }
+  return { type: "ephemeral", ttl: cachePolicy.ttl };
 }
 
 /**
- * @param {string | undefined} body
- * @returns {boolean}
- */
-function isHaikuModel(model) {
-  return /haiku/i.test(model);
-}
-
-/**
- * @param {string | undefined} body
- * @returns {boolean}
- */
-function supportsThinking(model) {
-  if (!model) return true;
-  return /claude|sonnet|opus|haiku/i.test(model);
-}
-
-/**
- * Detects claude-opus-4.6 / claude-opus-4-6 model IDs.
- * These models use adaptive thinking (effort parameter) instead of
- * manual budgetTokens.
- * @param {string | undefined} body
- * @returns {boolean}
- */
-function isOpus46Model(model) {
-  if (!model) return false;
-  // Match standard IDs (claude-opus-4-6, claude-opus-4.6) and Bedrock ARNs
-  // (arn:aws:bedrock:...anthropic.claude-opus-4-6-...).
-  // Also match bare "opus-4-6" / "opus-4.6" fragments for non-standard strings.
-  return /claude-opus-4[._-]6|opus[._-]4[._-]6/i.test(model);
-}
-
-/**
- * Detects claude-opus-4.7 / claude-opus-4-7 model IDs.
- * @param {string | undefined} model
- * @returns {boolean}
- */
-function isOpus47Model(model) {
-  if (!model) return false;
-  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
- * `CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT=1`).
- *
- * Real CC's `sR9` matches: `claude-opus-4-7`, any model with `-eap` (early
- * access) suffix, plus a small GrowthBook-controlled allowlist we can't read.
- * Plugin mirrors the deterministic subset only.
- *
- * @param {string | undefined} model
- * @returns {boolean}
- */
-function isSimpleSystemPromptEligible(model) {
-  if (!model) return false;
-  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;
-}
-
-/**
- * Detects claude-sonnet-4.6 / claude-sonnet-4-6 model IDs.
- * @param {string | undefined} body
- * @returns {boolean}
- */
-function isSonnet46Model(model) {
-  if (!model) return false;
-  return /claude-sonnet-4[._-]6|sonnet[._-]4[._-]6/i.test(model);
-}
-
-/**
- * Detects models that support adaptive thinking ({type: "adaptive"}).
- * Currently: Opus 4.6, Opus 4.7, Opus 4.8, and Sonnet 4.6.
- * @param {string | undefined} body
- * @returns {boolean}
- */
-export function isFable5Model(model) {
-  if (!model) return false;
-  return /claude-fable-5|fable[._-]5/i.test(model);
-}
-
-/**
- * @param {string | undefined} model
- * @returns {boolean}
- */
-export function isMythos5Model(model) {
-  if (!model) return false;
-  return /claude-mythos-5|mythos[._-]5/i.test(model);
-}
-
-/**
- * @param {string | undefined} model
- * @returns {boolean}
- */
-export function isAdaptiveThinkingModel(model) {
-  return (
-    isOpus46Model(model) ||
-    isOpus47Model(model) ||
-    isOpus48Model(model) ||
-    isSonnet46Model(model) ||
-    isFable5Model(model) ||
-    isMythos5Model(model)
-  );
-}
-
-/**
- * Check if a model is eligible for 1M context (can receive context-1m beta).
- * Real CC v2.1.97 U01(): claude-sonnet-4* || opus-4-6 are eligible.
- * Also matches explicit "1m" in the name (e.g. "claude-opus-4-6[1m]").
- * @param {string} model
- * @returns {boolean}
- */
-function isEligibleFor1MContext(model) {
-  if (!model) return false;
-  // 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 / 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)
-  );
-}
-
-/**
- * Check if a model should ALWAYS use 1M context (static mode, no adaptive gating).
- * Only models with explicit "1m" in the name — NOT bare Opus 4.6.
- * When adaptive_context is enabled, Opus 4.6 uses the adaptive decision instead.
- * @param {string} model
- * @returns {boolean}
- */
-function hasOneMillionContext(model) {
-  return /(^|[-_ ])1m($|[-_ ])|context[-_]?1m/i.test(model);
-}
-
-/**
- * @param {string | undefined} body
- * @returns {boolean}
- */
-function supportsStructuredOutputs(model) {
-  if (!/claude|sonnet|opus|haiku/i.test(model)) return false;
-  return !isHaikuModel(model);
-}
-
-/**
- * @param {string | undefined} body
- * @returns {boolean}
- */
-function supportsWebSearch(model) {
-  return /claude|sonnet|opus|haiku|gpt|gemini/i.test(model);
-}
-
-/**
- * @param {URL | null} requestUrl
- * @returns {"anthropic" | "bedrock" | "vertex" | "foundry" | "anthropicAws" | "mantle"}
- */
-function detectProvider(requestUrl) {
-  // Match Claude Code provider precedence first (env-driven), then URL fallback.
-  if (isTruthyEnv(process.env.CLAUDE_CODE_USE_BEDROCK)) return "bedrock";
-  if (isTruthyEnv(process.env.CLAUDE_CODE_USE_FOUNDRY)) return "foundry";
-  if (isTruthyEnv(process.env.CLAUDE_CODE_USE_ANTHROPIC_AWS)) return "anthropicAws";
-  if (isTruthyEnv(process.env.CLAUDE_CODE_USE_MANTLE)) return "mantle";
-  if (isTruthyEnv(process.env.CLAUDE_CODE_USE_VERTEX)) return "vertex";
-
-  if (!requestUrl) return "anthropic";
-  const host = requestUrl.hostname.toLowerCase();
-  if (host.includes("mantle")) return "mantle";
-  if (host.includes("anthropicaws")) return "anthropicAws";
-  if (host.includes("bedrock") || host.includes("amazonaws.com")) return "bedrock";
-  if (host.includes("aiplatform") || host.includes("vertex")) return "vertex";
-  if (host.includes("foundry") || host.includes("azure")) return "foundry";
-  return "anthropic";
-}
-
-/**
- * Classify a request by inferred role, mirroring CC's `querySource` gate.
- * CC gates features like context-hint on `querySource.startsWith("repl_main_thread")`.
- * We don't have that string on the wire, so we infer from body shape.
- *
- * Returns one of:
- *   - "main"   → interactive main thread (long system, normal max_tokens, messages present)
- *   - "title"  → title / name generation (tiny max_tokens, 1 message)
- *   - "small"  → short background query (small max_tokens but not title)
- *   - "empty"  → pre-warm / no messages
- *   - "unknown" → treat as main for safety
- *
- * @param {any} parsed Parsed request body
- * @returns {"main"|"title"|"small"|"empty"|"unknown"}
- */
-function classifyRequestRole(parsed) {
-  if (!parsed || typeof parsed !== "object") return "unknown";
-  const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
-  const maxTokens = typeof parsed.max_tokens === "number" ? parsed.max_tokens : null;
-
-  if (messages.length === 0) return "empty";
-  if (maxTokens != null) {
-    if (maxTokens <= 256 && messages.length <= 2) return "title";
-    if (maxTokens <= 1024) return "small";
-  }
-  // System prompt length heuristic
-  let sysLen = 0;
-  if (typeof parsed.system === "string") {
-    sysLen = parsed.system.length;
-  } else if (Array.isArray(parsed.system)) {
-    for (const s of parsed.system) {
-      if (s && typeof s.text === "string") sysLen += s.text.length;
-    }
-  }
-  if (sysLen < 200 && messages.length <= 2 && (maxTokens == null || maxTokens <= 2048)) {
-    return "small";
-  }
-  return "main";
-}
-
-/**
- * @param {any} body
- * @returns {{model: string, tools: any[], messages: any[], hasFileReferences: boolean}}
- */
-function parseRequestBodyMetadata(body, parsedBody) {
-  const parsed =
-    parsedBody ||
-    (typeof body === "string"
-      ? (() => {
-          try {
-            return JSON.parse(body);
-          } catch {
-            return null;
-          }
-        })()
-      : null);
-  if (!parsed) {
-    return { model: "", tools: [], messages: [], hasFileReferences: false };
-  }
-
-  const model = typeof parsed?.model === "string" ? parsed.model : "";
-  const tools = Array.isArray(parsed?.tools) ? parsed.tools : [];
-  const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
-  const hasFileReferences = extractFileIds(parsed).length > 0;
-  return { model, tools, messages, hasFileReferences };
-}
-
-/**
- * @param {any[]} tools
- * @param {any[]} messages
- * @returns {string}
- */
-function buildStainlessHelperHeader(tools, messages) {
-  const helpers = new Set();
-
-  const collect = (value) => {
-    if (!value || typeof value !== "object") return;
-
-    for (const key of STAINLESS_HELPER_KEYS) {
-      if (typeof value[key] === "string" && value[key]) {
-        helpers.add(value[key]);
-      }
-    }
-
-    if (Array.isArray(value.content)) {
-      for (const contentBlock of value.content) {
-        collect(contentBlock);
-      }
-    }
-  };
-
-  for (const tool of tools) collect(tool);
-  for (const message of messages) collect(message);
-
-  return Array.from(helpers).join(", ");
-}
-
-/**
- * @param {{id?: string, accountUuid?: string} | null | undefined} account
- * @returns {string}
- */
-function getAccountIdentifier(account) {
-  // Prefer env-provided account UUID (v2.1.51+), then account record fields
-  const envUuid = process.env.CLAUDE_CODE_ACCOUNT_UUID?.trim();
-  if (envUuid) return envUuid;
-  if (account?.accountUuid && typeof account.accountUuid === "string") {
-    return account.accountUuid;
-  }
-  if (account?.id && typeof account.id === "string") {
-    return account.id;
-  }
-  return "";
-}
-
-/**
- * @param {{persistentUserId: string, accountId: string, sessionId: string}} input
- * @returns {{user_id: string}}
- */
-function buildRequestMetadata(input) {
-  // Backward-compat override: raw user_id passed through without JSON-encoding.
-  const envUserId = process.env.OPENCODE_ANTHROPIC_SIGNATURE_USER_ID?.trim();
-  if (envUserId) return { user_id: envUserId };
-
-  const extraMetadataEnv = process.env.CLAUDE_CODE_EXTRA_METADATA?.trim();
-  let extraMetadata = {};
-  if (extraMetadataEnv) {
-    try {
-      const parsed = JSON.parse(extraMetadataEnv);
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        extraMetadata = parsed;
-      }
-    } catch {
-      /* ignore */
-    }
-  }
-
-  return {
-    user_id: JSON.stringify({
-      ...extraMetadata,
-      device_id: input.persistentUserId,
-      account_uuid: input.accountId,
-      session_id: input.sessionId,
-    }),
-  };
-}
-
-/**
- * Build the billing header block for Claude Code system prompt injection.
- * Claude Code v2.1.97: cc_version includes 3-char fingerprint hash (not model ID).
- * cch is a static "00000" placeholder (xxHash64 attestation removed in v2.1.97).
- *
- * Real CC (system.ts:78): version = `${MACRO.VERSION}.${fingerprint}`
- * Real CC (system.ts:82): cch = ' cch=00000;' (static, no longer computed)
- *
- * @param {string} version - CLI version (e.g., "2.1.97")
- * @param {string} [firstUserMessage] - First user message text for fingerprint computation
- * @param {string} [provider] - API provider ("anthropic" | "bedrock" | "vertex" | "foundry" | "anthropicAws" | "mantle")
- * @param {string} [workloadOverride] - Explicit workload tag from config (`signature_emulation.workload`).
- *   Takes precedence over `CLAUDE_CODE_WORKLOAD` env var. Mirrors real CC's `--workload <tag>` flag.
- * @returns {string}
- */
-function buildAnthropicBillingHeader(version, firstUserMessage, provider, workloadOverride) {
-  if (isFalsyEnv(process.env.CLAUDE_CODE_ATTRIBUTION_HEADER)) return "";
-  // Real CC sends cc_entrypoint=cli (confirmed via proxy capture).
-  const entrypoint = process.env.CLAUDE_CODE_ENTRYPOINT || "cli";
-  // Fix #1: cc_version suffix is the 3-char fingerprint hash, NOT the model ID.
-  // computeBillingCacheHash() computes SHA256(salt + msg[4]+msg[7]+msg[20] + version)[:3]
-  // which matches computeFingerprint() in the real CC source (utils/fingerprint.ts).
-  // Always call the hash function — even for empty messages the real CC computes
-  // the hash from "000" chars (indices 4,7,20 all missing → fallback "0").
-  const fingerprint = computeBillingCacheHash(firstUserMessage || "", version);
-  const ccVersion = `${version}.${fingerprint}`;
-  // cch: v2.1.97 sends static "cch=00000" — xxHash64 attestation was removed.
-  // The server uses the PRESENCE of cch=00000 as a CC identification signal.
-  const cchDisabled = provider === "bedrock" || provider === "anthropicAws" || provider === "mantle";
-  const cchPart = cchDisabled ? "" : " cch=00000;";
-  // Build workload part (upstream concatenates directly, no regex replace).
-  // Config wins over env so `signature_emulation.workload` is portable across hosts.
-  let workloadPart = "";
-  const workload = workloadOverride || process.env.CLAUDE_CODE_WORKLOAD;
-  if (workload && !cchDisabled) {
-    // QA fix M5: sanitize workload value to prevent header injection.
-    // Real CC skips cc_workload on bedrock/anthropicAws/mantle (same gate as cch).
-    const safeWorkload = String(workload).replace(/[;\s\r\n]/g, "_");
-    if (safeWorkload) workloadPart = ` cc_workload=${safeWorkload};`;
-  }
-  return `x-anthropic-billing-header: cc_version=${ccVersion}; cc_entrypoint=${entrypoint};${cchPart}${workloadPart}`;
-}
-
-/**
- * @param {string} text
- * @returns {string}
- */
-// Max system prompt length that passes CC billing validation.
-// The server pattern-matches the system prompt against the real CC prompt.
-// Opencode's customizations after ~5800 chars diverge and trigger extra usage billing.
-const MAX_SAFE_SYSTEM_TEXT_LENGTH = 5000;
-
-// A5: Subagent CC-prefix cache.
-//
-// Context: opencode/packages/opencode/src/session/llm.ts:110 uses
-//   `input.agent.prompt ? [input.agent.prompt] : SystemPrompt.provider(model)`
-// so any agent with a custom prompt (explore, fast, title, summary, etc.)
-// fires WITHOUT the base CC prompt — the server-side fingerprint match fails
-// and the request is billed as pay-as-you-go credits instead of Max-plan usage.
-//
-// Fix: on the first main-agent call (where the anchor is present), cache the
-// sanitized CC prefix. On subsequent subagent calls (anchor missing), prepend
-// the cached prefix to the sanitized blocks so the fingerprint matches again.
-//
-// The cache lives at module scope because buildSystemPromptBlocks is re-entered
-// per request. It gets populated exactly once per process on the first main call.
-const MAX_SUBAGENT_CC_PREFIX = MAX_SAFE_SYSTEM_TEXT_LENGTH;
-const SUBAGENT_CC_ANCHOR = "You are an interactive";
-let cachedCCPrompt = null;
-
-// Perf: module-scope regexes reused across per-request hot paths. None use the
-// `/g` flag and all are consumed via `.test()`, so a single shared instance is
-// stateless and safe (no `lastIndex` to reset between calls).
-const CLAUDE_3_MODEL_RE = /claude-3-/i;
-const TAIL_IMPORTANT_RE = /\b(MUST|NEVER|CRITICAL|IMPORTANT|REQUIRED|DO NOT|ALWAYS|FORBIDDEN)\b/i;
-const TAIL_HEADER_RE = /^#{1,4}\s/;
-const TAIL_LIST_ITEM_RE = /^\s*[-*]\s/;
-
-function sanitizeSystemText(text) {
-  // QA fix M4: use word boundaries to avoid mangling URLs and code identifiers
-  let sanitized = text.replace(/\bOpenCode\b/g, "Claude Code").replace(/\bopencode\b/gi, "Claude");
-  // Strip non-CC custom prefixes before the standard CC prompt.
-  const ccStandardStart = sanitized.indexOf("You are an interactive");
-  if (ccStandardStart > 0) {
-    sanitized = sanitized.slice(ccStandardStart);
-  }
-  // NOTE: truncation removed — real CC v2.1.107 sends 26K+ char system prompts.
-  // The server checks for CC identity/billing markers, not exact prompt length.
-  return sanitized;
-}
-
-/**
- * @param {string} text
- * @param {'minimal' | 'off'} mode
- * @returns {string}
- */
-function tailSystemBlock(text, maxChars, turnThreshold) {
-  const lines = text.split("\n");
-  const kept = [];
-  let charCount = 0;
-  const importantRe = TAIL_IMPORTANT_RE;
-  const headerRe = TAIL_HEADER_RE;
-  const listItemRe = TAIL_LIST_ITEM_RE;
-  // Always keep the first paragraph (identity/role definition)
-  let firstParaEnd = 0;
-  for (let j = 0; j < lines.length; j++) {
-    if (lines[j].trim() === "" && j > 0) {
-      firstParaEnd = j;
-      break;
-    }
-  }
-  if (firstParaEnd === 0) firstParaEnd = Math.min(5, lines.length);
-  for (let j = 0; j <= firstParaEnd; j++) {
-    kept.push(lines[j]);
-    charCount += (lines[j]?.length || 0) + 1;
-  }
-  // Scan remaining lines: keep headers, important constraints, short list items
-  for (let j = firstParaEnd + 1; j < lines.length; j++) {
-    const line = lines[j];
-    const isHeader = headerRe.test(line);
-    const isImportant = importantRe.test(line);
-    const isShortListItem = listItemRe.test(line) && line.length < 120;
-    if (isHeader || isImportant || isShortListItem) {
-      if (charCount + line.length + 1 > maxChars) break;
-      kept.push(line);
-      charCount += line.length + 1;
-    }
-  }
-  kept.push("", "[Verbose instructions trimmed after turn " + turnThreshold + ". Key constraints preserved above.]");
-  return kept.join("\n");
-}
-
-function compactToolDescription(text) {
-  return text
-    .replace(/<example[\s\S]*?<\/example>/gi, "")
-    .replace(/\|[\s|:-]+\|/g, "")
-    .replace(/^\|.*\|$/gm, "")
-    .replace(/^(?:\s*[-*]\s+.{200,})$/gm, (m) => m.slice(0, 200) + "...")
-    .replace(/^(#{1,3}\s+)/gm, "")
-    .replace(/\*\*([^*]+)\*\*/g, "$1")
-    .replace(/`([^`]+)`/g, "$1")
-    .replace(/\n{3,}/g, "\n\n")
-    .trim();
-}
-
-function compactSystemText(text, mode) {
-  const withoutDuplicateIdentityPrefix = text.startsWith(`${CLAUDE_CODE_IDENTITY_STRING}\n`)
-    ? text.slice(CLAUDE_CODE_IDENTITY_STRING.length).trimStart()
-    : text;
-
-  if (mode === "off") {
-    return withoutDuplicateIdentityPrefix.trim();
-  }
-
-  const compacted = withoutDuplicateIdentityPrefix.replace(/<example>[\s\S]*?<\/example>/gi, "\n");
-
-  const dedupedLines = [];
-  let prevNormalized = "";
-  for (const line of compacted.split("\n")) {
-    const normalized = line.trim();
-    if (normalized && normalized === prevNormalized) continue;
-    dedupedLines.push(line);
-    prevNormalized = normalized;
-  }
-
-  return dedupedLines
-    .join("\n")
-    .replace(/\n{3,}/g, "\n\n")
-    .trim();
-}
-
-/**
- * @param {string} text
- * @returns {string}
- */
-function normalizeSystemTextForComparison(text) {
-  return text
-    .replace(/\r\n/g, "\n")
-    .split("\n")
-    .map((line) => line.trim())
-    .join("\n")
-    .replace(/\n{3,}/g, "\n\n")
-    .trim();
-}
-
-/**
- * @param {Array<{type: string, text: string, cache_control?: {type: string}}>} system
- * @returns {Array<{type: string, text: string, cache_control?: {type: string}}>}
- */
-function dedupeSystemBlocks(system) {
-  const exactSeen = new Set();
-  const exactDeduped = [];
-
-  for (const item of system) {
-    const normalized = normalizeSystemTextForComparison(item.text);
-    const key = `${item.type}:${normalized}`;
-    if (exactSeen.has(key)) continue;
-    exactSeen.add(key);
-    exactDeduped.push(item);
-  }
-
-  const normalizedBlocks = exactDeduped.map((item) => normalizeSystemTextForComparison(item.text));
-  return exactDeduped.filter((_, index) => {
-    const current = normalizedBlocks[index];
-    if (current.length < 80) return true;
-
-    for (let otherIndex = 0; otherIndex < normalizedBlocks.length; otherIndex += 1) {
-      if (otherIndex === index) continue;
-      const other = normalizedBlocks[otherIndex];
-      if (other.length <= current.length + 20) continue;
-      if (other.includes(current)) return false;
-    }
-
-    return true;
-  });
-}
-
-/**
- * @param {string} text
- * @returns {boolean}
- */
-function isTitleGeneratorSystemText(text) {
-  const normalized = text.trim().toLowerCase();
-  return normalized.includes("you are a title generator") || normalized.includes("generate a brief title");
-}
-
-/**
- * @param {Array<{type: string, text: string, cache_control?: {type: string}}>} system
- * @returns {boolean}
- */
-function isTitleGeneratorSystemBlocks(system) {
-  return system.some(
-    (item) => item.type === "text" && typeof item.text === "string" && isTitleGeneratorSystemText(item.text),
-  );
-}
-
-/**
- * @param {any[] | undefined} system
- * @returns {Array<{type: string, text: string, cache_control?: {type: string}}>}
- */
-// Env-context fingerprint rewrite: opencode emits
-//   "Here is some useful information about the environment you are running in:"
-// Real CC 2.1.117 emits
-//   "Here is useful information about the environment you are running in:"
-// Removing "some " gives byte-level parity with the CC fingerprint and saves
-// ~1 token in the non-cached portion. Unconditional, every request.
-const OPENCODE_ENV_CONTEXT_PREFIX = "Here is some useful information about the environment you are running in:";
-const CC_ENV_CONTEXT_PREFIX = "Here is useful information about the environment you are running in:";
-
-function rewriteEnvContextPhrasing(text) {
-  if (typeof text !== "string" || text.length === 0) return text;
-  if (text.indexOf(OPENCODE_ENV_CONTEXT_PREFIX) === -1) return text;
-  return text.split(OPENCODE_ENV_CONTEXT_PREFIX).join(CC_ENV_CONTEXT_PREFIX);
-}
-
-function normalizeSystemTextBlocks(system) {
-  const output = [];
-  if (!Array.isArray(system)) return output;
-
-  for (const item of system) {
-    if (typeof item === "string") {
-      output.push({ type: "text", text: rewriteEnvContextPhrasing(item) });
-      continue;
-    }
-
-    if (!item || typeof item !== "object") continue;
-    if (typeof item.text !== "string") continue;
-
-    const normalized = {
-      type: typeof item.type === "string" ? item.type : "text",
-      text: rewriteEnvContextPhrasing(item.text),
-    };
-
-    // Intentionally strip cache_control from incoming system blocks.
-    // The plugin controls cache placement: only the identity block and
-    // boundary-split blocks get cache_control (added in buildSystemPromptBlocks).
-    // Passing through upstream markers can cause "maximum of 4 blocks with
-    // cache_control" API errors when combined with our own markers.
-
-    output.push(normalized);
-  }
-
-  return output;
-}
-
-/**
- * Return the cache_control object appropriate for the given cache policy.
- * @param {{ttl: string, ttl_supported: boolean, boundary_marker?: boolean} | undefined} cachePolicy
- * @returns {{type: string, ttl?: string}}
- */
-function getCacheControlForPolicy(cachePolicy) {
-  if (!cachePolicy) return { type: "ephemeral" };
-  if (cachePolicy.ttl === "off" || cachePolicy.ttl_supported === false) {
-    return { type: "ephemeral" };
-  }
-  return { type: "ephemeral", ttl: cachePolicy.ttl };
-}
-
-/**
- * Determine the identity string prefix, matching real CC's getCLISyspromptPrefix().
- * Real CC selects based on isNonInteractive + hasAppendSystemPrompt flags.
- * OpenCode is always interactive CLI, so DEFAULT_PREFIX is almost always correct.
- * We check for Agent SDK signals from the environment to match non-interactive cases.
- *
- * @returns {string}
- */
-function getCLISyspromptPrefix() {
-  // Agent SDK preset: when running within the Claude Agent SDK with CC preset
-  if (isTruthyEnv(process.env.CLAUDE_AGENT_SDK_VERSION) && isTruthyEnv(process.env.CLAUDE_CODE_ENTRYPOINT)) {
-    const entrypoint = process.env.CLAUDE_CODE_ENTRYPOINT || "";
-    if (entrypoint === "agent-sdk" || entrypoint === "sdk") {
-      return "You are Claude Code, Anthropic's official CLI for Claude, running within the Claude Agent SDK.";
-    }
-  }
-  // Non-interactive agent without CC preset
-  if (isTruthyEnv(process.env.CLAUDE_AGENT_SDK_VERSION) && !isTruthyEnv(process.env.CLAUDE_CODE_ENTRYPOINT)) {
-    return "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
-  }
-  return CLAUDE_CODE_IDENTITY_STRING;
-}
-
-/**
- * Compute the cache_control object for a given cache scope and policy.
- * Mirrors real CC getCacheControl() (src/services/api/claude.ts:358-374).
- *
- * Real CC behavior:
- * - scope 'global' → {type: 'ephemeral', scope: 'global', ttl?: '1h'}
- * - scope 'org'    → {type: 'ephemeral', ttl?: '1h'} (org is internal, NOT on wire)
- * - scope null     → block gets NO cache_control at all (caller should omit it)
- *
- * @param {'global' | 'org' | null} cacheScope
- * @param {{ttl: string, ttl_supported: boolean}} cachePolicy
- * @returns {{type: string, ttl?: string, scope?: string} | null} null means "no cache_control"
- */
-function getCacheControlForScope(cacheScope, cachePolicy) {
-  if (cacheScope === null) return null; // no cache_control for this block
-
-  const hasTtl = cachePolicy.ttl !== "off" && cachePolicy.ttl_supported !== false;
-  const result = { type: "ephemeral" };
-  if (hasTtl) result.ttl = cachePolicy.ttl;
-  // Only 'global' scope is emitted on the wire; 'org' is internal-only
-  if (cacheScope === "global") result.scope = "global";
-  return result;
-}
-
-/**
- * Split system prompt blocks into structured blocks with cache scoping,
- * matching real CC splitSysPromptPrefix() (src/utils/api.ts:321-435).
- *
- * Real CC has 3 paths that produce 2 distinct wire formats:
- *
- * Path A (tool-based cache): skipGlobalCacheForSystemPrompt=true
- *   - billing → cacheScope: null
- *   - identity → cacheScope: 'org'
- *   - rest (joined) → cacheScope: 'org'
- *   Wire result: identical to Path C (org → ephemeral without scope field)
- *
- * Path B (boundary mode): shouldUseGlobalCacheScope() && boundary marker found
- *   - billing → cacheScope: null
- *   - identity → cacheScope: null (NO cache_control in boundary mode!)
- *   - static blocks (before boundary, joined) → cacheScope: 'global'
- *   - dynamic blocks (after boundary, joined) → cacheScope: null
- *
- * Path C (fallback): no global cache feature or no boundary
- *   - billing → cacheScope: null
- *   - identity → cacheScope: 'org'
- *   - rest (joined) → cacheScope: 'org'
- *
- * @param {Array<{text: string}>} blocks - Already sanitized/filtered text blocks
- * @param {string | undefined} attributionHeader - The billing header text (or undefined)
- * @param {string} identityString - The identity prefix string
- * @param {boolean} useBoundaryMode - Whether to use Path B (global cache with boundary)
- * @returns {Array<{text: string, cacheScope: 'global' | 'org' | null}>}
- */
-function splitSysPromptPrefix(blocks, attributionHeader, identityString, useBoundaryMode) {
-  // Separate known blocks from rest, matching real CC's parsing loop
-  const rest = [];
-  for (const block of blocks) {
-    if (!block.text) continue;
-    // Skip if it's a billing header or identity string (already extracted)
-    if (block.text.startsWith("x-anthropic-billing-header:")) continue;
-    if (KNOWN_IDENTITY_STRINGS.has(block.text)) continue;
-    // Skip the boundary marker itself (real CC skips it in Path A, processes it in Path B)
-    if (block.text === SYSTEM_PROMPT_DYNAMIC_BOUNDARY) continue;
-    rest.push(block.text);
-  }
-
-  // ====================================================================
-  // Path B: Global cache with boundary marker
-  // Real CC (utils/api.ts:219-262): when shouldUseGlobalCacheScope() &&
-  // boundary marker is found in the system prompt array.
-  // ====================================================================
-  if (useBoundaryMode) {
-    // Find boundary marker in the ORIGINAL block array (before filtering)
-    const boundaryIndex = blocks.findIndex((b) => b.text === SYSTEM_PROMPT_DYNAMIC_BOUNDARY);
-
-    if (boundaryIndex !== -1) {
-      // Classify blocks as static (before boundary) or dynamic (after boundary)
-      const staticBlocks = [];
-      const dynamicBlocks = [];
-      for (let i = 0; i < blocks.length; i++) {
-        const text = blocks[i].text;
-        if (!text) continue;
-        if (text === SYSTEM_PROMPT_DYNAMIC_BOUNDARY) continue;
-        if (text.startsWith("x-anthropic-billing-header:")) continue;
-        if (KNOWN_IDENTITY_STRINGS.has(text)) continue;
-        if (i < boundaryIndex) {
-          staticBlocks.push(text);
-        } else {
-          dynamicBlocks.push(text);
-        }
-      }
-
-      const result = [];
-      if (attributionHeader) result.push({ text: attributionHeader, cacheScope: null });
-      // Identity: cacheScope null in boundary mode (real CC behavior)
-      result.push({ text: identityString, cacheScope: null });
-      const staticJoined = staticBlocks.join("\n");
-      if (staticJoined) result.push({ text: staticJoined, cacheScope: "global" });
-      const dynamicJoined = dynamicBlocks.join("\n");
-      if (dynamicJoined) result.push({ text: dynamicJoined, cacheScope: null });
-      return result;
-    }
-    // Boundary marker not found — fall through to Path C
-  }
-
-  // ====================================================================
-  // Path C (fallback) / Path A (tool-based): no boundary or no global cache
-  // Real CC (utils/api.ts:264-289): identity and rest get cacheScope 'org'
-  // Path A produces identical wire output to Path C.
-  // ====================================================================
-  const result = [];
-  if (attributionHeader) result.push({ text: attributionHeader, cacheScope: null });
-  result.push({ text: identityString, cacheScope: "org" });
-  const restJoined = rest.join("\n");
-  if (restJoined) result.push({ text: restJoined, cacheScope: "org" });
-  return result;
-}
-
-/**
- * @param {Array<{type: string, text: string, cache_control?: {type: string}}>} system
- * @param {{enabled: boolean, claudeCliVersion: string, promptCompactionMode: 'minimal' | 'off', cachePolicy?: {ttl: string, ttl_supported: boolean, boundary_marker?: boolean}}} signature
- * @returns {Array<{type: string, text: string, cache_control?: {type: string}}>}
- */
-function buildSystemPromptBlocks(system, signature) {
-  const titleGeneratorRequest = isTitleGeneratorSystemBlocks(system);
-
-  let sanitized = system.map((item) => ({
-    ...item,
-    text: compactSystemText(sanitizeSystemText(item.text), signature.promptCompactionMode),
-  }));
-
-  // A5: Subagent CC-prefix cache/inject (see constant declaration above for context).
-  //
-  // After sanitize, main-agent blocks start with "You are an interactive..." because
-  // sanitizeSystemText() strips everything before that anchor. Subagent blocks
-  // (custom prompts from input.agent.prompt) do NOT start with the anchor —
-  // they start with whatever the agent template says (e.g., "You are a file search
-  // specialist.").
-  //
-  // This logic runs ONLY for Anthropic requests with signature enabled (signature.enabled
-  // is false for non-Anthropic providers), and skips the title-generator fast path
-  // because that one is replaced wholesale with COMPACT_TITLE_GENERATOR_SYSTEM_PROMPT below.
-  if (signature.enabled && !titleGeneratorRequest && sanitized.length > 0) {
-    const firstText = typeof sanitized[0]?.text === "string" ? sanitized[0].text : "";
-    const hasCcAnchor = firstText.startsWith(SUBAGENT_CC_ANCHOR);
-
-    if (hasCcAnchor) {
-      // Main-agent path: cache the prefix on the first hit so subagents can reuse it.
-      // We slice to MAX_SUBAGENT_CC_PREFIX to avoid unbounded growth if the upstream
-      // sanitize limit is ever raised.
-      if (!cachedCCPrompt) {
-        cachedCCPrompt = firstText.slice(0, MAX_SUBAGENT_CC_PREFIX);
-      }
-    } else if (cachedCCPrompt) {
-      // Subagent path: prepend the cached CC prefix so the fingerprint matches.
-      // We prepend, not concatenate, so the original subagent prompt stays as a
-      // separate block — dedupeSystemBlocks and splitSysPromptPrefix handle the
-      // join on their own downstream.
-      sanitized = [{ type: "text", text: cachedCCPrompt }, ...sanitized];
-    }
-    // If !hasCcAnchor && !cachedCCPrompt: no-op. The cache primes on the very
-    // first main call in a process. In practice opencode always fires a main
-    // call before any subagent, so this branch is only hit in synthetic tests.
-  }
-
-  if (titleGeneratorRequest) {
-    sanitized = [{ type: "text", text: COMPACT_TITLE_GENERATOR_SYSTEM_PROMPT }];
-  } else if (signature.promptCompactionMode !== "off") {
-    sanitized = dedupeSystemBlocks(sanitized);
-  }
-
-  // Anti-verbosity injection (CC v2.1.100 quiet_salted_ember equivalent).
-  // Applies to Opus 4.6 / 4.7 for non-title-generator requests.
-  //
-  // Simple-system-prompt gate (CC v2.1.133+ `tengu_vellum_lantern` equivalent):
-  // when `signature.simpleSystemPrompt` is true AND the model is eligible
-  // (Opus 4.7, -eap variants), skip the anti-verbosity boilerplate. Real CC's
-  // simple-prompt mode strips this kind of post-hoc behavioral hand-holding on
-  // models that don't need it. Conservative implementation: gates ONLY the
-  // anti-verbosity push, not the identity / billing / sanitized blocks. Saves
-  // ~600-1500 tokens per request on eligible models without touching the CC
-  // fingerprint markers the server checks.
-  const skipAntiVerbosity = signature.simpleSystemPrompt === true && isSimpleSystemPromptEligible(signature.modelId);
-
-  if (
-    !titleGeneratorRequest &&
-    !skipAntiVerbosity &&
-    signature.modelId &&
-    (isOpus46Model(signature.modelId) || isOpus47Model(signature.modelId))
-  ) {
-    const avConfig = signature.antiVerbosity;
-    if (avConfig?.enabled !== false) {
-      sanitized.push({ type: "text", text: ANTI_VERBOSITY_SYSTEM_PROMPT });
-    }
-    if (avConfig?.length_anchors !== false) {
-      sanitized.push({ type: "text", text: NUMERIC_LENGTH_ANCHORS_PROMPT });
-    }
-  }
-
-  if (!signature.enabled) {
-    return sanitized;
-  }
-
-  // Lean system prompt for non-main requests (title-gen is already handled
-  // above via the COMPACT_TITLE_GENERATOR_SYSTEM_PROMPT swap). For "title"
-  // and "small" request roles — one-off queries that don't belong to the main
-  // REPL thread — we skip billing identity + CC identity injection. This
-  // matches the spirit of real CC's querySource gates: identity context is
-  // for interactive main-thread conversations, not fire-and-forget calls.
-  // Opt-in (default off) because it changes the system-prompt shape.
-  const leanNonMain =
-    signature.leanNonMain === true &&
-    (signature.requestRole === "title" || signature.requestRole === "small") &&
-    !titleGeneratorRequest;
-  if (leanNonMain) {
-    return sanitized;
-  }
-
-  // Build attribution header
-  const billingHeader = buildAnthropicBillingHeader(
-    signature.claudeCliVersion,
-    signature.firstUserMessage,
-    signature.provider,
-    signature.workload,
-  );
-
-  // Select the identity string (matches real CC getCLISyspromptPrefix())
-  const identityString = getCLISyspromptPrefix();
-
-  // Determine cache policy
-  const effectiveCachePolicy = signature.cachePolicy || { ttl: "1h", ttl_supported: true };
-
-  // Determine if we should use boundary mode (Path B)
-  // Real CC: shouldUseGlobalCacheScope() is a GrowthBook feature flag.
-  // We simulate it via config: boundary_marker=true or CLAUDE_CODE_FORCE_GLOBAL_CACHE=1.
-  const useBoundaryMode =
-    effectiveCachePolicy.boundary_marker || isTruthyEnv(process.env.CLAUDE_CODE_FORCE_GLOBAL_CACHE);
-
-  // Run the real CC splitSysPromptPrefix algorithm to get blocks with cacheScope
-  const scopedBlocks = splitSysPromptPrefix(sanitized, billingHeader || undefined, identityString, useBoundaryMode);
-
-  // Convert scoped blocks to wire format using getCacheControlForScope
-  // (mirrors real CC buildSystemPromptBlocks → map + getCacheControl)
-  return scopedBlocks.map((block) => {
-    const cc = getCacheControlForScope(block.cacheScope, effectiveCachePolicy);
-    return {
-      type: "text",
-      text: block.text,
-      ...(cc !== null && { cache_control: cc }),
-    };
-  });
-}
-
-/**
- * @param {string} incomingBeta
- * @param {boolean} signatureEnabled
- * @param {string} model
- * @param {"anthropic" | "bedrock" | "vertex" | "foundry" | "anthropicAws" | "mantle"} provider
- * @param {string[]} [customBetas]
- * @param {import('./lib/config.mjs').AccountSelectionStrategy} [strategy]
- * @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}
- */
-// Mirrors CC's Kw(model) effort eligibility: returns false for claude-3-* and the
-// explicit older 4.x exclusion set (opus-4-0/4-1, sonnet-4-0/4-5, haiku-4-5), true
-// for every other model (effort-capable: Opus 4.5/4.6/4.7/4.8, Sonnet 4.6, etc.).
-const _EFFORT_EXCLUDED_MODELS = [
-  /claude-opus-4-0/i,
-  /claude-opus-4-1/i,
-  /claude-sonnet-4-0/i,
-  /claude-sonnet-4-5/i,
-  /claude-haiku-4-5/i,
-];
-function isEffortCapableModel(model) {
-  if (!model) return false;
-  if (CLAUDE_3_MODEL_RE.test(model)) return false;
-  return !_EFFORT_EXCLUDED_MODELS.some((re) => re.test(model));
-}
-
-function buildAnthropicBetaHeader(
-  incomingBeta,
-  signatureEnabled,
-  model,
-  provider,
-  customBetas,
-  strategy,
-  requestPath,
-  hasFileReferences,
-  adaptiveOverride,
-  tokenEconomy,
-  microcompactBetas, // NEW 11th param
-  fastModeActive, // NEW 12th param — see @param above
-) {
-  const incomingBetasList = incomingBeta
-    .split(",")
-    .map((b) => b.trim())
-    .filter(Boolean);
-
-  const betas = ["oauth-2025-04-20"];
-  const disableExperimentalBetas = isTruthyEnv(process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS);
-  const isMessagesCountTokensPath = requestPath === "/v1/messages/count_tokens";
-  const isFilesEndpoint = requestPath?.startsWith("/v1/files") ?? false;
-
-  if (!signatureEnabled) {
-    betas.push("interleaved-thinking-2025-05-14");
-    if (isMessagesCountTokensPath) {
-      betas.push(TOKEN_COUNTING_BETA_FLAG);
-    }
-    let mergedBetas = [...new Set([...betas, ...incomingBetasList])];
-    if (disableExperimentalBetas) {
-      mergedBetas = mergedBetas.filter((beta) => !EXPERIMENTAL_BETA_FLAGS.has(beta));
-    }
-    return mergedBetas.join(",");
-  }
-
-  const nonInteractive = isNonInteractiveMode();
-  const haiku = isHaikuModel(model);
-  const isRoundRobin = strategy === "round-robin";
-  const te = tokenEconomy || {};
-
-  // === ALWAYS-ON BETAS (Claude Code v2.1.90 base set) ===
-  // These are ALWAYS included regardless of env vars or feature flags.
-  // NOTE: Real Claude Code skips this beta for Haiku, but we include it
-  // so that Haiku subagents (via model-router delegation) get full mimic
-  // behavior from the Anthropic API.
-  betas.push(CLAUDE_CODE_BETA_FLAG); // "claude-code-20250219"
-
-  // v2.1.150: advanced-tool-use / tool-search-tool removed from always-on.
-  // CC 2.1.150 D5q does not push these per-request. Available via custom betas.
-
-  // v2.1.150: fast-mode-2026-02-01 removed from always-on (CC sends only when speed feature active).
-
-  // v2.1.195: effort-2025-11-24 is no longer always-on; it is now a model-gated
-  // default emitted in the conditional section below for effort-capable models
-  // (mirrors CC's Kw(model)).
-
-  // Interleaved thinking — real CC's i01 pushes via hv4(model), which is
-  // (firstParty && non-Claude-3). Claude 3.x models don't support interleaved
-  // thinking and real CC never sends this flag for them, so emitting it
-  // diverges the fingerprint for legacy Haiku/Sonnet 3.x requests.
-  if (!isTruthyEnv(process.env.DISABLE_INTERLEAVED_THINKING) && !CLAUDE_3_MODEL_RE.test(model)) {
-    betas.push("interleaved-thinking-2025-05-14");
-  }
-
-  // Context 1M — when adaptive override is provided, use it; otherwise fall back to static check.
-  {
-    const use1M =
-      adaptiveOverride && typeof adaptiveOverride.use1MContext === "boolean"
-        ? adaptiveOverride.use1MContext
-        : hasOneMillionContext(model);
-    if (use1M) {
-      betas.push("context-1m-2025-08-07");
-    }
-  }
-
-  // Prompt caching scope — always-on EXCEPT in round-robin (per-workspace state conflicts)
-  if (!isRoundRobin) {
-    betas.push("prompt-caching-scope-2026-01-05");
-  }
-  // v2.1.150: extended-cache-ttl for better cache hit rates (opt-out via token_economy.extended_cache_ttl = false).
-  if (te.extended_cache_ttl !== false && !isRoundRobin) {
-    betas.push("extended-cache-ttl-2025-04-11");
-  }
-
-  // === CONDITIONAL BETAS (model/context-dependent) ===
-
-  // First-party provider predicate (OAuth path). Mirrors CC's ZO(provider) which
-  // excludes bedrock/vertex/mantle. context-management and effort are first-party
-  // only here, so they must never be pushed on bedrock/vertex.
-  const isFirstPartyProvider = provider !== "vertex" && provider !== "bedrock" && provider !== "mantle";
-
-  // v2.1.195: context-management-2025-06-27 is default-ON for first-party non-claude-3
-  // models (incl. Haiku 4.5), mirroring CC's n0d(model) eligibility path. Earlier
-  // analyses read only the separate USE_API_CONTEXT_MANAGEMENT env term (hardcoded
-  // && false) and recorded it as off; 2.1.195 confirms it ships by default for modern
-  // first-party models. Opt out via token_economy.context_management = false.
-  if (te.context_management !== false && isFirstPartyProvider && !CLAUDE_3_MODEL_RE.test(model)) {
-    betas.push("context-management-2025-06-27");
-  }
-
-  // v2.1.195: effort-2025-11-24 is a model-gated default for effort-capable models
-  // (Opus 4.5/4.6/4.7/4.8, Sonnet 4.6), mirroring CC's Kw(model). Excluded for
-  // claude-3-*, opus-4-0, opus-4-1, sonnet-4-0, sonnet-4-5, haiku-4-5. First-party
-  // only; opt out via token_economy.effort = false.
-  if (te.effort !== false && isFirstPartyProvider && isEffortCapableModel(model)) {
-    betas.push(_EFFORT_BETA_FLAG);
-  }
-
-  // v2.1.150: structured-outputs gated behind opt-in (CC has behind tengu_tool_pear flag).
-  if (te.structured_outputs && supportsStructuredOutputs(model)) {
-    betas.push("structured-outputs-2025-12-15");
-  }
-
-  // Web search — for models that support it
-  if (supportsWebSearch(model)) {
-    betas.push("web-search-2025-03-05");
-  }
-
-  // Advisor tool — in CC this is gated by server-side feature flag
-  // (tengu_sage_compass2) and firstParty+isLoggedIn. Since we can't check
-  // CC's feature flags, include it unconditionally for Claude 4+ models.
-  // CC v108 sends it in MITM captures for Max/Pro users.
-  if (!CLAUDE_3_MODEL_RE.test(model)) {
-    betas.push("advisor-tool-2026-03-01");
-  }
-
-  // context-hint-2026-04-09 — introduced in CC v2.1.110. Paired with the body
-  // field `context_hint: { enabled: true }` (injected in transformRequestBody).
-  // Real CC gates it on includeFirstPartyBetas + querySource startsWith
-  // "repl_main_thread" (i.e. interactive sessions on 1P Anthropic only).
-  // Server responds with hints suggesting which messages to forget for
-  // token-efficient context compaction. Sticky: disabled permanently on
-  // 400/409/529 errors referencing the hint. Users can opt out via
-  // token_economy.context_hint = false.
-  // Mimicry note: real CC gates context-hint on querySource.startsWith("repl_main_thread").
-  // We infer main-thread from body shape via classifyRequestRole and pass it via
-  // tokenEconomy.__requestRole. Treat absent marker as "main" for backward compat.
-  const _isMainThread = te.__requestRole == null || te.__requestRole === "main";
-  if (isFirstPartyProvider && !CLAUDE_3_MODEL_RE.test(model) && te.context_hint !== false && _isMainThread) {
-    betas.push("context-hint-2026-04-09");
-  }
-
-  // Files API — scoped to file endpoints/references
-  if (isFilesEndpoint || hasFileReferences) {
-    betas.push("files-api-2025-04-14");
-  }
-
-  // Token counting endpoint
-  if (isMessagesCountTokensPath) {
-    betas.push(TOKEN_COUNTING_BETA_FLAG);
-  }
-
-  // === TOKEN ECONOMY BETAS (on by default for token savings) ===
-
-  // v2.1.150: redact-thinking is default-ON in CC (first-party, non-SDK, thinking models).
-  // Opt out via `/anthropic set redact-thinking off` to see thinking content.
-  if (te.redact_thinking !== false && !disableExperimentalBetas && !CLAUDE_3_MODEL_RE.test(model)) {
-    betas.push("redact-thinking-2026-02-12");
-  }
-
-  // v2.1.150: thinking-token-count for token budget tracking (behind tengu_chert_bezel in CC).
-  // Default ON for token economy visibility. Opt out via token_economy.thinking_token_count = false.
-  if (te.thinking_token_count !== false && !disableExperimentalBetas && !CLAUDE_3_MODEL_RE.test(model)) {
-    betas.push("thinking-token-count-2026-05-13");
-  }
-
-  // compact-2026-01-12 and mcp-client-2025-11-20 exist only in docs, not runtime.
-
-  // afk-mode — NOT auto-included (requires user opt-in)
-  // Available via: /anthropic betas add afk-mode-2026-01-31
-
-  // === MICROCOMPACT BETAS (context-aware, Phase 3 Task 3.4) ===
-  if (microcompactBetas?.length) {
-    for (const mb of microcompactBetas) {
-      if (!betas.includes(mb)) betas.push(mb);
-    }
-  }
-
-  // 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.
-  const filteredIncoming = incomingBetasList.filter((b) => !HOST_SDK_BETAS_BLOCKLIST.has(b));
-  let mergedBetas = [...new Set([...betas, ...filteredIncoming])];
-
-  // Add custom betas from config
-  if (customBetas?.length) {
-    for (const custom of customBetas) {
-      const resolved = BETA_SHORTCUTS.get(custom) || custom;
-      if (resolved && !mergedBetas.includes(resolved)) {
-        mergedBetas.push(resolved);
-      }
-    }
-  }
-
-  // Filter out experimental betas only if explicitly disabled.
-  // WARNING: The EXPERIMENTAL_BETA_FLAGS set overlaps with most always-on betas.
-  // Enabling CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS effectively strips Claude Code
-  // mimicry betas, leaving only oauth-2025-04-20, claude-code-20250219, and effort-*.
-  // Use this escape hatch only for debugging or when betas cause API rejections.
-  if (disableExperimentalBetas) {
-    mergedBetas = mergedBetas.filter((beta) => !EXPERIMENTAL_BETA_FLAGS.has(beta));
-  }
-
-  // Remove betas unsupported by Bedrock
-  if (provider === "bedrock") {
-    mergedBetas = mergedBetas.filter((beta) => !BEDROCK_UNSUPPORTED_BETAS.has(beta));
-  }
-
-  return mergedBetas.join(",");
-}
-
-/** @typedef {'low' | 'medium' | 'high'} ThinkingEffort */
-
-/**
- * Map budgetTokens to an effort level.
- * Used when an Opus 4.6 request arrives with the legacy budgetTokens shape.
- * @param {number} budgetTokens
- * @returns {ThinkingEffort}
- */
-function budgetTokensToEffort(budgetTokens) {
-  if (budgetTokens <= 1024) return "low";
-  if (budgetTokens <= 8000) return "medium";
-  return "high";
-}
-
-// QA fix L3: budgetTokensToEffort() removed — dead code, never called
-// QA fix L4: isValidEffort() removed — dead code, never called
-
-/**
- * Normalise the `thinking` block in the request body for the target model:
- * - 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
+ * @param {string} incomingBeta
+ * @param {boolean} signatureEnabled
  * @param {string} model
- * @returns {any}
- */
-function normalizeThinkingBlock(thinking, model) {
-  // If thinking is absent or not an object, pass through
-  if (!thinking || typeof thinking !== "object") {
-    return thinking;
-  }
-
-  // Adaptive thinking models always get { type: "adaptive" }
-  // regardless of what format the incoming thinking block has
-  if (isAdaptiveThinkingModel(model)) {
-    // Check for env-var override to force budget_tokens fallback
-    if (isTruthyEnv(process.env.OPENCODE_ANTHROPIC_DISABLE_ADAPTIVE_THINKING)) {
-      // Fallback: return as-is if already budget_tokens shape, otherwise default
-      if (thinking.type === "enabled" && typeof thinking.budget_tokens === "number") {
-        return thinking;
-      }
-      const parsedBudget = parseInt(process.env.MAX_THINKING_TOKENS, 10);
-      return { type: "enabled", budget_tokens: Number.isNaN(parsedBudget) ? 16000 : parsedBudget };
-    }
-    return { type: "adaptive" };
-  }
-
-  // Non-adaptive models: pass through unchanged
-  return thinking;
-}
-
-/**
- * Map Node.js platform to Stainless OS header value.
- * @param {NodeJS.Platform} value
- * @returns {string}
- */
-function getStainlessOs(value) {
-  if (value === "darwin") return "macOS";
-  if (value === "win32") return "Windows";
-  if (value === "linux") return "Linux";
-  return value;
-}
-
-/**
- * Normalize Node.js arch to Stainless arch header value.
- * @param {string} value
- * @returns {string}
- */
-function getStainlessArch(value) {
-  if (value === "x64") return "x64";
-  if (value === "arm64") return "arm64";
-  return value;
-}
-
-/**
- * Resolve latest claude-code package version from npm registry.
- * Returns null on timeout/network/parse failures.
- * @param {number} timeoutMs
- * @returns {Promise<string | null>}
- */
-async function fetchLatestClaudeCodeVersion(timeoutMs = 1200) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetch(CLAUDE_CODE_NPM_LATEST_URL, {
-      method: "GET",
-      headers: { accept: "application/json" },
-      signal: controller.signal,
-    });
-    if (!response.ok) return null;
-    const data = await response.json();
-    if (!data || typeof data !== "object") return null;
-    return typeof data.version === "string" && data.version ? data.version : null;
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-/**
- * Build request headers from input and init, applying OAuth requirements.
- * Preserves behaviors D1-D7.
- *
- * @param {any} input
- * @param {Record<string, any>} requestInit
- * @param {string} accessToken
- * @param {string | undefined} requestBody
- * @param {URL | null} requestUrl
- * @param {{enabled: boolean, claudeCliVersion: string, strategy?: import('./lib/config.mjs').AccountSelectionStrategy, customBetas?: string[], sessionId?: string}} signature
- * @returns {Headers}
- */
-function buildRequestHeaders(
-  input,
-  requestInit,
-  accessToken,
-  requestBody,
-  requestUrl,
-  signature,
-  adaptiveOverride,
-  tokenEconomy,
-) {
-  const requestHeaders = new Headers();
-  if (input instanceof Request) {
-    input.headers.forEach((value, key) => {
-      requestHeaders.set(key, value);
-    });
-  }
-  if (requestInit.headers) {
-    if (requestInit.headers instanceof Headers) {
-      requestInit.headers.forEach((value, key) => {
-        requestHeaders.set(key, value);
-      });
-    } else if (Array.isArray(requestInit.headers)) {
-      for (const [key, value] of requestInit.headers) {
-        if (typeof value !== "undefined") {
-          requestHeaders.set(key, String(value));
-        }
-      }
-    } else {
-      for (const [key, value] of Object.entries(requestInit.headers)) {
-        if (typeof value !== "undefined") {
-          requestHeaders.set(key, String(value));
-        }
-      }
-    }
-  }
-
-  // Preserve all incoming beta headers while ensuring OAuth requirements
-  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,
-    model,
-    provider,
-    signature.customBetas,
-    signature.strategy,
-    requestUrl?.pathname,
-    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();
-  const bearerToken = authTokenOverride || accessToken;
-
-  requestHeaders.set("authorization", `Bearer ${bearerToken}`);
-  requestHeaders.set("anthropic-beta", mergedBetas);
-  requestHeaders.set("user-agent", buildExtendedUserAgent(signature.claudeCliVersion));
-  if (signature.enabled) {
-    requestHeaders.set("anthropic-version", "2023-06-01");
-    // Fix #6: x-app is "cli" for interactive mode, "cli-bg" for background tasks.
-    // Real CC (client.ts:106): 'x-app': 'cli' (foreground) or 'cli-bg' (background agent).
-    requestHeaders.set("x-app", isTruthyEnv(process.env.CLAUDE_CODE_BACKGROUND) ? "cli-bg" : "cli");
-    // Fix #3: X-Claude-Code-Session-Id — sent in ALL requests by real CC (client.ts:108).
-    // Value matches metadata.user_id.session_id for server-side correlation.
-    if (signature.sessionId) {
-      requestHeaders.set("X-Claude-Code-Session-Id", signature.sessionId);
-    }
-    requestHeaders.set("x-stainless-arch", getStainlessArch(process.arch));
-    requestHeaders.set("x-stainless-lang", "js");
-    requestHeaders.set("x-stainless-os", getStainlessOs(process.platform));
-    // Real CC sends 0.81.0 (confirmed via proxy capture), not the internal 0.208.0.
-    // WATCH: most-likely-to-drift mimesis constant. Stable v2.1.97 → v2.1.105 (only
-    // the minifier identifier renamed, d66 → g86). Re-verify on every upstream bump:
-    //   rg -n '"0\.\d+\.\d+"' _tmp_claude_pkg/<version>/package/cli.js | rg -C2 stainless
-    // See docs/future-improvements.md §7 and claude-code-reverse-engineering.md §16.
-    requestHeaders.set("x-stainless-package-version", "0.94.0");
-    // Real CC on Windows/Node reports "node" — confirmed via proxy capture.
-    requestHeaders.set("x-stainless-runtime", "node");
-    requestHeaders.set("x-stainless-runtime-version", process.version);
-    const incomingRetryCount = requestHeaders.get("x-stainless-retry-count");
-    requestHeaders.set(
-      "x-stainless-retry-count",
-      incomingRetryCount && !isFalsyEnv(incomingRetryCount) ? incomingRetryCount : "0",
-    );
-    // x-stainless-timeout: real CC sends 600 on ALL requests (confirmed via proxy capture).
-    requestHeaders.set("x-stainless-timeout", "600");
-    // anthropic-dangerous-direct-browser-access: real CC sends this on all requests.
-    requestHeaders.set("anthropic-dangerous-direct-browser-access", "true");
-    const stainlessHelpers = buildStainlessHelperHeader(tools, messages);
-    if (stainlessHelpers) {
-      requestHeaders.set("x-stainless-helper", stainlessHelpers);
-    }
-
-    for (const [key, value] of Object.entries(parseAnthropicCustomHeaders())) {
-      requestHeaders.set(key, value);
-    }
-    if (process.env.CLAUDE_CODE_CONTAINER_ID) {
-      requestHeaders.set("x-claude-remote-container-id", process.env.CLAUDE_CODE_CONTAINER_ID);
-    }
-    if (process.env.CLAUDE_CODE_REMOTE_SESSION_ID) {
-      requestHeaders.set("x-claude-remote-session-id", process.env.CLAUDE_CODE_REMOTE_SESSION_ID);
-    }
-    if (process.env.CLAUDE_AGENT_SDK_CLIENT_APP) {
-      requestHeaders.set("x-client-app", process.env.CLAUDE_AGENT_SDK_CLIENT_APP);
-    }
-    if (isTruthyEnv(process.env.CLAUDE_CODE_ADDITIONAL_PROTECTION)) {
-      requestHeaders.set("x-anthropic-additional-protection", "true");
-    }
-
-    // x-client-request-id: real CC 2.1.195's first-party fetch middleware (Ukd) sets
-    // this to crypto.randomUUID() on every first-party request. Re-emit a random uuid.
-    requestHeaders.set("x-client-request-id", randomUUID());
-  }
-  requestHeaders.delete("x-api-key");
-  // x-session-affinity: set by opencode SDK but NOT in real CC. Strip it.
-  requestHeaders.delete("x-session-affinity");
-
-  return requestHeaders;
-}
-
-/**
- * Resolve max_tokens for a request based on output cap configuration.
- * If the caller specified max_tokens, it is preserved. Otherwise, defaults
- * to 8K and escalates to 64K after an output truncation (stop_reason: "max_tokens").
- *
- * @param {Record<string, any>} body - Parsed request body
- * @param {import('./lib/config.mjs').AnthropicAuthConfig} config
- * @returns {number | undefined} Resolved max_tokens value, or undefined for passthrough
- */
-function resolveMaxTokens(body, config) {
-  if (!config.output_cap?.enabled) return body.max_tokens; // passthrough
-  if (body.max_tokens != null) return body.max_tokens; // caller-specified wins
-  // QA note L-escalation: lastStopReason is set by extractUsageFromSSEEvent AFTER the stream
-  // completes. The timing works correctly for "escalate for one turn" because this function runs
-  // BEFORE the next request's stream starts. If the response pipeline changes to update stop
-  // reason mid-stream or before response completion, this ordering assumption would break.
-  const escalated = sessionMetrics.lastStopReason === "max_tokens";
-  const result = escalated
-    ? (config.output_cap.escalated_max_tokens ?? 64_000)
-    : (config.output_cap.default_max_tokens ?? 8_000);
-  // Reset after escalation is consumed (sticky for exactly one turn)
-  if (escalated) {
-    sessionMetrics.lastStopReason = null;
-  }
-  return result;
-}
-
-/**
- * Transform the request body: system prompt sanitization and tool prefixing.
- * Preserves behaviors E1-E7.
- *
- * @param {string | undefined} body
- * @param {{enabled: boolean, claudeCliVersion: string, promptCompactionMode: 'minimal' | 'off', provider?: string}} signature
- * @param {{persistentUserId: string, sessionId: string, accountId: string, turns?: number, usedTools?: Set<string>}} runtime
- * @param {string} [betaHeader] - Pre-computed anthropic-beta header value to inject into the body.
- * @param {import('./lib/config.mjs').AnthropicAuthConfig} [config] - Plugin configuration for output cap
- * @returns {string | undefined}
- */
-function transformRequestBody(body, signature, runtime, betaHeader, config) {
-  if (!body || typeof body !== "string") return body;
-
-  const TOOL_PREFIX = "mcp_";
-
-  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);
-    }
-    // Bedrock requires betas in the body as "anthropic_beta" (underscore) since it
-    // doesn't forward custom HTTP headers. First-party API rejects "betas" in body
-    // with "Extra inputs are not permitted" — betas are header-only for first-party.
-    if (signature.enabled && betaHeader && signature.provider === "bedrock") {
-      const betaArray = betaHeader
-        .split(",")
-        .map((b) => b.trim())
-        .filter(Boolean)
-        .filter((b) => b !== "oauth-2025-04-20");
-      parsed.anthropic_beta = betaArray;
-    }
-    // Strip any incoming "betas" field — API rejects it as unknown
-    if (Object.prototype.hasOwnProperty.call(parsed, "betas")) {
-      delete parsed.betas;
-    }
-    // Normalize thinking block for adaptive (Opus 4.6 / Sonnet 4.6) vs manual (older models).
-    // Real CC always sends thinking:{type:"adaptive"} for adaptive models even if the
-    // upstream SDK didn't include it. Inject it when missing to match the fingerprint.
-    if (Object.prototype.hasOwnProperty.call(parsed, "thinking")) {
-      parsed.thinking = normalizeThinkingBlock(parsed.thinking, parsed.model || "");
-    } else if (parsed.model && isAdaptiveThinkingModel(parsed.model)) {
-      parsed.thinking = { type: "adaptive" };
-    }
-
-    // Fingerprint fix: real Claude Code v2.1.87+ nests the effort control inside
-    // `output_config.effort` (via Lyz() in cli.js). opencode's provider transform
-    // for variant=max on Opus 4.6 / Sonnet 4.6 sets `effort` at the top level,
-    // which causes Anthropic's server to fingerprint the body as non-CC and bill
-    // it as pay-as-you-go — surfacing as "You're out of extra usage" even on a
-    // valid Max plan. Move it into output_config when we're talking to an
-    // adaptive-thinking model so the wire shape matches real CC.
-    if (typeof parsed.effort === "string" && parsed.model && isAdaptiveThinkingModel(parsed.model)) {
-      if (!parsed.output_config || typeof parsed.output_config !== "object") {
-        parsed.output_config = {};
-      }
-      if (!("effort" in parsed.output_config)) {
-        parsed.output_config.effort = parsed.effort;
-      }
-      delete parsed.effort;
-    } else if (Object.prototype.hasOwnProperty.call(parsed, "effort")) {
-      // Non-adaptive models never carry a top-level effort in real CC — strip it
-      // to avoid polluting the fingerprint for models like Haiku.
-      delete parsed.effort;
-    }
-
-    // Claude Code v2.1.117+: default effort for Pro/Max on adaptive models is
-    // "high" (was "medium"). If the host omits effort entirely, inject the
-    // default so the wire shape matches real CC.
-    if (parsed.model && isAdaptiveThinkingModel(parsed.model)) {
-      if (!parsed.output_config || typeof parsed.output_config !== "object") {
-        parsed.output_config = {};
-      }
-      if (!("effort" in parsed.output_config)) {
-        parsed.output_config.effort = "high";
-      }
-    }
-
-    // Claude Code temperature rule: when extended thinking is active (any type),
-    // temperature must be omitted (undefined). Otherwise default to 1.
-    const thinkingActive =
-      parsed.thinking &&
-      typeof parsed.thinking === "object" &&
-      (parsed.thinking.type === "adaptive" || parsed.thinking.type === "enabled");
-    if (thinkingActive) {
-      // Anthropic API rejects temperature when thinking is enabled
-      delete parsed.temperature;
-
-      // Claude Code v2.1.84: inject the context_management body field ONLY when the
-      // user has explicitly opted in via token_economy.context_management. Note: as of
-      // v2.1.195 the context-management *beta header* is default-ON for first-party
-      // non-claude-3 models (see buildAnthropicBetaHeader), but the body field stays
-      // opt-in. A top-level context_management field WITHOUT the beta is rejected with
-      // "context_management: Extra inputs are not permitted"; the beta being present
-      // without the field is fine. Gating the field on explicit opt-in keeps the field
-      // ⊆ beta invariant, so the 400 never fires.
-      if (
-        config?.token_economy?.context_management &&
-        !CLAUDE_3_MODEL_RE.test(parsed.model || "") &&
-        !parsed.context_management
-      ) {
-        parsed.context_management = {
-          edits: [{ type: "clear_thinking_20251015", keep: "all" }],
-        };
-      }
-    } else {
-      // Claude Code always uses temperature: 1 for non-thinking requests (RE doc §5.2, never 0)
-      parsed.temperature = 1;
-    }
-
-    // Strip leaked /anthropic slash command messages from conversation history.
-    // OpenCode may include command text and sendCommandMessage output as regular
-    // user messages even when output.noReply = true was set. Filter them out
-    // so the agent never sees /anthropic commands in its context.
-    if (Array.isArray(parsed.messages)) {
-      parsed.messages = stripSlashCommandMessages(parsed.messages);
-    }
-
-    // === Token economy: layered message/history compaction ===
-    // Only applies to main-thread requests (subagents/title-gen stay untouched).
-    // Strategies stack in order: TTL thinking strip → proactive microcompact →
-    // trailing-summary trim → tool_result dedupe. Each is independently gated.
-    const te = config?.token_economy || {};
-    const tes = runtime?.tokenEconomySession;
-    const isMainRole = runtime?.requestRole === "main" || runtime?.requestRole == null;
-
-    // `conservative` (default ON) disables all history-rewriting and tool-array
-    // transforms. These optimizations shrink each request body but cause the
-    // prompt-cache prefix to change turn-to-turn, invalidating the 1h cache
-    // and forcing a fresh cache_write each turn — which costs 2x base input
-    // tokens. For long opencode sessions, cache reuse dominates; flip to
-    // `false` only if you have measurements showing otherwise. Adaptive
-    // thinking zero-out remains active (affects only the thinking budget,
-    // not cached content).
-    const conservative = te.conservative !== false;
-
-    if (!conservative && isMainRole && Array.isArray(parsed.messages) && tes) {
-      // (1) TTL-based thinking strip
-      if (te.ttl_thinking_strip !== false) {
-        const ttlMs = signature?.cachePolicy?.ttl === "5m" ? 5 * 60_000 : 60 * 60_000;
-        const res = applyTtlThinkingStrip(parsed.messages, {
-          lastClearMs: tes.lastThinkingStripMs,
-          ttlMs,
-        });
-        if (res.changed) {
-          parsed.messages = res.messages;
-          tes.lastThinkingStripMs = res.ranStripAt;
-          tes.thinkingStripped += res.cleared;
-        }
-      }
-
-      // (1b) Session-wide reproducible-tool result dedupe (Phase C C3, opt-in)
-      // Pure over message history; runs before microcompact so dedup'd stubs
-      // are visible to downstream size estimation. Gated by
-      // token_economy_strategies.tool_result_dedupe_session_wide (default off).
-      if (config?.token_economy_strategies?.tool_result_dedupe_session_wide === true) {
-        const res = applySessionToolResultDedupe(parsed.messages);
-        if (res.changed) parsed.messages = res.messages;
-      }
-
-      // (2) Proactive microcompact (client-side, pre-422)
-      if (te.proactive_microcompact !== false) {
-        const estimated = estimatePromptTokensFromParsed(parsed);
-        const cw = 200_000; // conservative — 1M models still benefit
-        const res = applyProactiveMicrocompact(parsed.messages, {
-          estimatedTokens: estimated,
-          contextWindow: cw,
-          percent: te.microcompact_percent ?? 70,
-          keepRecent: te.microcompact_keep_recent ?? 8,
-        });
-        if (res.changed) {
-          parsed.messages = res.messages;
-          tes.lastMicrocompactMs = Date.now();
-          tes.toolResultsCompacted += res.cleared;
-        }
-      }
-
-      // (3) Trailing-summary trim (opt-in)
-      if (te.trailing_summary_trim === true) {
-        const res = applyTrailingSummaryTrim(parsed.messages);
-        if (res.changed) parsed.messages = res.messages;
-      }
-
-      // (4) Cross-turn tool_result dedupe (opt-in)
-      if (te.tool_result_dedupe === true) {
-        const SAFE_READ_TOOLS = new Set(["Read", "Grep", "Glob", "LS", "BashOutput"]);
-        const res = applyToolResultDedupe(parsed.messages, {
-          seen: tes.seenContentHashes,
-          safeTools: SAFE_READ_TOOLS,
-        });
-        if (res.changed) parsed.messages = res.messages;
-      }
-    }
-
-    // === Token economy: tool-array transforms (stable ordering, deferral) ===
-    if (!conservative && isMainRole && Array.isArray(parsed.tools)) {
-      if (te.stable_tool_ordering !== false) {
-        parsed.tools = applyStableToolOrdering(parsed.tools);
-      }
-      if (Array.isArray(te.deferred_tool_names) && te.deferred_tool_names.length > 0) {
-        // "Invoked" means any assistant message in the convo has used the tool.
-        const invoked = new Set();
-        if (Array.isArray(parsed.messages)) {
-          for (const m of parsed.messages) {
-            if (m.role !== "assistant" || !Array.isArray(m.content)) continue;
-            for (const b of m.content) {
-              if (b?.type === "tool_use" && typeof b.name === "string") invoked.add(b.name);
-            }
-          }
-        }
-        const res = applyToolSchemaDeferral(parsed.tools, {
-          deferred: new Set(te.deferred_tool_names),
-          invoked,
-        });
-        parsed.tools = res.tools;
-      }
-    }
-
-    // === Token economy: adaptive thinking zero-out for trivial follow-ups ===
-    if (isMainRole && te.adaptive_thinking_zero_simple !== false) {
-      applyAdaptiveThinkingZero(parsed);
-    }
-
-    // QA fix H2: avoid mutating the signature parameter; capture modelId locally
-    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,
-      // small, empty shapes) strip billing identity + CC identity injection.
-      // Title-gen path is handled separately by isTitleGeneratorSystemBlocks().
-      // Default off — opt-in via `token_economy.lean_system_non_main: true`.
-      requestRole: runtime?.requestRole,
-      leanNonMain: config?.token_economy?.lean_system_non_main === true,
-      // Simple-system-prompt mode for Opus 4.7+ (CC v2.1.133+ parity, gated by
-      // GrowthBook `tengu_vellum_lantern` in real CC). Plugin gate: model
-      // eligibility + opt-in flag. See buildSystemPromptBlocks for what it
-      // strips (anti-verbosity boilerplate only; identity/billing untouched).
-      simpleSystemPrompt: config?.token_economy?.simple_system_prompt === true,
-      // Workload tag for x-anthropic-billing-header `cc_workload=` segment.
-      // Mirrors real CC's `--workload <tag>` CLI flag (process-scoped, used by
-      // SDK daemon callers spawning cron subprocesses). Empty string -> omit.
-      workload: typeof config?.signature_emulation?.workload === "string" ? config.signature_emulation.workload : "",
-    };
-    // Sanitize system prompt and optionally inject Claude Code identity/billing blocks.
-    parsed.system = buildSystemPromptBlocks(normalizeSystemTextBlocks(parsed.system), signatureWithModel);
-
-    // Strategy 5 — System prompt tailing: after N turns, trim large system blocks
-    // to essential sections only. The model has internalized verbose instructions
-    // (shell strategy, package manager tables, delegation protocols) by this point.
-    // Preserves: first paragraph (identity/role), lines containing MUST/NEVER/CRITICAL/
-    // IMPORTANT, section headers, and short blocks. Drops verbose body paragraphs.
-    const tailThreshold = signature.systemPromptTailTurns ?? 6;
-    if (signature.systemPromptTailing === true && runtime.turns >= tailThreshold && Array.isArray(parsed.system)) {
-      const maxChars = signature.systemPromptTailMaxChars ?? 2000;
-      for (let i = 0; i < parsed.system.length; i++) {
-        const block = parsed.system[i];
-        if (block.type === "text" && block.text && block.text.length > maxChars * 2) {
-          block.text = tailSystemBlock(block.text, maxChars, tailThreshold);
-        }
-      }
-    }
-
-    // Token budget (A9): parse NL budget from last user message, inject status block
-    if (config?.token_budget?.enabled && Array.isArray(parsed.messages)) {
-      const budgetExpr = parseNaturalLanguageBudget(parsed.messages);
-      if (budgetExpr > 0) {
-        sessionMetrics.tokenBudget.limit = budgetExpr;
-      } else if (config.token_budget.default > 0 && sessionMetrics.tokenBudget.limit === 0) {
-        sessionMetrics.tokenBudget.limit = config.token_budget.default;
-      }
-      // If budget is active, inject status into system prompt
-      if (sessionMetrics.tokenBudget.limit > 0) {
-        const threshold = config.token_budget.completion_threshold ?? 0.9;
-        parsed.system = injectTokenBudgetBlock(parsed.system, sessionMetrics.tokenBudget, threshold);
-        // Soft stop: if we've exceeded the threshold, cap max_tokens to 1
-        if (sessionMetrics.tokenBudget.used >= sessionMetrics.tokenBudget.limit * threshold) {
-          parsed.max_tokens = 1;
-        }
-      }
-    }
-
-    if (signature.enabled) {
-      const currentMetadata =
-        parsed.metadata && typeof parsed.metadata === "object" && !Array.isArray(parsed.metadata)
-          ? parsed.metadata
-          : {};
-      parsed.metadata = {
-        ...currentMetadata,
-        ...buildRequestMetadata({
-          persistentUserId: runtime.persistentUserId,
-          accountId: runtime.accountId,
-          sessionId: runtime.sessionId,
-        }),
-      };
-    }
-
-    // Cache breakpoint optimization: add cache_control to the last content block
-    // of each user/assistant message for maximum prefix caching.
-    // Skip for round-robin strategy (cache defeated by account rotation).
-    // Skip for title generators / fire-and-forget queries: these are one-shot
-    // requests that don't benefit from caching and would pollute the cache pool.
-    const isTitleGen = isTitleGeneratorSystemBlocks(parsed.system || []);
-    if (
-      signature.enabled &&
-      signature.cachePolicy?.ttl !== "off" &&
-      signature.cachePolicy?.ttl_supported !== false &&
-      !isTitleGen
-    ) {
-      // Strip ALL incoming cache_control from tools and messages to prevent
-      // TTL ordering violations (host SDK may set ttl=5m which conflicts with
-      // 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 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;
-        }
-        // 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).
-        // (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;
-          const lastBlock = msg.content[msg.content.length - 1];
-          if (lastBlock && typeof lastBlock === "object") {
-            lastBlock.cache_control = { type: "ephemeral", ttl: ccTtl };
-          }
-          break;
-        }
-      }
-    }
-
-    // Tool name sanitization: Anthropic's server blocklists known non-CC tool names.
-    // opencode uses lowercase names while CC uses PascalCase. While only "todowrite"
-    // is currently confirmed blocklisted, we rename ALL core opencode tools to match
-    // CC's naming convention as a preventive measure against future blocklist additions.
-    const OC_TO_CC_TOOL_NAMES = {
-      bash: "Bash",
-      read: "Read",
-      glob: "Glob",
-      grep: "Grep",
-      edit: "Edit",
-      write: "Write",
-      webfetch: "WebFetch",
-      todowrite: "TodoWrite",
-      skill: "Skill",
-      task: "Task",
-      compress: "Compress",
-    };
-    if (Array.isArray(parsed.tools)) {
-      for (const tool of parsed.tools) {
-        if (tool.name && OC_TO_CC_TOOL_NAMES[tool.name]) {
-          tool.name = OC_TO_CC_TOOL_NAMES[tool.name];
-        }
-      }
-    }
-    // Also rename in tool_use blocks in messages (assistant responses referencing the tool)
-    if (Array.isArray(parsed.messages)) {
-      for (const msg of parsed.messages) {
-        if (!Array.isArray(msg.content)) continue;
-        for (const block of msg.content) {
-          if (block.type === "tool_use" && block.name && OC_TO_CC_TOOL_NAMES[block.name]) {
-            block.name = OC_TO_CC_TOOL_NAMES[block.name];
-          }
-        }
-      }
-    }
-    // Track which tools the model has used (from assistant tool_use blocks).
-    // Names are already CC PascalCase after renaming above.
-    if (Array.isArray(parsed.messages)) {
-      for (const msg of parsed.messages) {
-        if (msg.role === "assistant" && Array.isArray(msg.content)) {
-          for (const block of msg.content) {
-            if (block.type === "tool_use" && block.name) {
-              runtime.usedTools.add(block.name);
-            }
-          }
-        }
-      }
-    }
-
-    // Strategy 4 — Adaptive tool set: after turn 3, defer non-core tools that
-    // the model hasn't used yet. This saves schema bytes on turns where tools
-    // are unlikely to be needed. Core tools stay eager. Resets on /clear.
-    if (
-      Array.isArray(parsed.tools) &&
-      signature.adaptiveToolSet !== false &&
-      runtime.turns >= 3 &&
-      parsed.model &&
-      !/claude-3-|haiku/i.test(parsed.model)
-    ) {
-      const used = runtime.usedTools;
-      for (const tool of parsed.tools) {
-        if (tool.name && !used.has(tool.name) && !CORE_TOOL_NAMES.has(tool.name)) {
-          tool.defer_loading = true;
-        }
-      }
-    }
-
-    // Tool description compaction: apply the same compaction logic used for
-    // system prompts (strip examples, collapse whitespace, dedup lines) to tool
-    // descriptions. The top 4 tools (Bash 10.6K, TodoWrite 9.7K, Task 5.5K,
-    // Compress 4.5K) account for 30KB. Compaction typically saves 30-50%.
-    if (Array.isArray(parsed.tools) && signature.toolDescriptionCompaction !== false) {
-      for (const tool of parsed.tools) {
-        if (tool.description && tool.description.length > 500) {
-          tool.description = compactToolDescription(tool.description);
-        }
-      }
-    }
+ * @param {"anthropic" | "bedrock" | "vertex" | "foundry" | "anthropicAws" | "mantle"} provider
+ * @param {string[]} [customBetas]
+ * @param {import('./lib/config.mjs').AccountSelectionStrategy} [strategy]
+ * @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}
+ */
+// Mirrors CC's Kw(model) effort eligibility: returns false for claude-3-* and the
+// explicit older 4.x exclusion set (opus-4-0/4-1, sonnet-4-0/4-5, haiku-4-5), true
+// for every other model (effort-capable: Opus 4.5/4.6/4.7/4.8, Sonnet 4.6, etc.).
 
-    // MCP tool deferral: mark non-core tools with defer_loading: true.
-    // CC defers all MCP tools by default — the API omits their full schemas from token
-    // counting, only sending the tool name. When the model needs a deferred tool, it uses
-    // tool_reference to load the schema on demand. This saves ~20KB per turn.
-    // Core tools (OC_TO_CC_TOOL_NAMES) are always eager-loaded.
-    if (
-      Array.isArray(parsed.tools) &&
-      signature.toolDeferral !== false &&
-      parsed.model &&
-      !/claude-3-|haiku/i.test(parsed.model)
-    ) {
-      const coreToolNames = new Set(Object.values(OC_TO_CC_TOOL_NAMES));
-      for (const tool of parsed.tools) {
-        if (tool.name && !coreToolNames.has(tool.name)) {
-          tool.defer_loading = true;
-        }
-      }
-    }
+/** @typedef {'low' | 'medium' | 'high'} ThinkingEffort */
 
-    // Task budgets: when the task-budgets beta is active, preserve or inject output_config.
-    // The beta unlocks output_config.max_output_tokens for per-task budget control.
-    // Model-router compatibility: the beta header + output_config body are forwarded as-is.
-    if (betaHeader && betaHeader.includes("task-budgets-2026-03-13")) {
-      if (!parsed.output_config) {
-        // Default: set a reasonable per-task output budget for long-running agentic tasks.
-        // Claude Code tasks typically need generous output budgets.
-        parsed.output_config = { max_output_tokens: 16384 };
-      }
-    }
+/**
+ * Map budgetTokens to an effort level.
+ * Used when an Opus 4.6 request arrives with the legacy budgetTokens shape.
+ * @param {number} budgetTokens
+ * @returns {ThinkingEffort}
+ */
+function budgetTokensToEffort(budgetTokens) {
+  if (budgetTokens <= 1024) return "low";
+  if (budgetTokens <= 8000) return "medium";
+  return "high";
+}
 
-    // Context hint (CC v2.1.110+): pair the context-hint-2026-04-09 beta with
-    // the body field context_hint:{enabled:true}. Extracted from CC bundle
-    // buildRequestParams(): `{betaHeader, body:{context_hint:{enabled:!0}}}`.
-    // When active, the server responds with optional hints suggesting which
-    // messages to drop for token-efficient context compaction.
-    if (betaHeader && betaHeader.includes("context-hint-2026-04-09") && !parsed.context_hint) {
-      parsed.context_hint = { enabled: true };
-    }
+// QA fix L3: budgetTokensToEffort() removed — dead code, never called
+// QA fix L4: isValidEffort() removed — dead code, never called
 
-    // 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 (
-      !fastModeEnabled &&
-      te.fast_mode_auto === true &&
-      isMainRole &&
-      parsed.model &&
-      isFastModeEligibleModel(parsed.model) &&
-      Array.isArray(parsed.messages) &&
-      parsed.messages.length >= 2
-    ) {
-      // Simple exchange heuristic: last user message is short, no tool_result,
-      // no file references. Suggests a follow-up question that doesn't need
-      // deep reasoning.
-      const last = parsed.messages[parsed.messages.length - 1];
-      if (last && last.role === "user") {
-        let txt = "";
-        let hasToolResult = false;
-        if (typeof last.content === "string") txt = last.content;
-        else if (Array.isArray(last.content)) {
-          for (const b of last.content) {
-            if (b?.type === "tool_result") hasToolResult = true;
-            if (b?.type === "text" && typeof b.text === "string") txt += b.text;
-          }
-        }
-        if (!hasToolResult && txt.length < 240 && !/\bfile:|\.md\b|\.mjs\b|\.ts\b/i.test(txt)) {
-          fastModeAutoApplied = true;
-        }
-      }
-    }
-    if ((fastModeEnabled || fastModeAutoApplied) && parsed.model && isFastModeEligibleModel(parsed.model)) {
-      parsed.speed = "fast";
-    }
+/**
+ * Normalise the `thinking` block in the request body for the target model:
+ * - 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
+ * @param {string} model
+ * @returns {any}
+ */
+/**
+ * Map Node.js platform to Stainless OS header value.
+ * @param {NodeJS.Platform} value
+ * @returns {string}
+ */
 
-    // Guard: repair orphaned tool_use blocks anywhere in the message array.
-    // The Anthropic API requires that every assistant message containing tool_use
-    // blocks is immediately followed by a user message with matching tool_result
-    // blocks. When OpenCode crashes/hangs mid-tool-execution, the conversation
-    // state may be saved with unpaired tool_use blocks. This causes:
-    //   "messages.N: `tool_use` ids were found without `tool_result` blocks
-    //    immediately after: toolu_XXXXX"
-    // We scan the full array and synthesize missing tool_result messages.
-    if (Array.isArray(parsed.messages) && parsed.messages.length > 0) {
-      parsed.messages = repairOrphanedToolUseBlocks(parsed.messages);
-
-      // Also ensure the array never ends with an assistant message (prefill guard).
-      const lastMsg = parsed.messages[parsed.messages.length - 1];
-      if (lastMsg && lastMsg.role === "assistant") {
-        const lastContent = Array.isArray(lastMsg.content) ? lastMsg.content : [];
-        const toolUseBlocks = lastContent.filter((b) => b.type === "tool_use");
-        if (toolUseBlocks.length > 0) {
-          parsed.messages.push({
-            role: "user",
-            content: toolUseBlocks.map((tu) => ({
-              type: "tool_result",
-              tool_use_id: tu.id,
-              content: "[Result unavailable — conversation was restructured]",
-            })),
-          });
-        } else {
-          parsed.messages.push({
-            role: "user",
-            content: [{ type: "text", text: "Continue." }],
-          });
-        }
-      }
-    }
+/**
+ * Normalize Node.js arch to Stainless arch header value.
+ * @param {string} value
+ * @returns {string}
+ */
 
-    return JSON.stringify(parsed);
+/**
+ * Resolve latest claude-code package version from npm registry.
+ * Returns null on timeout/network/parse failures.
+ * @param {number} timeoutMs
+ * @returns {Promise<string | null>}
+ */
+async function fetchLatestClaudeCodeVersion(timeoutMs = 1200) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(CLAUDE_CODE_NPM_LATEST_URL, {
+      method: "GET",
+      headers: { accept: "application/json" },
+      signal: controller.signal,
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (!data || typeof data !== "object") return null;
+    return typeof data.version === "string" && data.version ? data.version : null;
   } catch {
-    // ignore parse errors
-    return body;
+    return null;
+  } finally {
+    clearTimeout(timeout);
   }
 }
 
+/**
+ * Build request headers from input and init, applying OAuth requirements.
+ * Preserves behaviors D1-D7.
+ *
+ * @param {any} input
+ * @param {Record<string, any>} requestInit
+ * @param {string} accessToken
+ * @param {string | undefined} requestBody
+ * @param {URL | null} requestUrl
+ * @param {{enabled: boolean, claudeCliVersion: string, strategy?: import('./lib/config.mjs').AccountSelectionStrategy, customBetas?: string[], sessionId?: string}} signature
+ * @returns {Headers}
+ */
+
+/**
+ * Resolve max_tokens for a request based on output cap configuration.
+ * If the caller specified max_tokens, it is preserved. Otherwise, defaults
+ * to 8K and escalates to 64K after an output truncation (stop_reason: "max_tokens").
+ *
+ * @param {Record<string, any>} body - Parsed request body
+ * @param {import('./lib/config.mjs').AnthropicAuthConfig} config
+ * @returns {number | undefined} Resolved max_tokens value, or undefined for passthrough
+ */
+
 /**
  * Transform the request URL: add ?beta=true to /v1/messages and /v1/messages/count_tokens.
  * Preserves behaviors F1-F3.
@@ -8815,234 +6014,9 @@ function transformRequestUrl(input) {
  * @property {number} cacheReadTokens
  * @property {number} cacheWriteTokens
  * @property {number} [webSearchRequests]
+ * @property {string} [lastStopReason]
  */
 
-/**
- * Update running usage stats from a parsed SSE event.
- * @param {any} parsed
- * @param {UsageStats} stats
- */
-function extractUsageFromSSEEvent(parsed, stats) {
-  // message_delta: cumulative usage (preferred, overwrites)
-  if (parsed?.type === "message_delta" && parsed.usage) {
-    const u = parsed.usage;
-    if (typeof u.input_tokens === "number") stats.inputTokens = u.input_tokens;
-    if (typeof u.output_tokens === "number") stats.outputTokens = u.output_tokens;
-    if (typeof u.cache_read_input_tokens === "number") stats.cacheReadTokens = u.cache_read_input_tokens;
-    if (typeof u.cache_creation_input_tokens === "number") stats.cacheWriteTokens = u.cache_creation_input_tokens;
-    // Web search requests (server tool usage)
-    if (typeof u.server_tool_use?.web_search_requests === "number") {
-      stats.webSearchRequests = u.server_tool_use.web_search_requests;
-    }
-    // Capture stop_reason from message_delta for output cap escalation
-    if (parsed.delta?.stop_reason) {
-      sessionMetrics.lastStopReason = parsed.delta.stop_reason;
-    }
-    return;
-  }
-
-  // message_start: initial usage (only set if we haven't seen message_delta yet)
-  if (parsed?.type === "message_start" && parsed.message?.usage) {
-    const u = parsed.message.usage;
-    if (stats.inputTokens === 0 && typeof u.input_tokens === "number") {
-      stats.inputTokens = u.input_tokens;
-    }
-    if (stats.cacheReadTokens === 0 && typeof u.cache_read_input_tokens === "number") {
-      stats.cacheReadTokens = u.cache_read_input_tokens;
-    }
-    if (stats.cacheWriteTokens === 0 && typeof u.cache_creation_input_tokens === "number") {
-      stats.cacheWriteTokens = u.cache_creation_input_tokens;
-    }
-  }
-}
-
-/**
- * Extract the combined SSE data payload from one event block.
- * @param {string} eventBlock
- * @returns {string | null}
- */
-function getSSEDataPayload(eventBlock) {
-  if (!eventBlock) return null;
-
-  const dataLines = [];
-  for (const line of eventBlock.split("\n")) {
-    if (!line.startsWith("data:")) continue;
-    // QA fix: SSE spec says strip only a single leading space after "data:", not all whitespace
-    const raw = line.slice(5);
-    dataLines.push(raw.startsWith(" ") ? raw.slice(1) : raw);
-  }
-
-  if (dataLines.length === 0) return null;
-  const payload = dataLines.join("\n");
-  if (!payload || payload === "[DONE]") return null;
-  return payload;
-}
-
-/**
- * Parse one SSE event payload and return account-error details if present.
- * @param {any} parsed
- * @returns {{reason: import('./lib/backoff.mjs').RateLimitReason, invalidateToken: boolean} | null}
- */
-function getMidStreamAccountError(parsed) {
-  if (!parsed || parsed.type !== "error" || !parsed.error) {
-    return null;
-  }
-
-  const errorBody = {
-    error: {
-      type: String(parsed.error.type || ""),
-      message: String(parsed.error.message || ""),
-    },
-  };
-
-  // Mid-stream errors do not include a reliable HTTP status. Use 400-style
-  // body parsing to identify account-specific errors.
-  if (!isAccountSpecificError(400, errorBody)) {
-    return null;
-  }
-
-  const reason = parseRateLimitReason(400, errorBody);
-
-  return {
-    reason,
-    invalidateToken: reason === "AUTH_FAILED",
-  };
-}
-
-/**
- * Strip `mcp_` prefix from tool_use `name` fields in SSE data lines.
- * Only modifies `name` values inside content blocks with `"type": "tool_use"`.
- * Non-JSON lines and text blocks are left untouched.
- *
- * @param {string} text - Raw SSE chunk text (may contain multiple lines)
- * @returns {string}
- */
-function stripMcpPrefixFromSSE(text) {
-  return text.replace(/^data:\s*(.+)$/gm, (_match, jsonStr) => {
-    try {
-      const parsed = JSON.parse(jsonStr);
-      if (stripMcpPrefixFromParsedEvent(parsed)) {
-        return `data: ${JSON.stringify(parsed)}`;
-      }
-    } catch {
-      // Not valid JSON — pass through unchanged.
-    }
-    return _match;
-  });
-}
-
-/**
- * Reverse map: CC PascalCase → opencode lowercase for response stream.
- * Built from the outgoing OC_TO_CC_TOOL_NAMES map (defined in transformRequestBody).
- * Must stay in sync with that map.
- */
-const CC_TO_OC_TOOL_NAMES = {
-  Bash: "bash",
-  Read: "read",
-  Glob: "glob",
-  Grep: "grep",
-  Edit: "edit",
-  Write: "write",
-  WebFetch: "webfetch",
-  TodoWrite: "todowrite",
-  Skill: "skill",
-  Task: "task",
-  Compress: "compress",
-};
-
-/**
- * Reverse-map a tool name from CC PascalCase back to opencode lowercase,
- * and strip `mcp_` prefix if present. Returns the original name if no mapping exists.
- * @param {string} name
- * @returns {string}
- */
-function reverseMapToolName(name) {
-  if (CC_TO_OC_TOOL_NAMES[name]) return CC_TO_OC_TOOL_NAMES[name];
-  if (name.startsWith("mcp_")) return name.slice(4);
-  return name;
-}
-
-/**
- * Mutate a parsed SSE event object, reversing tool name renames (CC PascalCase
- * → opencode lowercase) and removing `mcp_` prefix from tool_use name fields.
- * Returns true if any modification was made.
- *
- * @param {any} parsed
- * @returns {boolean}
- */
-function stripMcpPrefixFromParsedEvent(parsed) {
-  if (!parsed || typeof parsed !== "object") return false;
-
-  let modified = false;
-
-  // content_block_start: { content_block: { type: "tool_use"|"tool_reference", name: "..." } }
-  if (
-    parsed.content_block &&
-    (parsed.content_block.type === "tool_use" || parsed.content_block.type === "tool_reference") &&
-    typeof parsed.content_block.name === "string"
-  ) {
-    const mapped = reverseMapToolName(parsed.content_block.name);
-    if (mapped !== parsed.content_block.name) {
-      parsed.content_block.name = mapped;
-      modified = true;
-    }
-  }
-
-  // message_start: { message: { content: [{ type: "tool_use"|"tool_reference", name: "..." }] } }
-  if (parsed.message && Array.isArray(parsed.message.content)) {
-    for (const block of parsed.message.content) {
-      if ((block.type === "tool_use" || block.type === "tool_reference") && typeof block.name === "string") {
-        const mapped = reverseMapToolName(block.name);
-        if (mapped !== block.name) {
-          block.name = mapped;
-          modified = true;
-        }
-      }
-    }
-  }
-
-  // Top-level content array (non-streaming responses forwarded through SSE)
-  if (Array.isArray(parsed.content)) {
-    for (const block of parsed.content) {
-      if ((block.type === "tool_use" || block.type === "tool_reference") && typeof block.name === "string") {
-        const mapped = reverseMapToolName(block.name);
-        if (mapped !== block.name) {
-          block.name = mapped;
-          modified = true;
-        }
-      }
-    }
-  }
-
-  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
@@ -9053,166 +6027,20 @@ function resolveStreamIdleTimeoutMs(cfg) {
  * @param {((stats: UsageStats) => void) | null} [onUsage] - Called when stream ends with final usage
  * @param {((details: {reason: import('./lib/backoff.mjs').RateLimitReason, invalidateToken: boolean}) => void) | null} [onAccountError]
  *   Called if a mid-stream error looks account-specific
+ * @param {string} [correlationId]
  * @returns {Response}
  */
-function transformResponse(response, onUsage, onAccountError) {
+function transformResponse(response, onUsage, onAccountError, correlationId) {
   if (!response.body) return response;
-
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  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 = "";
-  let sseRewriteBuffer = "";
-  let accountErrorHandled = false;
-
-  /**
-   * Process buffered SSE event blocks.
-   * @param {boolean} flush
-   */
-  function processSSEBuffer(flush = false) {
-    while (true) {
-      const boundary = sseBuffer.indexOf("\n\n");
-
-      if (boundary === -1) {
-        if (!flush) return;
-        if (!sseBuffer.trim()) {
-          sseBuffer = "";
-          return;
-        }
-      }
-
-      const eventBlock = boundary === -1 ? sseBuffer : sseBuffer.slice(0, boundary);
-      sseBuffer = boundary === -1 ? "" : sseBuffer.slice(boundary + 2);
-
-      const payload = getSSEDataPayload(eventBlock);
-      if (!payload) {
-        if (boundary === -1) return;
-        continue;
-      }
-
-      try {
-        const parsed = JSON.parse(payload);
-
-        if (onUsage) {
-          extractUsageFromSSEEvent(parsed, stats);
-        }
-
-        if (onAccountError && !accountErrorHandled) {
-          const details = getMidStreamAccountError(parsed);
-          if (details) {
-            accountErrorHandled = true;
-            onAccountError(details);
-          }
-        }
-      } catch {
-        // Ignore malformed event payloads.
-      }
-
-      if (boundary === -1) return;
-    }
-  }
-
-  /**
-   * Rewrite complete SSE lines while preserving chunk boundaries for streaming.
-   * Buffers trailing partial lines to avoid parsing split JSON payloads.
-   * @param {string} chunk
-   * @param {boolean} [flush]
-   * @returns {string}
-   */
-  function rewriteSSEChunk(chunk, flush = false) {
-    sseRewriteBuffer += chunk;
-
-    if (!flush) {
-      const boundary = sseRewriteBuffer.lastIndexOf("\n");
-      if (boundary === -1) return "";
-      const complete = sseRewriteBuffer.slice(0, boundary + 1);
-      sseRewriteBuffer = sseRewriteBuffer.slice(boundary + 1);
-      return stripMcpPrefixFromSSE(complete);
-    }
-
-    if (!sseRewriteBuffer) return "";
-    const finalText = stripMcpPrefixFromSSE(sseRewriteBuffer);
-    sseRewriteBuffer = "";
-    return finalText;
-  }
-
-  const stream = new ReadableStream({
-    async pull(controller) {
-      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);
-
-        const rewrittenTail = rewriteSSEChunk("", true);
-        if (rewrittenTail) {
-          controller.enqueue(encoder.encode(rewrittenTail));
-        }
-
-        if (
-          onUsage &&
-          (stats.inputTokens > 0 || stats.outputTokens > 0 || stats.cacheReadTokens > 0 || stats.cacheWriteTokens > 0)
-        ) {
-          onUsage(stats);
-        }
-        controller.close();
-        return;
-      }
-
-      const text = decoder.decode(value, { stream: true });
-
-      if (onUsage || onAccountError) {
-        // Normalize CRLF for parser only; preserve original bytes for passthrough.
-        sseBuffer += text.replace(/\r\n/g, "\n");
-        processSSEBuffer(false);
-      }
-
-      const rewrittenText = rewriteSSEChunk(text, false);
-      if (rewrittenText) {
-        controller.enqueue(encoder.encode(rewrittenText));
-      } else {
-        // Keep the pull/read loop progressing when this chunk only extends a
-        // partial line buffered for later rewrite.
-        controller.enqueue(EMPTY_CHUNK);
-      }
-    },
+  const captureEnabled = _pluginConfig?.token_economy?.debug_dump_bodies === true && Boolean(correlationId);
+  const stream = createTransformedSSEStream(response, {
+    onUsage,
+    onAccountError,
+    correlationId,
+    idleTimeoutMs,
+    captureEnabled,
+    writeSseCapture,
   });
 
   // Inject cache transparency headers (session-level, available before stream completes).
@@ -9485,26 +6313,6 @@ function parseCommandArgs(raw) {
  * @param {any} body - Parsed JSON body
  * @returns {string[]}
  */
-function extractFileIds(body) {
-  const ids = [];
-  if (!body || typeof body !== "object") return ids;
-  // QA fix L-depth: cap recursion depth to prevent stack overflow on pathological payloads
-  const MAX_DEPTH = 20;
-  function walk(obj, depth) {
-    if (depth > MAX_DEPTH) return;
-    if (Array.isArray(obj)) {
-      for (const item of obj) walk(item, depth + 1);
-    } else if (obj && typeof obj === "object") {
-      if (obj.source?.file_id) ids.push(obj.source.file_id);
-      for (const val of Object.values(obj)) {
-        if (val && typeof val === "object") walk(val, depth + 1);
-      }
-    }
-  }
-  walk(body.messages, 0);
-  walk(body.system, 0);
-  return ids;
-}
 
 // Internals exposed for tests only. Do not consume from production code paths.
 //
@@ -9539,10 +6347,10 @@ AnthropicAuthPlugin.__testing__ = {
   // exposed for experimental.session.summarize integration tests
   runHaikuSessionSummarize,
   get cachedCCPrompt() {
-    return cachedCCPrompt;
+    return getCachedCCPrompt();
   },
   resetCachedCCPrompt() {
-    cachedCCPrompt = null;
+    resetCachedCCPrompt();
   },
   SUBAGENT_CC_ANCHOR,
   CLAUDE_CODE_IDENTITY_STRING,