opencode-anthropic-fix 0.0.37 → 0.0.39

package/index.mjs

@@ -158,6 +158,24 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
   let willowLastRequestTime = Date.now();
   let willowLastSuggestionTime = 0;
 
+  // Beta header latching: once a beta is sent in a session, it stays on for
+  // the rest of the session to prevent cache key churn (~50-70K tokens per flip).
+  // Cleared on /clear or /compact if needed.
+  const betaLatchState = {
+    /** @type {Set<string>} betas that have been sent at least once this session */
+    sent: new Set(),
+    /** When true, a config change invalidated the latch and next request rebuilds. */
+    dirty: false,
+    /** @type {string | null} The last computed beta header string (for latching). */
+    lastHeader: null,
+  };
+
+  // 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;
+  /** @type {{ttl: string, ttl_supported: boolean, boundary_marker?: boolean} | null} */
+  let latchedCachePolicy = null;
+
   /**
    * Whether OPENCODE_ANTHROPIC_INITIAL_ACCOUNT env var pinned this session to a
    * specific account. When true, syncActiveIndexFromDisk is skipped and strategy
@@ -846,6 +864,43 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
             adaptiveContextState.lastTransitionTurn = sessionMetrics.turns;
           }
         },
+        "token-efficient-tools": () => {
+          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 });
+          config.token_economy = te;
+          // Invalidate latched betas so the change takes effect next request
+          betaLatchState.dirty = true;
+        },
+        "redact-thinking": () => {
+          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": () => {
+          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;
+        },
       };
 
       if (!key || !setters[key]) {
@@ -2397,7 +2452,10 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
 
                 const _adaptiveOverride = _adaptiveOverrideForRequest;
 
-                const computedBetaHeader = buildAnthropicBetaHeader(
+                // Token economy config (resolved once, passed to beta builder)
+                const _tokenEconomy = config.token_economy || {};
+
+                let computedBetaHeader = buildAnthropicBetaHeader(
                   "",
                   getSignatureEmulationEnabled(),
                   _reqModel,
@@ -2407,8 +2465,43 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                   requestUrl?.pathname,
                   _reqHasFileRefs,
                   _adaptiveOverride,
+                  _tokenEconomy,
                 );
 
+                // Beta header latching: once a beta has been sent in this session,
+                // keep sending it to avoid server-side cache key churn (~50-70K tokens
+                // per flip). The latch is sticky-on: new betas can be added but never
+                // removed mid-session unless explicitly invalidated by config change.
+                {
+                  const currentBetas = computedBetaHeader
+                    .split(",")
+                    .map((b) => b.trim())
+                    .filter(Boolean);
+                  // Add all current betas to the latch set
+                  for (const b of currentBetas) betaLatchState.sent.add(b);
+                  // If a config change dirtied the latch, rebuild from current (allow removal)
+                  if (betaLatchState.dirty) {
+                    betaLatchState.dirty = false;
+                    betaLatchState.sent = new Set(currentBetas);
+                  }
+                  // Merge latched betas that aren't in the current set
+                  const merged = new Set(currentBetas);
+                  for (const b of betaLatchState.sent) merged.add(b);
+                  computedBetaHeader = [...merged].join(",");
+                  betaLatchState.lastHeader = computedBetaHeader;
+                }
+
+                // Cache TTL session latching: latch the cache policy at session start
+                // so mid-session toggles don't bust the server-side prompt cache.
+                if (!sessionCachePolicyLatched) {
+                  sessionCachePolicyLatched = true;
+                  latchedCachePolicy = config.cache_policy
+                    ? { ...config.cache_policy }
+                    : { ttl: "1h", ttl_supported: true };
+                }
+                const effectiveCachePolicy = latchedCachePolicy ||
+                  config.cache_policy || { ttl: "1h", ttl_supported: true };
+
                 let body = transformRequestBody(
                   requestInit.body,
                   {
@@ -2416,7 +2509,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     claudeCliVersion,
                     promptCompactionMode: getPromptCompactionMode(),
                     provider: _reqProvider,
-                    cachePolicy: config.cache_policy || { ttl: "1h", ttl_supported: true },
+                    cachePolicy: effectiveCachePolicy,
                     fastMode: config.fast_mode || false,
                     strategy: getEffectiveStrategy(),
                   },
@@ -2443,6 +2536,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     strategy: getEffectiveStrategy(),
                   },
                   _adaptiveOverride,
+                  _tokenEconomy,
                 );
                 // Execute the request
                 let response;
@@ -2629,10 +2723,15 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     // Auto-escalate adaptive context on prompt_too_long so the retry
                     // includes the 1M beta header (if model supports it).
                     if (config.adaptive_context?.enabled) {
-                      forceEscalateAdaptiveContext();
-                      toast("⬡ 1M context force-activated (prompt too long)", "warning", {
-                        debounceKey: "adaptive-ctx",
-                      }).catch(() => {});
+                      const stateChanged = forceEscalateAdaptiveContext();
+                      if (stateChanged) {
+                        // Invalidate cached adaptive decision so the retry loop
+                        // re-evaluates with the new active=true state.
+                        _adaptiveDecisionMade = false;
+                        toast("⬡ 1M context force-activated (prompt too long)", "warning", {
+                          debounceKey: "adaptive-ctx",
+                        }).catch(() => {});
+                      }
                     }
                     try {
                       const parsedBody = JSON.parse(body);
@@ -3215,7 +3314,7 @@ function estimatePromptTokens(bodyString) {
  * @returns {boolean}
  */
 function resolveAdaptiveContext(bodyString, model, adaptiveConfig) {
-  // Non-adaptive: use static check
+  // Non-adaptive: use static check (only explicit "1m" models)
   if (!adaptiveConfig.enabled) {
     return hasOneMillionContext(model);
   }
@@ -3225,8 +3324,8 @@ function resolveAdaptiveContext(bodyString, model, adaptiveConfig) {
     return false;
   }
 
-  // Model must be eligible for 1M context at all
-  if (!hasOneMillionContext(model)) {
+  // Model must be eligible for 1M context at all (includes Opus 4.6)
+  if (!isEligibleFor1MContext(model)) {
     return false;
   }
 
@@ -3235,10 +3334,25 @@ function resolveAdaptiveContext(bodyString, model, adaptiveConfig) {
 
   if (adaptiveContextState.active) {
     // Currently active — consider de-escalation
-    // Don't de-escalate if error-escalated (sticky)
+
+    // Error-escalated: sticky for ERROR_STICKY_TURNS turns, then allow de-escalation
+    // if prompt has dropped well below threshold (prevents permanent 1M lock-in).
+    const ERROR_STICKY_TURNS = 5;
     if (adaptiveContextState.escalatedByError) {
-      return true;
+      if (turnsSinceTransition < ERROR_STICKY_TURNS) {
+        return true; // Still within sticky window
+      }
+      // Past sticky window: allow de-escalation if tokens dropped significantly
+      // (below 75% of deescalation threshold to avoid flapping)
+      if (estimatedTokens < adaptiveConfig.deescalation_threshold * 0.75) {
+        adaptiveContextState.active = false;
+        adaptiveContextState.escalatedByError = false;
+        adaptiveContextState.lastTransitionTurn = sessionMetrics.turns;
+        return false;
+      }
+      return true; // Still high enough to keep 1M
     }
+
     // Hysteresis: require at least 2 turns before considering de-escalation
     if (turnsSinceTransition < 2) {
       return true;
@@ -3268,13 +3382,17 @@ function resolveAdaptiveContext(bodyString, model, adaptiveConfig) {
 
 /**
  * Force-escalate adaptive context (e.g. after prompt_too_long error).
+ * Returns true so callers can invalidate cached decisions.
+ * @returns {boolean}
  */
 function forceEscalateAdaptiveContext() {
+  const wasActive = adaptiveContextState.active;
   if (!adaptiveContextState.active) {
     adaptiveContextState.active = true;
     adaptiveContextState.lastTransitionTurn = sessionMetrics.turns;
   }
   adaptiveContextState.escalatedByError = true;
+  return !wasActive; // true if state actually changed
 }
 
 const MODEL_PRICING = {
@@ -3607,6 +3725,96 @@ function computeBillingCacheHash(firstUserMessage, version) {
  * @param {any[] | undefined} messages
  * @returns {string}
  */
+/**
+ * Strip leaked /anthropic slash command messages from conversation history.
+ *
+ * When a user runs `/anthropic <subcommand>`, OpenCode may still include the
+ * command text as a user message and the sendCommandMessage output as an
+ * assistant message in the API request. This function removes those messages
+ * so the model never sees internal plugin commands in its context.
+ *
+ * Detection heuristics:
+ * - User messages that start with `/anthropic` (with optional leading whitespace)
+ * - User messages where the ONLY text content is a `/anthropic` command
+ * - Assistant messages that start with the `▣ Anthropic` prefix used by sendCommandMessage
+ *
+ * After filtering, if the last remaining message is an assistant message, drop it
+ * to maintain the user→assistant alternation required by the API.
+ *
+ * @param {Array} messages — The messages array from the parsed request body
+ * @returns {Array} — Filtered messages array
+ */
+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);
+  }
+
+  /**
+   * 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);
+  }
+
+  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;
+    }
+
+    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) {
@@ -3656,6 +3864,8 @@ const EXPERIMENTAL_BETA_FLAGS = new Set([
   "prompt-caching-scope-2026-01-05",
   "redact-thinking-2026-02-12",
   "structured-outputs-2025-12-15",
+  "summarize-connector-text-2026-03-13",
+  "token-efficient-tools-2026-03-28",
   "tool-examples-2025-10-29",
   "tool-search-tool-2025-10-19",
   "web-search-2025-03-05",
@@ -3669,6 +3879,11 @@ const BETA_SHORTCUTS = new Map([
   ["opus-fast", "fast-mode-2026-02-01"],
   ["task-budgets", "task-budgets-2026-03-13"],
   ["budgets", "task-budgets-2026-03-13"],
+  ["efficient-tools", "token-efficient-tools-2026-03-28"],
+  ["token-efficient", "token-efficient-tools-2026-03-28"],
+  ["redact-thinking", "redact-thinking-2026-02-12"],
+  ["connector-text", "summarize-connector-text-2026-03-13"],
+  ["anti-distill", "summarize-connector-text-2026-03-13"],
 ]);
 const STAINLESS_HELPER_KEYS = [
   "x_stainless_helper",
@@ -3884,14 +4099,26 @@ function isAdaptiveThinkingModel(model) {
 }
 
 /**
- * @param {string | undefined} body
+ * Check if a model is eligible for 1M context (can receive context-1m beta).
+ * This includes models with explicit "1m" in the name AND Opus 4.6.
+ * @param {string} model
  * @returns {boolean}
  */
-function hasOneMillionContext(model) {
-  // Models with explicit 1m suffix, or Opus 4.6 (1M by default since v2.1.75).
+function isEligibleFor1MContext(model) {
   return /(^|[-_ ])1m($|[-_ ])|context[-_]?1m/i.test(model) || isOpus46Model(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}
@@ -4324,6 +4551,7 @@ function buildAnthropicBetaHeader(
   requestPath,
   hasFileReferences,
   adaptiveOverride,
+  tokenEconomy,
 ) {
   const incomingBetasList = incomingBeta
     .split(",")
@@ -4350,13 +4578,23 @@ function buildAnthropicBetaHeader(
   const nonInteractive = isNonInteractiveMode();
   const haiku = isHaikuModel(model);
   const isRoundRobin = strategy === "round-robin";
+  const te = tokenEconomy || {};
 
   // === ALWAYS-ON BETAS (Claude Code v2.1.84 base set) ===
   // These are ALWAYS included regardless of env vars or feature flags.
   if (!haiku) {
     betas.push(CLAUDE_CODE_BETA_FLAG); // "claude-code-20250219"
   }
-  betas.push(ADVANCED_TOOL_USE_BETA_FLAG); // "advanced-tool-use-2025-11-20"
+
+  // Tool search: use provider-aware header.
+  // 1P/Foundry → advanced-tool-use-2025-11-20 (enables broader tool capabilities)
+  // Vertex/Bedrock → tool-search-tool-2025-10-19 (3P-compatible subset)
+  if (provider === "vertex" || provider === "bedrock") {
+    betas.push("tool-search-tool-2025-10-19");
+  } else {
+    betas.push(ADVANCED_TOOL_USE_BETA_FLAG); // "advanced-tool-use-2025-11-20"
+  }
+
   betas.push(FAST_MODE_BETA_FLAG); // "fast-mode-2026-02-01"
   betas.push(EFFORT_BETA_FLAG); // "effort-2025-11-24"
 
@@ -4386,8 +4624,14 @@ function buildAnthropicBetaHeader(
   // Context management — always-on in Claude Code (not env-gated)
   betas.push("context-management-2025-06-27");
 
-  // Structured outputs — always-on for capable models
-  if (supportsStructuredOutputs(model)) {
+  // Structured outputs vs token-efficient-tools: mutually exclusive.
+  // token-efficient-tools gives ~4.5% output token reduction (JSON FC v3).
+  // When both are configured, token-efficient-tools wins (per CC source:
+  // "strict wins" internally, but we prefer token savings for proxy users).
+  if (te.token_efficient_tools && !disableExperimentalBetas) {
+    betas.push("token-efficient-tools-2026-03-28");
+    // Skip structured-outputs — API rejects both together
+  } else if (supportsStructuredOutputs(model)) {
     betas.push("structured-outputs-2025-12-15");
   }
 
@@ -4396,9 +4640,6 @@ function buildAnthropicBetaHeader(
     betas.push("web-search-2025-03-05");
   }
 
-  // Tool search tool
-  betas.push("tool-search-tool-2025-10-19");
-
   // Files API — scoped to file endpoints/references
   if (isFilesEndpoint || hasFileReferences) {
     betas.push("files-api-2025-04-14");
@@ -4409,10 +4650,20 @@ function buildAnthropicBetaHeader(
     betas.push(TOKEN_COUNTING_BETA_FLAG);
   }
 
-  // === OPTIONAL BETAS (env-gated, intentionally NOT always-on) ===
+  // === TOKEN ECONOMY BETAS (config-controlled) ===
+
+  // 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.
+  if (te.redact_thinking && !disableExperimentalBetas) {
+    betas.push("redact-thinking-2026-02-12");
+  }
 
-  // redact-thinking — NOT auto-included (users benefit from seeing thinking blocks)
-  // Available via: /anthropic betas add redact-thinking-2026-02-12
+  // summarize-connector-text: API summarizes assistant text between tool calls.
+  // Anti-distillation measure — same mechanism as thinking blocks (summary + signature).
+  if (te.connector_text_summarization && !disableExperimentalBetas) {
+    betas.push("summarize-connector-text-2026-03-13");
+  }
 
   // afk-mode — NOT auto-included (requires user opt-in)
   // Available via: /anthropic betas add afk-mode-2026-01-31
@@ -4559,7 +4810,16 @@ async function fetchLatestClaudeCodeVersion(timeoutMs = 1200) {
  * @param {{enabled: boolean, claudeCliVersion: string, strategy?: import('./lib/config.mjs').AccountSelectionStrategy, customBetas?: string[]}} signature
  * @returns {Headers}
  */
-function buildRequestHeaders(input, requestInit, accessToken, requestBody, requestUrl, signature, adaptiveOverride) {
+function buildRequestHeaders(
+  input,
+  requestInit,
+  accessToken,
+  requestBody,
+  requestUrl,
+  signature,
+  adaptiveOverride,
+  tokenEconomy,
+) {
   const requestHeaders = new Headers();
   if (input instanceof Request) {
     input.headers.forEach((value, key) => {
@@ -4600,6 +4860,7 @@ function buildRequestHeaders(input, requestInit, accessToken, requestBody, reque
     requestUrl?.pathname,
     hasFileReferences,
     adaptiveOverride,
+    tokenEconomy,
   );
 
   const authTokenOverride = process.env.ANTHROPIC_AUTH_TOKEN?.trim();
@@ -4727,6 +4988,14 @@ function transformRequestBody(body, signature, runtime, betaHeader) {
       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);
+    }
+
     // 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)
@@ -4753,7 +5022,15 @@ function transformRequestBody(body, signature, runtime, betaHeader) {
     // 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).
-    if (signature.enabled && signature.cachePolicy?.ttl !== "off" && signature.cachePolicy?.ttl_supported !== false) {
+    // 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
+    ) {
       const strategy = signature.strategy || "sticky";
       if (strategy !== "round-robin" && Array.isArray(parsed.messages)) {
         const cacheControl = { type: "ephemeral", ttl: signature.cachePolicy?.ttl || "1h" };

package/lib/config.mjs

@@ -166,6 +166,19 @@ export const DEFAULT_CONFIG = {
      *  (no point suggesting reset at the start of a session). */
     min_turns_before_suggest: 3,
   },
+  /** Token economy optimizations. */
+  token_economy: {
+    /** Enable token-efficient-tools-2026-03-28 beta (~4.5% output token reduction).
+     *  Mutually exclusive with structured-outputs — this flag takes precedence. */
+    token_efficient_tools: true,
+    /** Enable redact-thinking-2026-02-12 beta (suppresses thinking summaries
+     *  server-side for lower bandwidth). Off by default — set to true if you
+     *  don't need to inspect thinking blocks. */
+    redact_thinking: false,
+    /** Enable summarize-connector-text-2026-03-13 beta (API summarizes assistant
+     *  text between tool calls — anti-distillation measure). */
+    connector_text_summarization: true,
+  },
 };
 
 export const VALID_STRATEGIES = ["sticky", "round-robin", "hybrid"];
@@ -194,6 +207,7 @@ function createDefaultConfig() {
     cc_credential_reuse: { ...DEFAULT_CONFIG.cc_credential_reuse },
     adaptive_context: { ...DEFAULT_CONFIG.adaptive_context },
     willow_mode: { ...DEFAULT_CONFIG.willow_mode },
+    token_economy: { ...DEFAULT_CONFIG.token_economy },
   };
 }
 

package/package.json

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