opencode-anthropic-fix 0.2.0 → 0.3.0-beta.0

package/lib/mimicry/wire-compat.mjs

@@ -0,0 +1,305 @@
+/**
+ * Adapter from the plugin's host request shape to the shared wire constructor.
+ * The logical canonical header order is tested, but order on the fetch wire is
+ * NOT promised because the returned HeaderPair array is converted to Headers.
+ */
+
+import { buildClaudeCodeRequest } from "@tormentalabs/claude-code-wire-compat";
+import { stripStainlessHelperMarkers } from "./headers.mjs";
+
+const PROFILE_OVERRIDE_ENV = "OPENCODE_ANTHROPIC_PROFILE_OVERRIDE";
+
+const BODY_FIELD_NAMES = new Set([
+  "model",
+  "max_tokens",
+  "messages",
+  "system",
+  "tools",
+  "thinking",
+  "effort",
+  "metadata",
+  "context_management",
+  "output_config",
+  "speed",
+  "service_tier",
+  "output_format",
+  "tool_choice",
+  "top_p",
+  "top_k",
+  "stop_sequences",
+  "stream",
+  "temperature",
+]);
+
+/**
+ * @param {Record<string, import('@tormentalabs/claude-code-wire-compat').JsonValue>} body
+ * @returns {Record<string, import('@tormentalabs/claude-code-wire-compat').JsonValue> | undefined}
+ */
+function collectExperimentalBodyFields(body) {
+  const fields = Object.fromEntries(Object.entries(body).filter(([name]) => !BODY_FIELD_NAMES.has(name)));
+  return Object.keys(fields).length > 0 ? fields : undefined;
+}
+
+/**
+ * The shared contract accepts `system` as an array of strings or text blocks.
+ * A host may send a bare string instead, which must be wrapped rather than
+ * dropped: silently discarding it would lose caller intent with no error.
+ *
+ * @param {import('@tormentalabs/claude-code-wire-compat').JsonValue | undefined} system
+ * @returns {readonly import('@tormentalabs/claude-code-wire-compat').SystemInput[] | undefined}
+ */
+function normalizeSystem(system) {
+  if (system === undefined) return undefined;
+  if (typeof system === "string") return [system];
+  if (Array.isArray(system)) return system;
+  throw new TypeError("Expected request system to be a string or an array");
+}
+
+/**
+ * Rewrite DOTTED model version separators to DASHED ones before the id reaches
+ * the shared package.
+ *
+ * WHY THIS EXISTS. The package classifies models by dashed id ONLY:
+ * `normalizeModelId` (dist/model-identity.js) tests `includes("claude-opus-4-7")`
+ * and never the dotted spelling, because the genuine Claude Code client emits
+ * dashed ids. The plugin, by contrast, deliberately TOLERATES dotted ids
+ * throughout — `lib/mimicry/models.mjs` matches with the `[._-]` character class
+ * — so a host can legitimately hand us `claude-opus-4.7`.
+ *
+ * Passing a dotted id straight through MISCLASSIFIES it. For
+ * `claude-opus-4.7` no `includes` branch matches, so the fallback
+ * `/claude-opus-4(?!-\d(?!\d))/` matches (the character after `claude-opus-4`
+ * is `.`, not `-`) and the model resolves to `claude-opus-4-0`. That silently
+ * drops `adaptiveThinking`, `supportsEffort`, `supportsMaxEffort` and
+ * `supportsXhighEffort`, and wrongly turns `supportsTemperature` ON.
+ *
+ * The tolerance belongs to the plugin, so it is spent here and the package
+ * receives the dashed id it is built for. The rewrite is deliberately narrow:
+ * a dot is only replaced when it FOLLOWS a letter or digit and PRECEDES a
+ * digit, i.e. when it is a version separator (`claude-opus-4.7`,
+ * `claude-3.5-sonnet`). A dot before a letter is left alone, so vendor
+ * prefixes such as `anthropic.claude-opus-4-6` in a Bedrock ARN survive
+ * untouched.
+ *
+ * NOTE: `wireId = stripModelMarkers(model)` derives from this same string, so
+ * the `model` sent on the wire also becomes dashed. That is intended — the
+ * real API only accepts the dashed spelling — and is pinned by a test.
+ *
+ * @param {import('@tormentalabs/claude-code-wire-compat').JsonValue | undefined} model
+ * @returns {import('@tormentalabs/claude-code-wire-compat').JsonValue | undefined}
+ */
+function normalizeModelVersionSeparators(model) {
+  if (typeof model !== "string") return model;
+  return model.replace(/([A-Za-z0-9])\.(?=\d)/g, "$1-");
+}
+
+/**
+ * Reject a malformed `tools` value instead of dropping it, so a host mistake
+ * surfaces as an error rather than as a silently toolless request.
+ *
+ * @param {import('@tormentalabs/claude-code-wire-compat').JsonValue | undefined} tools
+ * @returns {readonly import('@tormentalabs/claude-code-wire-compat').ToolDefinition[] | undefined}
+ */
+function normalizeTools(tools) {
+  if (tools === undefined) return undefined;
+  if (Array.isArray(tools)) return tools;
+  throw new TypeError("Expected request tools to be an array");
+}
+
+/**
+ * Resolve the emergency protocol-profile override. Explicit plugin
+ * configuration wins over the environment; an absent override leaves the
+ * shared package's pinned profile untouched. JSON and package validation
+ * errors intentionally propagate so an emergency override cannot fail open.
+ *
+ * @param {import('@tormentalabs/claude-code-wire-compat').ClaudeCodeProfileOverride | undefined} configuredOverride
+ * @returns {import('@tormentalabs/claude-code-wire-compat').ClaudeCodeProfileOverride | undefined}
+ */
+function resolveProfileOverride(configuredOverride) {
+  if (configuredOverride !== undefined) return configuredOverride;
+
+  const serializedOverride = process.env[PROFILE_OVERRIDE_ENV];
+  if (serializedOverride === undefined || serializedOverride === "") return undefined;
+
+  const parsed = JSON.parse(serializedOverride);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new TypeError(`${PROFILE_OVERRIDE_ENV} must contain a JSON object`);
+  }
+  return parsed;
+}
+
+/**
+ * @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[],
+ *   extraHeaderPolicy?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeExtraHeaderPolicy,
+ *   additionalBetas?: readonly string[],
+ *   suppressBetas?: readonly string[],
+ *   suppressBillingBlock?: boolean,
+ *   suppressIdentityBlock?: boolean,
+ *   betaOverrides?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeBetaOverrides,
+ *   metadataOverrides?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeMetadataOverrides,
+ *   cacheControl?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeCacheControlInput,
+ *   capabilities?: Partial<import('@tormentalabs/claude-code-wire-compat').ClaudeCodeCapabilities>,
+ *   profileOverride?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeProfileOverride,
+ * }} transport
+ * @returns {import('@tormentalabs/claude-code-wire-compat').ClaudeCodeRequestInput}
+ */
+export function toClaudeCodeRequestInput(body, transport) {
+  const system = normalizeSystem(body.system);
+  const profileOverride = resolveProfileOverride(transport.profileOverride);
+  const thinking =
+    body.thinking === undefined
+      ? undefined
+      : {
+          type: body.thinking.type,
+          ...(body.thinking.budget_tokens === undefined ? {} : { budgetTokens: body.thinking.budget_tokens }),
+          ...(body.thinking.display === undefined ? {} : { display: body.thinking.display }),
+        };
+  const outputConfig =
+    body.output_config === undefined
+      ? undefined
+      : Object.fromEntries(
+          Object.entries(body.output_config).map(([name, value]) => [
+            name === "max_output_tokens" ? "maxOutputTokens" : name,
+            value,
+          ]),
+        );
+  const input = {
+    accessToken: transport.accessToken,
+    model: normalizeModelVersionSeparators(body.model),
+    maxTokens: body.max_tokens,
+    messages: body.messages,
+    runtime: transport.runtime,
+    clientRequestId: transport.clientRequestId,
+    system,
+    tools: normalizeTools(body.tools),
+    thinking,
+    cacheControl: transport.cacheControl,
+    // WHY: the package derives model capabilities from the normalized model id
+    // alone. This seam is the only way a consumer can DOWNGRADE one of them
+    // (`build-request.js` rejects an UPGRADE with `UNSUPPORTED_CAPABILITY`, but
+    // allows `true -> false`). The plugin needs it so
+    // `OPENCODE_ANTHROPIC_DISABLE_ADAPTIVE_THINKING` can turn `adaptiveThinking`
+    // off and push `resolveThinking` down its `else` branch, emitting
+    // `{budget_tokens, type: "enabled"}` instead of `{type: "adaptive"}`.
+    // Omitted entirely when the transport does not set it, so a consumer that
+    // downgrades nothing stays byte-identical to the genuine client.
+    capabilities: transport.capabilities,
+    effort: body.effort,
+    metadata: body.metadata,
+    experimentalBodyFields: collectExperimentalBodyFields(body),
+    contextManagement: body.context_management,
+    outputConfig,
+    speed: body.speed,
+    serviceTier: body.service_tier,
+    outputFormat: body.output_format,
+    toolChoice: body.tool_choice,
+    topP: body.top_p,
+    topK: body.top_k,
+    stopSequences: body.stop_sequences,
+    stream: body.stream,
+    temperature: body.temperature,
+    app: transport.app,
+    stainlessRetryCount: transport.stainlessRetryCount,
+    stainlessHelper: transport.stainlessHelper,
+    claudeRemoteContainerId: transport.claudeRemoteContainerId,
+    claudeRemoteSessionId: transport.claudeRemoteSessionId,
+    clientApp: transport.clientApp,
+    anthropicAdditionalProtection: transport.anthropicAdditionalProtection,
+    extraHeaders: transport.extraHeaders,
+    extraHeaderPolicy: transport.extraHeaderPolicy,
+    additionalBetas: transport.additionalBetas,
+    suppressBetas: transport.suppressBetas,
+    suppressBillingBlock: transport.suppressBillingBlock,
+    // Sibling of `suppressBillingBlock` at the ROOT of the package input — NOT
+    // `cacheControl.suppressIdentityBlock`, which only drops the block's
+    // `cache_control` marker and keeps the block itself. This one omits the
+    // whole identity block, which is what the lean-system-prompt feature needs
+    // now that the adapter path delegates canonical block composition to the
+    // package (`suppressCanonicalBlocks` in request-body.mjs).
+    suppressIdentityBlock: transport.suppressIdentityBlock,
+    // UNCONDITIONAL on purpose. `lib/mimicry/request-body.mjs` never touches
+    // `cache_control` on `thinking`/`redacted_thinking` blocks because ANY
+    // mutation of those blocks — including deleting the key — makes the real
+    // API answer 400 "thinking or redacted_thinking blocks in the latest
+    // assistant message cannot be modified". The plugin therefore ALWAYS needs
+    // the package to accept and pass the key through verbatim; the need is a
+    // property of the API round-trip contract, not of a given request. Gating
+    // it on "does some block actually carry the key" would add a scan and a
+    // second state to get wrong for zero behavioural gain: with the flag on and
+    // no such key present, the package output is byte-identical.
+    preserveThinkingBlockCacheControl: true,
+    betaOverrides: transport.betaOverrides,
+    metadataOverrides: transport.metadataOverrides,
+    ...(profileOverride === undefined ? {} : { profileOverride }),
+  };
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}
+
+/**
+ * Build a Claude Code request from the JSON body received from the host.
+ *
+ * @param {string | undefined} 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[],
+ *   extraHeaderPolicy?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeExtraHeaderPolicy,
+ *   additionalBetas?: readonly string[],
+ *   suppressBetas?: readonly string[],
+ *   suppressBillingBlock?: boolean,
+ *   suppressIdentityBlock?: boolean,
+ *   betaOverrides?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeBetaOverrides,
+ *   metadataOverrides?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeMetadataOverrides,
+ *   cacheControl?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeCacheControlInput,
+ *   capabilities?: Partial<import('@tormentalabs/claude-code-wire-compat').ClaudeCodeCapabilities>,
+ *   profileOverride?: import('@tormentalabs/claude-code-wire-compat').ClaudeCodeProfileOverride,
+ * }} transport
+ * @returns {Promise<Omit<import('@tormentalabs/claude-code-wire-compat').BuiltClaudeCodeRequest, 'headers'> & {headers: Headers}>}
+ */
+export async function buildWireCompatibleRequest(body, transport) {
+  if (!body || typeof body !== "string") throw new TypeError("Expected a JSON request body");
+  const parsed = JSON.parse(body);
+  // The stainless helper markers are an internal signal: buildAdapterTransport
+  // already derived `transport.stainlessHelper` from them, and the API has never
+  // known those keys — 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 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;
+  }
+  return { ...built, headers: new Headers(built.headers) };
+}

