opencode-anthropic-fix 0.4.0 → 0.6.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/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,138 @@ 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",
+  "extraHeaderPolicy",
+]);
+
+/**
+ * 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.
+ *
+ * EXTRA HEADERS. The count surface takes `extraHeaderPolicy` since wire-compat
+ * 0.4.0, so the policy is set here exactly as the main turn sets it on the
+ * transport (`buildAdapterTransport`). Under the package default (`strict`) 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 — and the plugin forwards a heterogeneous host header map, the opencode
+ * SDK alone sending `content-type` and `accept`. `dropConflicting` drops only
+ * OWNERSHIP conflicts: 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.
+ * The names the package drops are reported back as
+ * `evidence.droppedExtraHeaderNames`.
+ *
+ * @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)));
+  input.extraHeaderPolicy = "dropConflicting";
+  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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "license": "GPL-3.0-or-later",
   "repository": {
     "type": "git",