opencode-anthropic-fix 0.1.8 → 0.1.11

package/index.mjs

@@ -184,6 +184,35 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
     lastHeader: null,
   };
 
+  // Context-hint controller (CC v2.1.110+). Mirrors real CC's `createContextHintController`:
+  // sticky on across requests until the server responds with a specific error family.
+  //   - 422/424 → apply hint compaction (clear thinking + microcompact) and retry
+  //   - 400 "Unexpected value" + "anthropic-beta" → disable for session (beta unsupported)
+  //   - 409      → disable for session (conflict)
+  //   - 529 / overloaded → disable for session (temporary overload)
+  // When disabled, we strip context-hint from betas + body on subsequent requests so
+  // we don't keep triggering the same rejection and churning the cache.
+  const contextHintState = {
+    /** Permanently disabled for this session after a server rejection. */
+    disabled: false,
+    /** Number of 422/424 compactions applied this session (for telemetry). */
+    compactionsApplied: 0,
+  };
+
+  // Token economy — session state for layered compaction strategies.
+  const tokenEconomySession = {
+    /** When thinking was last stripped (TTL-based strategy). 0 = never. */
+    lastThinkingStripMs: 0,
+    /** When proactive microcompact was last run (threshold-based). 0 = never. */
+    lastMicrocompactMs: 0,
+    /** Running count of tool_results client-compacted this session. */
+    toolResultsCompacted: 0,
+    /** Running count of thinking blocks stripped this session. */
+    thinkingStripped: 0,
+    /** Map of content-hash → first-seen tool_use_id for cross-turn dedupe. */
+    seenContentHashes: new Map(),
+  };
+
   // Cache TTL session latching: latch the cache policy at session start
   // so mid-session toggles don't bust the server-side prompt cache.
   let sessionCachePolicyLatched = false;
@@ -666,6 +695,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
       const secondary = (args[1] || "").toLowerCase();
       if (secondary === "reset") {
         sessionMetrics.turns = 0;
+        sessionMetrics.usedTools.clear();
         sessionMetrics.totalInput = 0;
         sessionMetrics.totalOutput = 0;
         sessionMetrics.totalCacheRead = 0;
@@ -1081,8 +1111,6 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
           const enabled = value === "on" || value === "true" || value === "1";
           const te = config.token_economy || {
             token_efficient_tools: true,
-            redact_thinking: false,
-            connector_text_summarization: true,
           };
           te.token_efficient_tools = enabled;
           saveConfig({ token_economy: te });
@@ -1094,25 +1122,35 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
           const enabled = value === "on" || value === "true" || value === "1";
           const te = config.token_economy || {
             token_efficient_tools: true,
-            redact_thinking: false,
-            connector_text_summarization: true,
           };
           te.redact_thinking = enabled;
           saveConfig({ token_economy: te });
           config.token_economy = te;
           betaLatchState.dirty = true;
         },
-        "connector-text": () => {
+        "tool-deferral": () => {
           const enabled = value === "on" || value === "true" || value === "1";
-          const te = config.token_economy || {
-            token_efficient_tools: true,
-            redact_thinking: false,
-            connector_text_summarization: true,
-          };
-          te.connector_text_summarization = enabled;
-          saveConfig({ token_economy: te });
-          config.token_economy = te;
-          betaLatchState.dirty = true;
+          saveConfig({ token_economy_strategies: { tool_deferral: enabled } });
+          if (!config.token_economy_strategies) config.token_economy_strategies = {};
+          config.token_economy_strategies.tool_deferral = enabled;
+        },
+        "tool-compaction": () => {
+          const enabled = value === "on" || value === "true" || value === "1";
+          saveConfig({ token_economy_strategies: { tool_description_compaction: enabled } });
+          if (!config.token_economy_strategies) config.token_economy_strategies = {};
+          config.token_economy_strategies.tool_description_compaction = enabled;
+        },
+        "adaptive-tools": () => {
+          const enabled = value === "on" || value === "true" || value === "1";
+          saveConfig({ token_economy_strategies: { adaptive_tool_set: enabled } });
+          if (!config.token_economy_strategies) config.token_economy_strategies = {};
+          config.token_economy_strategies.adaptive_tool_set = enabled;
+        },
+        "prompt-tailing": () => {
+          const enabled = value === "on" || value === "true" || value === "1";
+          saveConfig({ token_economy_strategies: { system_prompt_tailing: enabled } });
+          if (!config.token_economy_strategies) config.token_economy_strategies = {};
+          config.token_economy_strategies.system_prompt_tailing = enabled;
         },
       };
 
