opencode-anthropic-fix 0.3.0 → 0.5.0

package/index.mjs

@@ -77,7 +77,7 @@ import {
   SUBAGENT_CC_ANCHOR,
 } from "./lib/mimicry/system-prompt.mjs";
 import { buildAdapterTransport, resolveAdapterEnv } from "./lib/mimicry/adapter-input.mjs";
-import { buildWireCompatibleRequest } from "./lib/mimicry/wire-compat.mjs";
+import { buildWireCompatibleRequest, buildWireCompatibleCountTokensRequest } from "./lib/mimicry/wire-compat.mjs";
 import {
   hasOneMillionContext,
   isEligibleFor1MContext,
@@ -3010,20 +3010,29 @@ export async function AnthropicAuthPlugin({ client }) {
                 //  1. signature emulation on — with it off the plugin emits only
                 //     3 headers and a minimal beta set, while the package always
                 //     emits the full Claude Code set;
-                //  2. the /v1/messages endpoint — the package pins
-                //     `https://api.anthropic.com/v1/messages?beta=true`, so a
-                //     /v1/messages/count_tokens turn sent through it would be
-                //     silently rewritten to the wrong endpoint.
+                //  2. a messages endpoint the package has a surface for. Both
+                //     qualify now: `buildClaudeCodeRequest` for /v1/messages and
+                //     `buildClaudeCodeCountTokensRequest` for
+                //     /v1/messages/count_tokens, each pinning its OWN endpoint.
+                //     The endpoint pin is inert either way — `built.url` is never
+                //     adopted (see the consumption comment below), so the URL on
+                //     the wire stays the one transformRequestUrl produced and a
+                //     custom ANTHROPIC_BASE_URL survives.
                 //
                 // The former first-party check is now structural: the plugin only
                 // speaks to first-party Anthropic, so it is always satisfied.
-                //  3. a JSON body is actually present — the package requires
-                //     `model` and `max_tokens`, so a bodiless request must keep
-                //     using the legacy path rather than throwing INVALID_INPUT.
+                //  3. a JSON body is actually present. The main-turn surface
+                //     requires `model` and `max_tokens`; the count surface
+                //     requires `model` and `messages` and accepts no
+                //     `max_tokens` at all. Either way a bodiless request must
+                //     keep using the legacy path rather than throwing
+                //     INVALID_INPUT.
                 const _adapterPathname = requestUrl?.pathname;
+                const _isCountTokens =
+                  _adapterPathname === "/v1/messages/count_tokens" || _adapterPathname === "/messages/count_tokens";
                 const _useAdapter =
                   getSignatureEmulationEnabled() &&
-                  (_adapterPathname === "/v1/messages" || _adapterPathname === "/messages") &&
+                  (_adapterPathname === "/v1/messages" || _adapterPathname === "/messages" || _isCountTokens) &&
                   typeof requestInit.body === "string" &&
                   requestInit.body.length > 0;
 
@@ -3106,12 +3115,17 @@ export async function AnthropicAuthPlugin({ client }) {
                 //
                 // Adapter path: the shared package composes the headers AND
                 // rebuilds the body (canonical system prefix, metadata, beta
-                // header). Legacy path: unchanged, byte for byte.
+                // header). On the count-tokens surface it composes headers and a
+                // body that deliberately carries NO system, metadata or
+                // max_tokens. Legacy path: unchanged, byte for byte.
                 //
                 // The URL deliberately stays whatever transformRequestUrl already
-                // produced. `built.url` is the package's pinned
-                // `https://api.anthropic.com/v1/messages?beta=true`, which would
-                // override a custom ANTHROPIC_BASE_URL or proxy endpoint.
+                // produced. `built.url` is the package's pinned endpoint
+                // (`https://api.anthropic.com/v1/messages?beta=true`, or
+                // `.../v1/messages/count_tokens?beta=true` on the count surface),
+                // which would override a custom ANTHROPIC_BASE_URL or proxy
+                // endpoint. transformRequestUrl already appends `?beta=true` to
+                // both endpoints itself, so discarding `built.url` costs nothing.
                 const _adapterSignature = {
                   enabled: getSignatureEmulationEnabled(),
                   claudeCliVersion,
@@ -3159,7 +3173,12 @@ export async function AnthropicAuthPlugin({ client }) {
                     nodeVersion: process.version,
                   });
                   if (_adapterResult.applicable) {
-                    const built = await buildWireCompatibleRequest(body, _adapterResult.transport);
+                    // Two package surfaces, one transport: the count-tokens
+                    // builder consumes a strict subset of the same input, so the
+                    // transport object needs no count-specific mode.
+                    const built = _isCountTokens
+                      ? await buildWireCompatibleCountTokensRequest(body, _adapterResult.transport)
+                      : await buildWireCompatibleRequest(body, _adapterResult.transport);
                     requestHeaders = built.headers;
                     adapterBody = built.body;
                   } else {

package/lib/mimicry/adapter-input.mjs

@@ -131,12 +131,26 @@ export const ADAPTER_ENV_KEYS = Object.freeze([
 ]);
 
 /**
- * Protocol identity of the pinned profile (`claude-code-2.1.195`). Used to
- * decide whether a `profileOverride` is needed at all — see
- * `resolveProfileOverride` for the user-agent convergence argument.
+ * Protocol identity of the profile this adapter composes against
+ * (`claude-code-2.1.233-sdk-0.112.1`). Used to decide whether a
+ * `profileOverride` is needed at all — see `resolveProfileOverride` for the
+ * user-agent convergence argument.
+ *
+ * PROFILE INHERITANCE POLICY. The adapter never passes an explicit `profile`
+ * argument to the package's entry points; omitting it IS the mechanism by which
+ * the plugin inherits whatever `DEFAULT_PROFILE` the installed
+ * `@tormentalabs/claude-code-wire-compat` declares. The dependency is tracked at
+ * the `latest` dist-tag, so each package release can advance the default profile
+ * and the plugin follows without a code change to the composition path.
+ *
+ * These two constants are the ONLY thing that has to move in lockstep: they
+ * mirror the default profile's `cliVersion` / `userAgent` so that
+ * `resolveProfileOverride` stays silent in the common case. Keep them in sync
+ * with `FALLBACK_CLAUDE_CLI_VERSION` (lib/request-headers.mjs) on every package
+ * bump that changes the default profile.
  */
-export const PROFILE_CLI_VERSION = "2.1.195";
-export const PROFILE_USER_AGENT = "claude-cli/2.1.195 (external, cli)";
+export const PROFILE_CLI_VERSION = "2.1.233";
+export const PROFILE_USER_AGENT = "claude-cli/2.1.233 (external, cli)";
 
 // ---------------------------------------------------------------------------
 // Environment snapshot
@@ -179,12 +193,12 @@ export function buildAdapterUserAgent(version, env) {
 }
 
 /**
- * The pinned profile carries a FIXED `userAgent`
- * (`"claude-cli/2.1.195 (external, cli)"`) while the plugin builds one
+ * The inherited default profile carries a FIXED `userAgent`
+ * (`"claude-cli/2.1.233 (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.195` — both sides
- * produce the byte-identical `"claude-cli/2.1.195 (external, cli)"`, so 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
  * override is emitted and the request stays byte-identical to the profile.
  *
  * When they diverge, `userAgent` and `cliVersion` are validated TOGETHER by the

package/lib/mimicry/wire-compat.mjs

@@ -4,7 +4,7 @@
  * NOT promised because the returned HeaderPair array is converted to Headers.
  */
 
-import { buildClaudeCodeRequest } from "@tormentalabs/claude-code-wire-compat";
+import { buildClaudeCodeRequest, buildClaudeCodeCountTokensRequest } from "@tormentalabs/claude-code-wire-compat";
 import { stripStainlessHelperMarkers } from "./headers.mjs";
 
 const PROFILE_OVERRIDE_ENV = "OPENCODE_ANTHROPIC_PROFILE_OVERRIDE";
@@ -288,18 +288,208 @@ export async function buildWireCompatibleRequest(body, transport) {
   try {
     built = await buildClaudeCodeRequest(toClaudeCodeRequestInput(parsed, transport));
   } catch (error) {
-    // The package deliberately sanitizes its errors down to a bare code, and
-    // carries the useful part in `safeDetails`, which nothing surfaces. Fold it
-    // into the message so a rejection is diagnosable from a stack trace alone.
-    // The error object itself is preserved, so `code`, `safeDetails` and
-    // `instanceof` all still hold for callers that inspect them.
-    if (error instanceof Error && "safeDetails" in error) {
-      const detail = Object.entries(error.safeDetails ?? {})
-        .map(([key, value]) => `${key}=${value}`)
-        .join(" ");
-      if (detail) error.message = `${error.message} (${detail})`;
-    }
-    throw error;
+    throw foldSafeDetailsIntoMessage(error);
   }
   return { ...built, headers: new Headers(built.headers) };
 }
+
+/**
+ * The subset of `ClaudeCodeRequestInput` keys that `ClaudeCodeCountTokensInput`
+ * picks. Kept as data so the pick below stays a single source of truth.
+ */
+const COUNT_TOKENS_INPUT_FIELDS = new Set([
+  "accessToken",
+  "model",
+  "messages",
+  "tools",
+  "runtime",
+  "clientRequestId",
+  "profileOverride",
+  "crypto",
+  "app",
+  "stainlessRetryCount",
+  "stainlessHelper",
+  "claudeRemoteContainerId",
+  "claudeRemoteSessionId",
+  "clientApp",
+  "anthropicAdditionalProtection",
+  "extraHeaders",
+]);
+
+/**
+ * The header names the package composes itself, mirrored from `HEADER_NAMES`
+ * (src/headers.ts). Exported so `wire-compat.test.mjs` can pin the mirror
+ * against the package's real behaviour rather than trusting this copy.
+ */
+export const PACKAGE_CANONICAL_HEADER_NAMES = new Set([
+  "anthropic-beta",
+  "anthropic-dangerous-direct-browser-access",
+  "anthropic-version",
+  "authorization",
+  "content-type",
+  "user-agent",
+  "x-app",
+  "x-claude-code-session-id",
+  "x-client-request-id",
+  "x-stainless-arch",
+  "x-stainless-lang",
+  "x-stainless-os",
+  "x-stainless-package-version",
+  "x-stainless-retry-count",
+  "x-stainless-runtime",
+  "x-stainless-runtime-version",
+  "x-stainless-timeout",
+  "x-stainless-helper",
+  "x-claude-remote-container-id",
+  "x-claude-remote-session-id",
+  "x-client-app",
+  "x-anthropic-additional-protection",
+]);
+
+/** Mirror of the package's `FORBIDDEN_HEADER_NAMES` (src/headers.ts). */
+export const PACKAGE_FORBIDDEN_HEADER_NAMES = new Set([
+  "x-api-key",
+  "cookie",
+  "set-cookie",
+  "forwarded",
+  "content-length",
+  "host",
+  "connection",
+  "transfer-encoding",
+  "te",
+  "upgrade",
+  "keep-alive",
+]);
+
+/** Mirror of the package's `isForbiddenHeader` prefix rules. */
+export const PACKAGE_FORBIDDEN_HEADER_PREFIXES = Object.freeze(["proxy-", "x-forwarded-"]);
+
+/**
+ * Apply the package's `dropConflicting` extra-header policy PLUGIN-SIDE.
+ *
+ * WHY THIS EXISTS. `extraHeaderPolicy` is not one of the sixteen keys
+ * `ClaudeCodeCountTokensInput` picks, and `validateCountTokensInput` runs
+ * `assertExactKeys`, so passing it is `INVALID_INPUT` rather than a no-op. The
+ * count surface therefore always resolves extra headers under `strict`, where
+ * the FIRST host header the package owns raises `DUPLICATE_HEADER` (canonical
+ * name) or `FORBIDDEN_HEADER` (hop-by-hop / credential name) and nothing
+ * reaches the wire. The plugin forwards a heterogeneous host header map — the
+ * opencode SDK alone sends `content-type` and `accept` — so without this filter
+ * every count turn would throw and fall back to nothing at all.
+ *
+ * The main turn gets the same outcome for free through
+ * `extraHeaderPolicy: "dropConflicting"` on the transport, which the count pick
+ * discards; this reproduces it. Only OWNERSHIP conflicts are dropped, exactly
+ * as the package does: header syntax is still validated package-side and a
+ * caller duplicating one of its OWN extra headers still raises
+ * `DUPLICATE_HEADER`, because that is a caller bug and not ours to paper over.
+ *
+ * @param {readonly (readonly [string, string])[] | undefined} extraHeaders
+ * @returns {readonly (readonly [string, string])[] | undefined}
+ */
+function dropConflictingExtraHeaders(extraHeaders) {
+  if (extraHeaders === undefined) return undefined;
+  const kept = extraHeaders.filter(([name]) => {
+    const normalized = String(name).toLowerCase();
+    if (PACKAGE_CANONICAL_HEADER_NAMES.has(normalized)) return false;
+    if (PACKAGE_FORBIDDEN_HEADER_NAMES.has(normalized)) return false;
+    return !PACKAGE_FORBIDDEN_HEADER_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+  });
+  return kept.length > 0 ? kept : undefined;
+}
+
+/**
+ * Map the host body to the shared package's count-tokens input.
+ *
+ * WHY THIS DELEGATES TO THE FULL MAPPER AND PICKS. The package declares
+ * `ClaudeCodeCountTokensInput = Pick<ClaudeCodeRequestInput, ...>` — literally
+ * the same field names carrying the same types — so every value the full mapper
+ * produces for a retained key is already built under the exact contract the
+ * count-tokens surface expects. Picking is therefore safe by construction, and
+ * it keeps the host tolerances that DO apply in one place instead of forking
+ * them: the dotted->dashed model rewrite, `tools` raising on a malformed value
+ * instead of silently dropping it, the stainless marker/transport passthrough,
+ * and the profile-override resolution all carry over unchanged.
+ *
+ * The tolerances that do NOT apply are dropped by the pick rather than reaching
+ * the package: upstream derives the count-tokens beta set from the model alone
+ * and the count body carries no `system`, `metadata` or `max_tokens`. `system`
+ * is stripped BEFORE delegating, because `normalizeSystem` throws on a
+ * malformed value and a field that is contractually absent from the count body
+ * must not be able to fail the build.
+ *
+ * @param {Record<string, import('@tormentalabs/claude-code-wire-compat').JsonValue>} body
+ * @param {{
+ *   accessToken: string,
+ *   clientRequestId: string,
+ *   runtime: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeRuntimeIdentity,
+ *   app?: 'cli' | 'cli-bg',
+ *   stainlessRetryCount?: number,
+ *   stainlessHelper?: string,
+ *   claudeRemoteContainerId?: string,
+ *   claudeRemoteSessionId?: string,
+ *   clientApp?: string,
+ *   anthropicAdditionalProtection?: string,
+ *   extraHeaders?: readonly import('@tormentalabs/claude-code-wire-compat').HeaderPair[],
+ *   crypto?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeRequestInput['crypto'],
+ *   profileOverride?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeProfileOverride,
+ * }} transport
+ * @returns {import('@tormentalabs/claude-code-wire-compat').ClaudeCodeCountTokensInput}
+ */
+export function toClaudeCodeCountTokensInput(body, transport) {
+  const { system: _system, ...bodyWithoutSystem } = body;
+  const full = toClaudeCodeRequestInput(bodyWithoutSystem, transport);
+  const input = Object.fromEntries(Object.entries(full).filter(([name]) => COUNT_TOKENS_INPUT_FIELDS.has(name)));
+  const extraHeaders = dropConflictingExtraHeaders(input.extraHeaders);
+  if (extraHeaders === undefined) delete input.extraHeaders;
+  else input.extraHeaders = extraHeaders;
+  if (transport.crypto !== undefined) input.crypto = transport.crypto;
+  return input;
+}
+
+/**
+ * Build a Claude Code `/v1/messages/count_tokens` request from the JSON body
+ * received from the host. Mirrors `buildWireCompatibleRequest`, including the
+ * deliberate absence of an explicit `profile` argument so the count turn
+ * inherits the package's `DEFAULT_PROFILE` exactly like the main turn does.
+ *
+ * @param {string | undefined} body
+ * @param {Parameters<typeof toClaudeCodeCountTokensInput>[1]} transport
+ * @returns {Promise<Omit<import('@tormentalabs/claude-code-wire-compat').BuiltClaudeCodeCountTokensRequest, 'headers'> & {headers: Headers}>}
+ */
+export async function buildWireCompatibleCountTokensRequest(body, transport) {
+  if (!body || typeof body !== "string") throw new TypeError("Expected a JSON request body");
+  const parsed = JSON.parse(body);
+  // Same rationale as the main turn: `buildAdapterTransport` already derived
+  // `transport.stainlessHelper` from these markers, the API has never known the
+  // keys, and the package rejects them with INVALID_INPUT. `parsed` is a local
+  // object owned by this call, so the strip is in place.
+  stripStainlessHelperMarkers(parsed?.tools, parsed?.messages);
+  let built;
+  try {
+    built = await buildClaudeCodeCountTokensRequest(toClaudeCodeCountTokensInput(parsed, transport));
+  } catch (error) {
+    throw foldSafeDetailsIntoMessage(error);
+  }
+  return { ...built, headers: new Headers(built.headers) };
+}
+
+/**
+ * The package deliberately sanitizes its errors down to a bare code, and carries
+ * the useful part in `safeDetails`, which nothing surfaces. Fold it into the
+ * message so a rejection is diagnosable from a stack trace alone. The error
+ * object itself is preserved, so `code`, `safeDetails` and `instanceof` all
+ * still hold for callers that inspect them.
+ *
+ * @param {unknown} error
+ * @returns {unknown}
+ */
+function foldSafeDetailsIntoMessage(error) {
+  if (error instanceof Error && "safeDetails" in error) {
+    const detail = Object.entries(error.safeDetails ?? {})
+      .map(([key, value]) => `${key}=${value}`)
+      .join(" ");
+    if (detail) error.message = `${error.message} (${detail})`;
+  }
+  return error;
+}

package/lib/request-headers.mjs

@@ -16,7 +16,10 @@
 // Version / build / SDK constants
 // ---------------------------------------------------------------------------
 
-export const FALLBACK_CLAUDE_CLI_VERSION = "2.1.195";
+// Tracks the CLI version of the wire-compat package's DEFAULT_PROFILE (see
+// lib/mimicry/adapter-input.mjs PROFILE_CLI_VERSION). Bump both together when
+// the package ships a newer default profile.
+export const FALLBACK_CLAUDE_CLI_VERSION = "2.1.233";
 export const CLAUDE_CODE_NPM_LATEST_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
 // Real build markers extracted from the 2.1.195 native binary
 // (Bun-embedded JS): `BUILD_TIME:"2026-06-26T01:00:56Z"`,
@@ -38,6 +41,11 @@ export const ANTHROPIC_SDK_VERSION = "0.94.0";
 
 // Map of CLI version to bundled SDK version (update when CLI version changes)
 export const CLI_TO_SDK_VERSION = new Map([
+  // 2.1.233: the wire-compat package's DEFAULT_PROFILE
+  // (`claude-code-2.1.233-sdk-0.112.1`) declares sdkVersion 0.112.1, so the
+  // legacy header path stays consistent with the adapter path when the tracked
+  // CLI version is the profile baseline.
+  ["2.1.233", "0.112.1"],
   // 2.1.160-2.1.195: refusal-fallback feature (server-side-fallback /
   // fallback-credit betas) is opt-in/GrowthBook-gated and never emitted on a
   // default /v1/messages turn; no wire SDK bump (binary-verified:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "license": "GPL-3.0-or-later",
   "repository": {
     "type": "git",
@@ -55,6 +55,6 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@tormentalabs/claude-code-wire-compat": "0.1.0"
+    "@tormentalabs/claude-code-wire-compat": "latest"
   }
 }