opencode-anthropic-fix 2.0.0 → 2.1.0

package/lib/mimicry/adapter-input.mjs

@@ -30,7 +30,7 @@ import {
   supportsStructuredOutputs,
   supportsWebSearch,
   WIRE_PROFILE,
-  BETA_REGISTRY_2_1_233,
+  BETA_REGISTRY_2_1_280,
 } from "./wire-compat.mjs";
 import { BETA_SHORTCUTS, EXPERIMENTAL_BETA_FLAGS } from "../betas.mjs";
 import { resolveCacheTtl } from "./cache.mjs";
@@ -149,7 +149,145 @@ export const MAX_SUPPRESS_BETAS = 32;
  * registry through the seam rather than re-typed here: if the package ever
  * re-dates the beta, the suppression keeps matching what the package composes.
  */
-export const PROMPT_CACHING_SCOPE_BETA = BETA_REGISTRY_2_1_233.PROMPT_CACHING_SCOPE.header;
+export const PROMPT_CACHING_SCOPE_BETA = BETA_REGISTRY_2_1_280.PROMPT_CACHING_SCOPE.header;
+
+/**
+ * Betas the session-rejected-beta latch may NEVER suppress, whatever an error
+ * body names. `suppressBetas` is unguarded package-side ("Suppressing
+ * `oauth-2025-04-20` produces a request the API rejects with 401"), so the guard
+ * lives here: OAuth first, and the Claude Code identity beta stays on the wire.
+ * Applies only to the rejected-beta input, never to the policy suppressions.
+ */
+export const UNSUPPRESSIBLE_BETAS = new Set([BETA_REGISTRY_2_1_280.OAUTH_AUTH.header, CLAUDE_CODE_BETA_FLAG]);
+
+/**
+ * Betas whose presence is COUPLED to a request-body field, so the rejected-beta
+ * latch must never suppress them: `suppressBetas` only filters the header, and
+ * the package (or the plugin's own body transform) still writes the paired body
+ * field, producing a request that is neither genuine nor valid. For latching
+ * purposes they are treated like `UNSUPPRESSIBLE_BETAS`: a rejection naming one
+ * surfaces as before. Headers are read from the package registry through the
+ * seam. The pairings, verified against wire-compat 0.7.0 `dist/betas.js` and
+ * `dist/request-body.js` (plus lib/mimicry/request-body.mjs for task budgets):
+ *
+ *  - thinking-display-updates -> `thinking.display: "updates"` (site 12b pair)
+ *  - context-management       -> `context_management`
+ *  - effort                   -> `output_config.effort`
+ *  - structured-outputs       -> `output_format`
+ *  - fast-mode (SPEED)        -> `speed`
+ *  - task-budgets             -> `output_config` (plugin body transform)
+ *  - context-hint             -> `context_hint`
+ *  - extended-cache-ttl       -> `cache_control.ttl: "1h"` (package `cacheTtl`)
+ *  - files-api                -> file references in `messages`
+ *  - mcp-servers              -> `mcp_servers` (experimental body passthrough)
+ *
+ * `thinking-binding-controls` is NOT listed: the package emits it header-only
+ * (its `thinking.block_binding` field is never written).
+ */
+export const BODY_COUPLED_BETAS = new Set([
+  BETA_REGISTRY_2_1_280.THINKING_DISPLAY_UPDATES.header,
+  BETA_REGISTRY_2_1_280.CONTEXT_MANAGEMENT.header,
+  BETA_REGISTRY_2_1_280.EFFORT.header,
+  BETA_REGISTRY_2_1_280.STRUCTURED_OUTPUTS.header,
+  BETA_REGISTRY_2_1_280.SPEED.header,
+  BETA_REGISTRY_2_1_280.TASK_BUDGETS.header,
+  BETA_REGISTRY_2_1_280.CONTEXT_HINT.header,
+  BETA_REGISTRY_2_1_280.EXTENDED_CACHE_TTL.header,
+  BETA_REGISTRY_2_1_280.FILES_API.header,
+  BETA_REGISTRY_2_1_280.MCP_SERVERS.header,
+]);
+
+/**
+ * Upper bound on sent betas one rejection may latch. The API names the one or
+ * two identifiers it refused; more matches than this means the error echoed the
+ * whole header back, and latching from it would strip betas that were fine.
+ */
+export const MAX_LATCHABLE_REJECTED_BETAS = 2;
+
+/** The package's `suppressBetas` entry grammar; anything else is `INVALID_INPUT`. */
+const BETA_IDENTIFIER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const BETA_IDENTIFIER_MAX_LENGTH = 128;
+
+/**
+ * The API's invalid-beta message shape:
+ * "Unexpected value(s) `a`, `b` for the `anthropic-beta` header. ...".
+ * Group 1 is the value list; quoting varies (backtick / single / double).
+ * The separators are literal single spaces, not `\s+`: two `\s+` runs around a
+ * lazy group backtrack catastrophically on long whitespace (ReDoS).
+ */
+const INVALID_BETA_MESSAGE_PATTERN = /Unexpected value\(s\) (.*?) for the [`'"]?anthropic-beta[`'"]? header/i;
+/**
+ * Only this much of the message is matched. The API's invalid-beta sentence
+ * sits at the start and is far shorter; the cap bounds the lazy scan above on
+ * a hostile or runaway body (the pattern is linear per start position, and
+ * the cap keeps start positions x scan length small).
+ */
+const INVALID_BETA_MESSAGE_SCAN_LIMIT = 2048;
+const QUOTED_BETA_PATTERN = /[`'"]([A-Za-z0-9][A-Za-z0-9._-]*)[`'"]/g;
+
+/**
+ * Extract the beta identifiers an Anthropic invalid-beta error names. Only the
+ * specific "Unexpected value(s) ... for the `anthropic-beta` header" shape is
+ * recognised, read from `error.message` when the body is the JSON error
+ * envelope (the raw text otherwise). Any other wording yields `[]`, so a body
+ * that merely mentions a beta name elsewhere never drives the latch.
+ *
+ * @param {string | null | undefined} errorBody Raw response body text.
+ * @returns {string[]} Named identifiers, in message order, deduplicated.
+ */
+export function parseRejectedBetaNames(errorBody) {
+  if (typeof errorBody !== "string" || !errorBody) return [];
+  let message = errorBody;
+  try {
+    const parsed = JSON.parse(errorBody);
+    if (typeof parsed?.error?.message === "string") message = parsed.error.message;
+  } catch {
+    // Not JSON: match against the raw text.
+  }
+  const match = INVALID_BETA_MESSAGE_PATTERN.exec(message.slice(0, INVALID_BETA_MESSAGE_SCAN_LIMIT));
+  if (!match) return [];
+  const list = match[1];
+  const names = [...list.matchAll(QUOTED_BETA_PATTERN)].map((m) => m[1]);
+  const candidates = names.length > 0 ? names : list.split(/[\s,]+/);
+  return [
+    ...new Set(
+      candidates.filter(
+        (name) => name && name.length <= BETA_IDENTIFIER_MAX_LENGTH && BETA_IDENTIFIER_PATTERN.test(name),
+      ),
+    ),
+  ];
+}
+
+/**
+ * Decide which betas of a rejected request the latch may suppress.
+ *
+ * `namedSent` is every identifier on the failing request's `anthropic-beta`
+ * header that the invalid-beta message names (see `parseRejectedBetaNames`),
+ * UNSUPPRESSIBLE ones included; it is empty when the message is not that
+ * shape or when it looks like an echoed header (more than
+ * `MAX_LATCHABLE_REJECTED_BETAS` suppressible matches). `latchable` is
+ * `namedSent` minus `UNSUPPRESSIBLE_BETAS` and `BODY_COUPLED_BETAS`.
+ *
+ * @param {string | null | undefined} sentHeader The failing request's `anthropic-beta` value.
+ * @param {string | null | undefined} errorBody Raw response body text.
+ * @returns {{namedSent: string[], latchable: string[]}}
+ */
+export function selectLatchableRejectedBetas(sentHeader, errorBody) {
+  const named = new Set(parseRejectedBetaNames(errorBody).map((name) => name.toLowerCase()));
+  if (named.size === 0) return { namedSent: [], latchable: [] };
+  const sent = [
+    ...new Set(
+      String(sentHeader ?? "")
+        .split(",")
+        .map((b) => b.trim())
+        .filter(Boolean),
+    ),
+  ];
+  const namedSent = sent.filter((b) => named.has(b.toLowerCase()));
+  const suppressible = namedSent.filter((b) => !UNSUPPRESSIBLE_BETAS.has(b.toLowerCase()));
+  if (suppressible.length > MAX_LATCHABLE_REJECTED_BETAS) return { namedSent: [], latchable: [] };
+  return { namedSent, latchable: suppressible.filter((b) => !BODY_COUPLED_BETAS.has(b.toLowerCase())) };
+}
 
 /**
  * Betas the plugin opts INTO on its own (see `buildAdditionalBetas`): whether
@@ -161,11 +299,11 @@ export const PROMPT_CACHING_SCOPE_BETA = BETA_REGISTRY_2_1_233.PROMPT_CACHING_SC
  * rename or date bump surfaces as a changed emission instead of drifting
  * silently against a literal re-typed in this file.
  */
-export const WEB_SEARCH_BETA = BETA_REGISTRY_2_1_233.WEB_SEARCH.header;
-export const ADVISOR_TOOL_BETA = BETA_REGISTRY_2_1_233.ADVISOR_TOOL.header;
-export const FILES_API_BETA = BETA_REGISTRY_2_1_233.FILES_API.header;
-export const EXTENDED_CACHE_TTL_BETA = BETA_REGISTRY_2_1_233.EXTENDED_CACHE_TTL.header;
-export const STRUCTURED_OUTPUTS_BETA = BETA_REGISTRY_2_1_233.STRUCTURED_OUTPUTS.header;
+export const WEB_SEARCH_BETA = BETA_REGISTRY_2_1_280.WEB_SEARCH.header;
+export const ADVISOR_TOOL_BETA = BETA_REGISTRY_2_1_280.ADVISOR_TOOL.header;
+export const FILES_API_BETA = BETA_REGISTRY_2_1_280.FILES_API.header;
+export const EXTENDED_CACHE_TTL_BETA = BETA_REGISTRY_2_1_280.EXTENDED_CACHE_TTL.header;
+export const STRUCTURED_OUTPUTS_BETA = BETA_REGISTRY_2_1_280.STRUCTURED_OUTPUTS.header;
 
 /**
  * `runtime.sessionId` is REQUIRED by the package (`requiredString`), while the
@@ -233,7 +371,7 @@ export const ADAPTER_ENV_KEYS = Object.freeze([
 
 /**
  * Protocol identity of the profile this adapter composes against
- * (`claude-code-2.1.233-sdk-0.112.1`). Used to decide whether a
+ * (`claude-code-2.1.280-sdk-0.112.1`). Used to decide whether a
  * `profileOverride` is needed at all — see `resolveProfileOverride` for the
  * user-agent convergence argument.
  *
@@ -298,11 +436,11 @@ export function buildAdapterUserAgent(version, env) {
 
 /**
  * The inherited default profile carries a FIXED `userAgent`
- * (`"claude-cli/2.1.233 (external, cli)"`) while the plugin builds one
+ * (`"claude-cli/2.1.280 (external, cli)"`) while the plugin builds one
  * dynamically from entrypoint / agent-sdk version / client-app. In the common
  * case — no `CLAUDE_CODE_ENTRYPOINT`, no `CLAUDE_AGENT_SDK_VERSION`, no
- * `CLAUDE_AGENT_SDK_CLIENT_APP`, detected CLI version `2.1.233` — both sides
- * produce the byte-identical `"claude-cli/2.1.233 (external, cli)"`, so no
+ * `CLAUDE_AGENT_SDK_CLIENT_APP`, detected CLI version `2.1.280` — both sides
+ * produce the byte-identical `"claude-cli/2.1.280 (external, cli)"`, so no
  * override is emitted and the request stays byte-identical to the profile.
  *
  * When they diverge, `userAgent` and `cliVersion` are validated TOGETHER by the
@@ -521,16 +659,35 @@ function buildAdditionalBetas(args) {
  * `EXPERIMENTAL_BETA_FLAGS` set is safe and avoids depending on which of them the
  * package happens to compose for a given model.
  *
- * @param {{isRoundRobin: boolean, disableExperimentalBetas: boolean}} args
+ * `rejectedBetas` carries the sent betas the API explicitly named as invalid
+ * for the current account (the TTL'd per-account sent-beta latch in index.mjs;
+ * see `selectLatchableRejectedBetas`). Dropping them from `customBetas` alone is
+ * not enough once the package composes the same beta itself (e.g.
+ * `cache-diagnosis-2026-04-07` under 2.1.280), so they are suppressed here.
+ * `UNSUPPRESSIBLE_BETAS` and `BODY_COUPLED_BETAS` are never taken from this
+ * input, entries outside the package grammar are skipped (they cannot be on the
+ * wire anyway), and the list is capped at `MAX_SUPPRESS_BETAS` with the policy
+ * suppressions taking precedence.
+ *
+ * @param {{isRoundRobin: boolean, disableExperimentalBetas: boolean, rejectedBetas?: readonly string[]}} args
  * @returns {readonly string[] | undefined}
  */
-function buildSuppressBetas({ isRoundRobin, disableExperimentalBetas }) {
+function buildSuppressBetas({ isRoundRobin, disableExperimentalBetas, rejectedBetas }) {
   /** @type {Set<string>} */
   const suppressed = new Set();
 
   if (isRoundRobin) suppressed.add(PROMPT_CACHING_SCOPE_BETA);
   if (disableExperimentalBetas) for (const beta of EXPERIMENTAL_BETA_FLAGS) suppressed.add(beta);
 
+  for (const rejected of rejectedBetas ?? []) {
+    if (suppressed.size >= MAX_SUPPRESS_BETAS) break;
+    if (typeof rejected !== "string") continue;
+    const beta = rejected.trim();
+    if (!beta || beta.length > BETA_IDENTIFIER_MAX_LENGTH || !BETA_IDENTIFIER_PATTERN.test(beta)) continue;
+    if (UNSUPPRESSIBLE_BETAS.has(beta.toLowerCase()) || BODY_COUPLED_BETAS.has(beta.toLowerCase())) continue;
+    suppressed.add(beta);
+  }
+
   if (suppressed.size === 0) return undefined;
   return [...suppressed];
 }
@@ -592,7 +749,8 @@ function buildMetadataOverrides(env) {
  * @property {URL | undefined} [requestUrl] Parsed outgoing URL.
  * @property {string} provider Result of `detectProvider(requestUrl)`.
  * @property {string} clientRequestId Caller-generated `randomUUID()`.
- * @property {{enabled: boolean, claudeCliVersion: string, customBetas?: readonly string[], strategy?: string, sessionId?: string}} signature
+ * @property {{enabled: boolean, claudeCliVersion: string, customBetas?: readonly string[], rejectedBetas?: readonly string[], strategy?: string, sessionId?: string}} signature
+ *   `rejectedBetas`: sent betas the API named as invalid for this account (TTL'd); routed to `suppressBetas`.
  * @property {{persistentUserId: string, accountId: string}} identity Correlation triple sources.
  * @property {{use1MContext?: unknown} | undefined} [adaptiveOverride]
  * @property {Record<string, unknown> | undefined} [tokenEconomy]
@@ -662,7 +820,11 @@ export function buildAdapterTransport(state) {
     disableExperimentalBetas,
     incomingBetas,
   });
-  const suppressBetas = buildSuppressBetas({ isRoundRobin, disableExperimentalBetas });
+  const suppressBetas = buildSuppressBetas({
+    isRoundRobin,
+    disableExperimentalBetas,
+    rejectedBetas: signature.rejectedBetas,
+  });
 
   // 1M context is ALWAYS passed explicitly. The plugin's default is
   // `hasOneMillionContext(model)` (`/(^|[-_ ])1m($|[-_ ])|context[-_]?1m/i`)

package/lib/mimicry/headers.mjs

@@ -73,7 +73,7 @@ export const TOKEN_COUNTING_BETA_FLAG = "token-counting-2024-11-01";
  *
  * These are betas the HOST SDK injects into its outgoing request that the
  * genuine Claude Code client NEVER sends. They are not stale registry entries
- * and they are not the package's business — `BETA_REGISTRY_2_1_233` has no slot
+ * and they are not the package's business — `BETA_REGISTRY_2_1_280` has no slot
  * for either, because upstream has no reason to model a header it does not
  * emit. The plugin drops them so a host's own SDK cannot leak a foreign
  * fingerprint into a request that is otherwise byte-identical to the real