@@ -2703,8 +2741,19 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
 
                 const _adaptiveOverride = _adaptiveOverrideForRequest;
 
-                // Token economy config (resolved once, passed to beta builder)
-                const _tokenEconomy = config.token_economy || {};
+                // Token economy config (resolved once, passed to beta builder).
+                // If the server has rejected context-hint this session, reflect it here
+                // so buildAnthropicBetaHeader (called again inside buildRequestHeaders)
+                // drops the beta on subsequent requests.
+                // Also classify the request role (CC's querySource analog) and
+                // suppress context-hint for non-main-thread requests so we don't
+                // opt subagent/title/tool one-shots into a server retry loop.
+                const _requestRole = classifyRequestRole(_parsedBodyOnce);
+                const _baseTE = config.token_economy || {};
+                const _disableCtxHint = contextHintState.disabled || _requestRole !== "main";
+                const _tokenEconomy = _disableCtxHint
+                  ? { ..._baseTE, context_hint: false, __requestRole: _requestRole }
+                  : { ..._baseTE, __requestRole: _requestRole };
 
                 // Microcompact: inject clear betas at high context utilization
                 let _microcompactBetas = null;
@@ -2760,6 +2809,12 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                   // Merge latched betas that aren't in the current set
                   const merged = new Set(currentBetas);
                   for (const b of betaLatchState.sent) merged.add(b);
+                  // Context-hint kill switch: once server rejected it this session,
+                  // stop sending the beta (body field is gated on header, so it drops too).
+                  if (contextHintState.disabled) {
+                    merged.delete("context-hint-2026-04-09");
+                    betaLatchState.sent.delete("context-hint-2026-04-09");
+                  }
                   computedBetaHeader = [...merged].join(",");
                   betaLatchState.lastHeader = computedBetaHeader;
                 }
@@ -2785,11 +2840,21 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     cachePolicy: effectiveCachePolicy,
                     fastMode: config.fast_mode || false,
                     strategy: getEffectiveStrategy(),
+                    toolDeferral: config.token_economy_strategies?.tool_deferral,
+                    toolDescriptionCompaction: config.token_economy_strategies?.tool_description_compaction,
+                    adaptiveToolSet: config.token_economy_strategies?.adaptive_tool_set,
+                    systemPromptTailing: config.token_economy_strategies?.system_prompt_tailing,
+                    systemPromptTailTurns: config.token_economy_strategies?.system_prompt_tail_turns,
+                    systemPromptTailMaxChars: config.token_economy_strategies?.system_prompt_tail_max_chars,
                   },
                   {
                     persistentUserId: signatureUserId,
                     sessionId: signatureSessionId,
                     accountId: getAccountIdentifier(account),
+                    turns: sessionMetrics.turns,
+                    usedTools: sessionMetrics.usedTools,
+                    tokenEconomySession,
+                    requestRole: _requestRole,
                   },
                   computedBetaHeader,
                   config,
@@ -3152,6 +3217,63 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     // Ignore read errors in debug logging path.
                   }
 