package/lib/rotation.mjs

@@ -259,6 +259,22 @@ export function selectAccount(candidates, strategy, currentIndex, healthTracker,
       return next ? { index: next.index, cursor: cursor + 1 } : null;
     }
 
+    case "single": {
+      // Single-account mode: use exactly one account and never auto-rotate.
+      // Stay on the current account while it is available; if it is
+      // rate-limited or otherwise unavailable, STOP (return null) so the
+      // caller alerts the user instead of silently switching accounts.
+      // Auto-resumes once the account becomes available again (e.g. the
+      // rate-limit window expires). See issue #20.
+      if (currentIndex !== null) {
+        const current = available.find((acc) => acc.index === currentIndex);
+        return current ? { index: current.index, cursor } : null;
+      }
+      // No account selected yet — pick the first available as the single account.
+      const next = available[cursor % available.length];
+      return next ? { index: next.index, cursor: cursor + 1 } : null;
+    }
+
     case "hybrid": {
       const scoredCandidates = available
         .filter((acc) => healthTracker.isUsable(acc.index) && tokenTracker.hasTokens(acc.index))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.2.0",
+  "version": "0.3.0-beta.0",
   "license": "GPL-3.0-or-later",
   "repository": {
     "type": "git",
@@ -15,6 +15,7 @@
     "index.mjs",
     "cli.mjs",
     "lib/**/*.mjs",
+    "!lib/**/*.test.mjs",
     "README.md",
     "LICENSE"
   ],
@@ -54,7 +55,6 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@openauthjs/openauth": "^0.4.3",
-    "xxhash-wasm": "^1.1.0"
+    "@tormentalabs/claude-code-wire-compat": "0.1.0"
   }
 }