+                  // Context-hint protocol (CC v2.1.110+): detect server rejections and
+                  // apply the same disable/compact semantics as real Claude Code.
+                  //   - 400 w/ "Unexpected value" + "anthropic-beta" → beta unsupported, disable
+                  //   - 409 / 529 / overloaded                      → temporary, disable
+                  //   - 422 / 424                                    → compact messages (strip
+                  //     thinking blocks + old tool_result content) and retry ONCE.
+                  // Disable is permanent for the session; the beta latch strips it from future
+                  // requests so we don't keep triggering the same rejection.
+                  if (!contextHintState.disabled) {
+                    if (
+                      response.status === 400 &&
+                      errorBody &&
+                      errorBody.includes("Unexpected value") &&
+                      errorBody.includes("anthropic-beta") &&
+                      errorBody.includes("context-hint")
+                    ) {
+                      contextHintState.disabled = true;
+                      betaLatchState.dirty = true;
+                      debugLog("context-hint: beta rejected by server (400), disabling for session");
+                    } else if (response.status === 409) {
+                      contextHintState.disabled = true;
+                      betaLatchState.dirty = true;
+                      debugLog("context-hint: 409 conflict, disabling for session");
+                    } else if (response.status === 529 && errorBody && errorBody.includes("context_hint")) {
+                      contextHintState.disabled = true;
+                      betaLatchState.dirty = true;
+                      debugLog("context-hint: 529 overloaded referencing hint, disabling for session");
+                    } else if (
+                      (response.status === 422 || response.status === 424) &&
+                      !requestInit._contextHintCompactAttempted
+                    ) {
+                      try {
+                        const hintBody = JSON.parse(requestInit.body);
+                        if (Array.isArray(hintBody.messages)) {
+                          const compacted = applyContextHintCompaction(hintBody.messages);
+                          if (compacted.changed) {
+                            hintBody.messages = compacted.messages;
+                            requestInit.body = JSON.stringify(hintBody);
+                            _parsedBodyOnce = null;
+                            requestInit._contextHintCompactAttempted = true;
+                            contextHintState.compactionsApplied += 1;
+                            attempt--;
+                            toast(
+                              `⚙ Context hint compaction (${response.status}) — cleared ${compacted.stats.thinkingCleared} thinking / ${compacted.stats.toolResultsCleared} tool results`,
+                              "info",
+                              { debounceKey: "context-hint-compact" },
+                            ).catch(() => {});
+                            debugLog("context-hint: applied compaction on status", response.status, compacted.stats);
+                            continue;
+                          }
+                        }
+                      } catch {
+                        // fall through to normal error handling
+                      }
+                    }
+                  }
+
                   // Reactive compaction: on "prompt too long" error, trim oldest messages and retry once
                   if (
                     response.status === 400 &&
@@ -3908,6 +4030,8 @@ const sessionMetrics = {
     continuations: 0,
     outputHistory: [], // last 5 output token deltas
   },
+  /** Tools used in this session (populated from assistant tool_use blocks in messages) */
+  usedTools: new Set(),
 };
 
 // ---------------------------------------------------------------------------
@@ -5058,17 +5182,25 @@ process.once("beforeExit", _beforeExitHandler);
 // Request building helpers (extracted from original fetch interceptor)
 // ---------------------------------------------------------------------------
 
-const FALLBACK_CLAUDE_CLI_VERSION = "2.1.107";
+const FALLBACK_CLAUDE_CLI_VERSION = "2.1.114";
 const CLAUDE_CODE_NPM_LATEST_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
-const CLAUDE_CODE_BUILD_TIME = "2026-04-14T03:13:25Z";
+const CLAUDE_CODE_BUILD_TIME = "2026-04-17T22:37:24Z";
 
 // The @anthropic-ai/sdk version bundled with Claude Code.
 // This is distinct from the CLI version and goes in X-Stainless-Package-Version.
-// v2.1.107 switched from @anthropic-ai/sdk v0.208.0 to v0.81.0 (confirmed via proxy capture).
+// v2.1.107 switched from @anthropic-ai/sdk v0.208.0 to v0.81.0 (confirmed via bundle var x$H="0.81.0").
+// Still 0.81.0 in v2.1.114 (verified via strings extraction from native Bun binary).
 const ANTHROPIC_SDK_VERSION = "0.81.0";
 
 // Map of CLI version → bundled SDK version (update when CLI version changes)
 const CLI_TO_SDK_VERSION = new Map([
+  ["2.1.114", "0.81.0"],
+  ["2.1.113", "0.81.0"],
+  ["2.1.112", "0.81.0"],
+  ["2.1.111", "0.81.0"],
+  ["2.1.110", "0.81.0"],
+  ["2.1.109", "0.81.0"],
+  ["2.1.108", "0.81.0"],
   ["2.1.107", "0.81.0"],
   ["2.1.105", "0.81.0"],
   ["2.1.97", "0.208.0"],
@@ -5186,6 +5318,334 @@ function computeBillingCacheHash(firstUserMessage, version) {
  * @param {Array} messages — The messages array from the parsed request body
  * @returns {Array} — Repaired messages array
  */
+/**
+ * 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 } }}
+ */
+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 });
+      }
+    }
+  }
+  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 },
+  };
+}
+
+/**
+ * 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 }}
+ */
+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 };
+  }
+
+  // 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;
+    }
+  }
+
+  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 }}
+ */
+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[]}
+ */
+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;
+  });
+}
+
+/**
+ * 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 }}
+ */
+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 }}
+ */
+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 }}
+ */
+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.
+ *
+ * @param {Array} messages
+ * @returns {{ messages: Array, changed: boolean, trimmed: number }}
+ */
+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;
 
@@ -5357,6 +5817,23 @@ const BEDROCK_UNSUPPORTED_BETAS = new Set([
   "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 EXPERIMENTAL_BETA_FLAGS = new Set([
   "adaptive-thinking-2026-01-28",
   "advanced-tool-use-2025-11-20",
@@ -5365,6 +5842,7 @@ const EXPERIMENTAL_BETA_FLAGS = new Set([
   "code-execution-2025-08-25",
   "compact-2026-01-12",
   "context-1m-2025-08-07",
+  "context-hint-2026-04-09",
   "context-management-2025-06-27",
   "fast-mode-2026-02-01",
   "files-api-2025-04-14",
@@ -5380,6 +5858,8 @@ const BETA_SHORTCUTS = new Map([
   ["1m", "context-1m-2025-08-07"],
   ["1m-context", "context-1m-2025-08-07"],
   ["context-1m", "context-1m-2025-08-07"],
+  ["context-hint", "context-hint-2026-04-09"],
+  ["hint", "context-hint-2026-04-09"],
   ["fast", "fast-mode-2026-02-01"],
   ["fast-mode", "fast-mode-2026-02-01"],
   ["opus-fast", "fast-mode-2026-02-01"],
@@ -5693,6 +6173,46 @@ function detectProvider(requestUrl) {
   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}}
@@ -5883,6 +6403,55 @@ function sanitizeSystemText(text) {
  * @param {'minimal' | 'off'} mode
  * @returns {string}
  */
+function tailSystemBlock(text, maxChars, turnThreshold) {
+  const lines = text.split("\n");
+  const kept = [];
+  let charCount = 0;
+  const importantRe = /\b(MUST|NEVER|CRITICAL|IMPORTANT|REQUIRED|DO NOT|ALWAYS|FORBIDDEN)\b/i;
+  const headerRe = /^#{1,4}\s/;
+  const listItemRe = /^\s*[-*]\s/;
+  // 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()
@@ -6231,6 +6800,21 @@ function buildSystemPromptBlocks(system, signature) {
     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,
@@ -6386,6 +6970,31 @@ function buildAnthropicBetaHeader(
     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-/i.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.
+  const isFirstPartyProvider = provider !== "vertex" && provider !== "bedrock" && provider !== "mantle";
+  // 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-/i.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");
@@ -6396,16 +7005,15 @@ function buildAnthropicBetaHeader(
     betas.push(TOKEN_COUNTING_BETA_FLAG);
   }
 
-  // === TOKEN ECONOMY BETAS (config-controlled) ===
+  // === TOKEN ECONOMY BETAS (on by default for token savings) ===
 
   // redact-thinking: suppresses thinking summaries server-side.
-  // When enabled, API returns redacted_thinking blocks instead of summaries.
-  // Saves bandwidth and tokens for users who don't inspect thinking.
+  // CC v108 enables this by default but we keep it off so thinking is visible.
+  // Users can opt in via `/anthropic set redact-thinking on`.
   if (te.redact_thinking && !disableExperimentalBetas) {
     betas.push("redact-thinking-2026-02-12");
   }
 
-  // summarize-connector-text-2026-03-13 was removed in v2.1.90 (dead slot njq="").
   // 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)
@@ -6418,8 +7026,11 @@ function buildAnthropicBetaHeader(
     }
   }
 
-  // Merge incoming betas from the original request
-  let mergedBetas = [...new Set([...betas, ...incomingBetasList])];
+  // 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) {
@@ -6713,7 +7324,7 @@ function resolveMaxTokens(body, config) {
  *
  * @param {string | undefined} body
  * @param {{enabled: boolean, claudeCliVersion: string, promptCompactionMode: 'minimal' | 'off', provider?: string}} signature
- * @param {{persistentUserId: string, sessionId: string, accountId: string}} runtime
+ * @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}
@@ -6805,14 +7416,127 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
       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;
+
+    if (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;
+        }
+      }
+
+      // (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 (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);
-    const signatureWithModel = { ...signature, modelId, firstUserMessage, antiVerbosity: config?.anti_verbosity };
+    const signatureWithModel = {
+      ...signature,
+      modelId,
+      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,
+    };
     // 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 !== false && 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);
@@ -6861,13 +7585,24 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
     ) {
       // 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 1h to the last user message
+      // our system prompt ttl=1h). Then add our own to the last user message
       // (matching real CC behavior seen in proxy capture).
-      const ccTtl = signature.cachePolicy?.ttl || "1h";
-      if (Array.isArray(parsed.tools)) {
+      //
+      // Role-scoped TTL: real CC's MoY(querySource) gates the `ttl:"1h"` field
+      // on an allowlist of query sources (`repl_main_thread*`, `sdk`,
+      // `auto_mode`). Non-matching requests fall back to the default 5m tier
+      // — which is cheaper to write. We match this via classifyRequestRole
+      // (main → configured TTL, usually 1h; everything else → 5m).
+      const configuredTtl = signature.cachePolicy?.ttl || "1h";
+      const roleScopedTtl = config?.token_economy?.role_scoped_cache_ttl !== false;
+      const isMainForCache = runtime?.requestRole === "main" || runtime?.requestRole == null;
+      const ccTtl = roleScopedTtl && !isMainForCache ? "5m" : configuredTtl;
+      if (Array.isArray(parsed.tools) && parsed.tools.length > 0) {
         for (const tool of parsed.tools) {
           if (tool.cache_control) delete tool.cache_control;
         }
+        // Add cache_control to last tool as prompt-cache breakpoint (CC does this)
+        parsed.tools[parsed.tools.length - 1].cache_control = { type: "ephemeral", ttl: ccTtl };
       }
       if (Array.isArray(parsed.messages)) {
         for (const msg of parsed.messages) {
@@ -6925,6 +7660,69 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
         }
       }
     }
+    // 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);
+        }
+      }
+    }
+
+    // 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;
+        }
+      }
+    }
+
     // 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.
@@ -6936,10 +7734,48 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
       }
     }
 