package/lib/account-state.test.mjs

@@ -1,109 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { applyOAuthCredentials, resetAccountTracking, adjustActiveIndexAfterRemoval } from "./account-state.mjs";
-
-describe("resetAccountTracking", () => {
-  it("resets rate-limit and failure fields", () => {
-    const account = {
-      rateLimitResetTimes: { anthropic: Date.now() + 60_000 },
-      consecutiveFailures: 7,
-      lastFailureTime: Date.now(),
-    };
-
-    resetAccountTracking(account);
-
-    expect(account.rateLimitResetTimes).toEqual({});
-    expect(account.consecutiveFailures).toBe(0);
-    expect(account.lastFailureTime).toBeNull();
-  });
-});
-
-describe("applyOAuthCredentials", () => {
-  it("applies refresh/access/expiry and optional email", () => {
-    const account = {
-      refreshToken: "old-refresh",
-      access: "old-access",
-      expires: 1,
-      email: "old@example.com",
-    };
-
-    applyOAuthCredentials(account, {
-      refresh: "new-refresh",
-      access: "new-access",
-      expires: 123,
-      email: "new@example.com",
-    });
-
-    expect(account).toEqual({
-      refreshToken: "new-refresh",
-      access: "new-access",
-      expires: 123,
-      token_updated_at: expect.any(Number),
-      email: "new@example.com",
-    });
-  });
-
-  it("preserves existing email when credentials omit email", () => {
-    const account = {
-      refreshToken: "old-refresh",
-      access: "old-access",
-      expires: 1,
-      email: "old@example.com",
-    };
-
-    applyOAuthCredentials(account, {
-      refresh: "new-refresh",
-      access: "new-access",
-      expires: 456,
-    });
-
-    expect(account.email).toBe("old@example.com");
-    expect(account.refreshToken).toBe("new-refresh");
-    expect(account.access).toBe("new-access");
-    expect(account.expires).toBe(456);
-    expect(account.token_updated_at).toEqual(expect.any(Number));
-  });
-});
-
-describe("adjustActiveIndexAfterRemoval", () => {
-  it("resets activeIndex to 0 when no accounts remain", () => {
-    const storage = { accounts: [], activeIndex: 3 };
-    adjustActiveIndexAfterRemoval(storage, 0);
-    expect(storage.activeIndex).toBe(0);
-  });
-
-  it("clamps activeIndex when it falls out of range", () => {
-    const storage = {
-      accounts: [{ id: "a" }, { id: "b" }],
-      activeIndex: 2,
-    };
-    adjustActiveIndexAfterRemoval(storage, 0);
-    expect(storage.activeIndex).toBe(1);
-  });
-
-  it("decrements activeIndex when removed index is before active", () => {
-    const storage = {
-      accounts: [{ id: "a" }, { id: "b" }, { id: "c" }],
-      activeIndex: 2,
-    };
-    adjustActiveIndexAfterRemoval(storage, 0);
-    expect(storage.activeIndex).toBe(1);
-  });
-
-  it("keeps activeIndex when removed index is after active", () => {
-    const storage = {
-      accounts: [{ id: "a" }, { id: "b" }, { id: "c" }],
-      activeIndex: 0,
-    };
-    adjustActiveIndexAfterRemoval(storage, 2);
-    expect(storage.activeIndex).toBe(0);
-  });
-
-  it("keeps activeIndex when removed index was the active slot", () => {
-    const storage = {
-      accounts: [{ id: "a" }, { id: "b" }, { id: "c" }],
-      activeIndex: 1,
-    };
-    adjustActiveIndexAfterRemoval(storage, 1);
-    expect(storage.activeIndex).toBe(1);
-  });
-});