+    // 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 };
+    }
+
     // Fast mode: inject speed parameter for Opus 4.6 only (v2.1.97 restriction).
     // Real CC v2.1.97 xJ() checks: model.includes("opus-4-6") — Sonnet is NOT eligible.
     const fastModeEnabled = signature.fastMode && !isFalsyEnv(process.env.OPENCODE_ANTHROPIC_DISABLE_FAST_MODE);
-    if (fastModeEnabled && parsed.model && isOpus46Model(parsed.model)) {
+    let fastModeAutoApplied = false;
+    if (
+      !fastModeEnabled &&
+      te.fast_mode_auto === true &&
+      isMainRole &&
+      parsed.model &&
+      isOpus46Model(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 && isOpus46Model(parsed.model)) {
       parsed.speed = "fast";
     }
 
@@ -7019,6 +7855,22 @@ function transformRequestUrl(input) {
     }
   }
 
+  // MITM proxy redirect: rewrite host/port/protocol when OPENCODE_MITM_BASE_URL is set.
+  // This allows capturing the exact over-the-wire request for conformance testing.
+  // Example: OPENCODE_MITM_BASE_URL=http://localhost:9999
+  const mitmBase = process.env.OPENCODE_MITM_BASE_URL;
+  if (mitmBase && requestUrl) {
+    try {
+      const mitmUrl = new URL(mitmBase);
+      requestUrl.protocol = mitmUrl.protocol;
+      requestUrl.hostname = mitmUrl.hostname;
+      requestUrl.port = mitmUrl.port;
+      requestInput = input instanceof Request ? new Request(requestUrl.toString(), input) : requestUrl;
+    } catch {
+      // Invalid MITM URL — ignore silently
+    }
+  }
+
   return { requestInput, requestUrl };
 }
 
@@ -7189,10 +8041,10 @@ function stripMcpPrefixFromParsedEvent(parsed) {
 
   let modified = false;
 
-  // content_block_start: { content_block: { type: "tool_use", name: "..." } }
+  // 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_use" || parsed.content_block.type === "tool_reference") &&
     typeof parsed.content_block.name === "string"
   ) {
     const mapped = reverseMapToolName(parsed.content_block.name);
@@ -7202,10 +8054,10 @@ function stripMcpPrefixFromParsedEvent(parsed) {
     }
   }
 
-  // message_start: { message: { content: [{ type: "tool_use", name: "..." }] } }
+  // 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" && typeof block.name === "string") {
+      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;
@@ -7218,7 +8070,7 @@ function stripMcpPrefixFromParsedEvent(parsed) {
   // 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" && typeof block.name === "string") {
+      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;
@@ -7674,9 +8526,12 @@ function extractFileIds(body) {
 AnthropicAuthPlugin.__testing__ = {
   sanitizeSystemText,
   compactSystemText,
+  compactToolDescription,
   dedupeSystemBlocks,
   normalizeSystemTextBlocks,
   buildSystemPromptBlocks,
+  stripMcpPrefixFromParsedEvent,
+  CORE_TOOL_NAMES,
   get cachedCCPrompt() {
     return cachedCCPrompt;
   },

package/lib/config.mjs

@@ -190,12 +190,78 @@ export const DEFAULT_CONFIG = {
      *  This flag is retained for config backward compatibility but has no effect. */
     token_efficient_tools: false,
     /** Enable redact-thinking-2026-02-12 beta (suppresses thinking summaries
-     *  server-side for lower bandwidth). Off by default u2014 set to true if you
-     *  don't need to inspect thinking blocks. */
+     *  server-side for lower bandwidth). Off by default so thinking stays
+     *  visible. Opt in via `/anthropic set redact-thinking on`. */
     redact_thinking: false,
-    /** [DEPRECATED] summarize-connector-text-2026-03-13 was removed in CC v2.1.90.
-     *  This flag is retained for config backward compatibility but has no effect. */
-    connector_text_summarization: false,
+    /** Enable context-hint-2026-04-09 beta (CC v2.1.110+). When on, the server
+     *  MAY reject 422/424 and trigger client-side compaction retries.
+     *  Server-side rollout is partial — many accounts 400-reject the beta.
+     *  Off by default; the plugin still mimics CC's error-handling semantics
+     *  when a user opts in. Even when on, the beta is only sent for requests
+     *  classified as "main-thread" (see classifyRequestRole). */
+    context_hint: false,
+
+    /** TTL-based thinking strip (CC parity). When the time since the last
+     *  thinking strip exceeds the cache TTL, drop all `thinking` /
+     *  `redacted_thinking` blocks from prior assistant messages. Mirrors CC's
+     *  `logThinkingClearLatched("ttl", ...)` behavior. Zero quality impact
+     *  because stale thinking blocks don't influence the next response. */
+    ttl_thinking_strip: true,
+
+    /** Proactive client-side microcompact. At or above `microcompact_percent`
+     *  of the model context window, replace old tool_result content with a
+     *  placeholder (keeping the last `microcompact_keep_recent` verbatim).
+     *  Runs BEFORE the request hits the server — preempts 422s. */
+    proactive_microcompact: true,
+    microcompact_percent: 70,
+    microcompact_keep_recent: 8,
+
+    /** Stable tool ordering — sort tools deterministically across turns so
+     *  the system-prompt prefix stays cache-stable. Safe and cheap. */
+    stable_tool_ordering: true,
+
+    /** Tool schema deferral — ship minimal (name+description only) schemas
+     *  for tools below the defer threshold until they're actually invoked in
+     *  the session. Accepts a list of tool names to defer. Empty = feature off. */
+    deferred_tool_names: [],
+
+    /** Adaptive thinking — zero the thinking budget for simple follow-up
+     *  user turns (short user message, no file refs, no tool_use in prior
+     *  assistant turn). Reduces thinking tokens on trivial exchanges. */
+    adaptive_thinking_zero_simple: true,
+
+    /** Cross-turn tool_result dedupe — when the same (tool_use_name + input)
+     *  appears twice, replace the later result content with a pointer to the
+     *  earlier tool_use_id. Opt-in; can surprise models that expected a fresh
+     *  read. Applies only to read-only tools in the safe set. */
+    tool_result_dedupe: false,
+
+    /** Fast-mode auto-opt-in — detect simple exchanges (short user msg, no
+     *  tools likely needed) and emit speed:fast for that turn. Opt-in. */
+    fast_mode_auto: false,
+
+    /** Trailing-summary trimmer — detect trailing summary paragraphs in past
+     *  assistant text blocks and strip them from the outgoing messages array.
+     *  Opt-in; can hide context the model relied on. */
+    trailing_summary_trim: false,
+
+    /** Role-scoped cache TTL (CC parity). Real CC's MoY(querySource) gates
+     *  `ttl:"1h"` on an allowlist of query sources (`repl_main_thread*`, `sdk`,
+     *  `auto_mode`). Everything else falls back to the 5m tier, which is
+     *  cheaper to write. Matches by classifying request role: main → 1h (or
+     *  whatever signature.cachePolicy.ttl is configured as), else → 5m. */
+    role_scoped_cache_ttl: true,
+
+    /** Lean system prompt for non-main requests. For title-gen / small /
+     *  subagent-shaped requests, strip billing identity + CC identity
+     *  injection. Saves ~1-2kB per request. Opt-in: changes the system-prompt
+     *  shape that downstream observers (billing/telemetry) may rely on, so
+     *  enable deliberately rather than by default. */
+    lean_system_non_main: false,
+
+    // NOTE: identical-tool-call short-circuit was considered but requires SSE
+    // response-stream rewriting that breaks normal tool-execution semantics.
+    // Tracked as future work — not exposed as a config flag here.
   },
   /** Output cap: default max_tokens to save context window. */
   output_cap: {
@@ -577,10 +643,56 @@ function validateConfig(raw) {
           : DEFAULT_CONFIG.token_economy.token_efficient_tools,
       redact_thinking:
         typeof te.redact_thinking === "boolean" ? te.redact_thinking : DEFAULT_CONFIG.token_economy.redact_thinking,
-      connector_text_summarization:
-        typeof te.connector_text_summarization === "boolean"
-          ? te.connector_text_summarization
-          : DEFAULT_CONFIG.token_economy.connector_text_summarization,
+      context_hint: typeof te.context_hint === "boolean" ? te.context_hint : DEFAULT_CONFIG.token_economy.context_hint,
+      ttl_thinking_strip:
+        typeof te.ttl_thinking_strip === "boolean"
+          ? te.ttl_thinking_strip
+          : DEFAULT_CONFIG.token_economy.ttl_thinking_strip,
+      proactive_microcompact:
+        typeof te.proactive_microcompact === "boolean"
+          ? te.proactive_microcompact
+          : DEFAULT_CONFIG.token_economy.proactive_microcompact,
+      microcompact_percent: clampNumber(
+        te.microcompact_percent,
+        30,
+        95,
+        DEFAULT_CONFIG.token_economy.microcompact_percent,
+      ),
+      microcompact_keep_recent: clampNumber(
+        te.microcompact_keep_recent,
+        1,
+        64,
+        DEFAULT_CONFIG.token_economy.microcompact_keep_recent,
+      ),
+      stable_tool_ordering:
+        typeof te.stable_tool_ordering === "boolean"
+          ? te.stable_tool_ordering
+          : DEFAULT_CONFIG.token_economy.stable_tool_ordering,
+      deferred_tool_names: Array.isArray(te.deferred_tool_names)
+        ? te.deferred_tool_names.filter((n) => typeof n === "string")
+        : DEFAULT_CONFIG.token_economy.deferred_tool_names,
+      adaptive_thinking_zero_simple:
+        typeof te.adaptive_thinking_zero_simple === "boolean"
+          ? te.adaptive_thinking_zero_simple
+          : DEFAULT_CONFIG.token_economy.adaptive_thinking_zero_simple,
+      tool_result_dedupe:
+        typeof te.tool_result_dedupe === "boolean"
+          ? te.tool_result_dedupe
+          : DEFAULT_CONFIG.token_economy.tool_result_dedupe,
+      fast_mode_auto:
+        typeof te.fast_mode_auto === "boolean" ? te.fast_mode_auto : DEFAULT_CONFIG.token_economy.fast_mode_auto,
+      trailing_summary_trim:
+        typeof te.trailing_summary_trim === "boolean"
+          ? te.trailing_summary_trim
+          : DEFAULT_CONFIG.token_economy.trailing_summary_trim,
+      role_scoped_cache_ttl:
+        typeof te.role_scoped_cache_ttl === "boolean"
+          ? te.role_scoped_cache_ttl
+          : DEFAULT_CONFIG.token_economy.role_scoped_cache_ttl,
+      lean_system_non_main:
+        typeof te.lean_system_non_main === "boolean"
+          ? te.lean_system_non_main
+          : DEFAULT_CONFIG.token_economy.lean_system_non_main,
     };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.1.8",
+  "version": "0.1.11",
   "license": "GPL-3.0-or-later",
   "main": "./index.mjs",
   "files": [