@ex-machina/opencode-anthropic-auth 1.8.2 → 1.8.4

package/README.md

@@ -1,20 +1,42 @@
 # OpenCode Anthropic Auth Plugin
 
+[![OpenCode v1 — npm latest tag](https://img.shields.io/npm/v/%40ex-machina%2Fopencode-anthropic-auth/latest?label=OpenCode%20v1%20(latest))](https://www.npmjs.com/package/@ex-machina/opencode-anthropic-auth?activeTab=versions)
+[![OpenCode v2 — npm next tag](https://img.shields.io/npm/v/%40ex-machina%2Fopencode-anthropic-auth/next?label=OpenCode%20v2%20(next))](https://www.npmjs.com/package/@ex-machina/opencode-anthropic-auth?activeTab=versions)
+
 > [!WARNING]
 > This plugin comes with no guarantees. You might be banned for breaking the TOS, you might not be. I don't work at Anthropic, nor am I an attorney.
 >
 > Use your best judgment and don't try to abuse the subscriptions. Plugins like oh-my-openagent are _known_ to trigger bans. Please be careful when using Ralph loops or insanely heavy usage patterns.
 
 > [!IMPORTANT]
-> If you are seeing issues, please try to `rm -rf ~/.cache/opencode/packages/@ex-machina` and check your `opencode.json` config to make sure you're on the latest version.
+> If you are seeing issues, try `rm -rf ~/.cache/opencode/packages/@ex-machina` and confirm that your `opencode.json` uses the plugin release line for your OpenCode version.
 >
 > Try this FIRST before making an Issue. Thanks!
 
 An [OpenCode](https://github.com/anomalyco/opencode) plugin that provides Anthropic OAuth authentication, enabling Claude Pro/Max users to use their subscription directly with OpenCode.
 
+> [!NOTE]
+> This repository uses [Agent Facets](https://agentfacets.io) to manage agent capabilities. See the [quickstart](https://docs.agentfacets.io/quickstart) to install the CLI and get started.
+
+## Version support
+
+| OpenCode version | Plugin release | Support branch | npm dist-tag | Configuration key |
+|------------------|----------------|----------------|--------------|-------------------|
+| OpenCode v1 | 1.x | [`main`](https://github.com/ex-machina-co/opencode-anthropic-auth/tree/main) | `latest` | `plugin` |
+| OpenCode v2 | 2.x prereleases | [`v2/main`](https://github.com/ex-machina-co/opencode-anthropic-auth/tree/v2/main) | `next` | `plugins` |
+
+Both release lines use the same npm package. They are not cross-compatible: the v1 plugin does not load in OpenCode v2, and the v2 plugin does not load in OpenCode v1. OpenCode v2's plugin API is still beta, so review the changelog before upgrading either side.
+
 ## Usage
 
-Add the plugin to your OpenCode configuration:
+> [!TIP]
+> Pin an exact plugin version for a stable setup that changes only when you choose to upgrade. If you intentionally want automatic updates, use the moving npm tag for your OpenCode release line.
+>
+> This applies to every OpenCode plugin: an unpinned or moving-tag dependency can install new code on startup, so only track automatic updates from publishers you trust.
+
+### OpenCode v1 (`latest`)
+
+OpenCode v1 uses the singular `plugin` configuration key. A bare package spec tracks npm's `latest` tag:
 
 ```json
 {
@@ -22,47 +44,94 @@ Add the plugin to your OpenCode configuration:
 }
 ```
 
-> [!TIP]
-> It is STRONGLY advised that you pin the plugin to a version. This will keep you from getting automatic updates; however, this will protect you from nefarious updates.
->
-> This holds true for ANY OpenCode plugin. If you do not pin them, OpenCode will automatically update them on startup. It's a massive vulnerability waiting to happen.
+You can also write the moving tag explicitly as `@ex-machina/opencode-anthropic-auth@latest`.
+
+For a stable setup, look up the exact version currently published on `latest`:
+
+```bash
+npm view @ex-machina/opencode-anthropic-auth dist-tags.latest
+```
+
+Substitute the command output for `<version>`:
+
+```json
+{
+  "plugin": ["@ex-machina/opencode-anthropic-auth@<version>"]
+}
+```
+
+### OpenCode v2 (`next`)
+
+OpenCode v2 uses the plural `plugins` configuration key. Because npm's default tag points to the v1 line, specify `@next` if you want to track the newest v2 prerelease:
+
+```json
+{
+  "plugins": ["@ex-machina/opencode-anthropic-auth@next"]
+}
+```
 
-#### Example of pinned version
+For a stable setup, look up the exact version currently published on `next`:
+
+```bash
+npm view @ex-machina/opencode-anthropic-auth dist-tags.next
+```
+
+Substitute the command output for `<version>`:
 
 ```json
 {
-  "plugin": ["@ex-machina/opencode-anthropic-auth@1.8.1"]
+  "plugins": ["@ex-machina/opencode-anthropic-auth@<version>"]
 }
 ```
 
 ## Authentication Methods
 
-The plugin provides three authentication options:
+### OpenCode v1
+
+OpenCode v1 provides three authentication options:
+
+- **Claude Pro/Max** — OAuth flow via `claude.ai` for Pro/Max subscribers. Uses your existing subscription at no additional API cost.
+    - Run `/connect`, select `Anthropic (API key)` -> `Claude Pro/Max`, and complete OAuth.
+- **Create an API Key** — OAuth flow via `console.anthropic.com` that creates an API key on your behalf.
+- **Manually enter API Key** — Standard API-key entry for users who already have one.
 
-- **Claude Pro/Max** - OAuth flow via `claude.ai` for Pro/Max subscribers. Uses your existing subscription at no additional API cost.
-    - run the `/connect` command, select `Anthropic (API key)` -> `Claude Pro/Max` and do OAuth
-- **Create an API Key** - OAuth flow via `console.anthropic.com` that creates an API key on your behalf.
-- **Manually enter API Key** - Standard API key entry for users who already have one.
+### OpenCode v2
+
+OpenCode v2 provides:
+
+- **Claude Pro/Max** — OAuth flow via `claude.ai` for Pro/Max subscribers. Uses your existing subscription at no additional API cost.
+    - Run `/connect`, select `Anthropic` -> `Claude Pro/Max`, and complete OAuth.
+- **Manually enter API Key / `ANTHROPIC_API_KEY`** — Handled by OpenCode's built-in Anthropic integration, not by this plugin.
+
+> [!NOTE]
+> OpenCode v1 also offers a "Create an API Key" OAuth flow that mints and stores an API key. OpenCode v2's plugin API cannot yet complete an OAuth flow by storing a generated API key, so that option is unavailable in v2. Use manual API-key entry or `ANTHROPIC_API_KEY` in the meantime; see [issue #203](https://github.com/ex-machina-co/opencode-anthropic-auth/issues/203) for status.
 
 ## Configuration
 
-The plugin supports the following environment variables:
+The plugin reads the following environment variables:
+
+- **`ANTHROPIC_BASE_URL`** — Overrides the Anthropic API endpoint for both release lines, such as when using a proxy. Must be a valid HTTP(S) URL.
+- **`ANTHROPIC_INSECURE`** — Skips TLS certificate verification. Behavior differs by OpenCode version:
+    - **OpenCode v1** — Set to `1` or `true` to skip verification. Only effective when `ANTHROPIC_BASE_URL` is also set.
+    - **OpenCode v2** — Not supported. OpenCode v2 plugin request hooks cannot disable TLS verification. If set, the plugin logs a warning and leaves verification enabled; requests to an untrusted or self-signed `ANTHROPIC_BASE_URL` will fail.
+- **`ANTHROPIC_CLAUDE_CODE_VERSION`** — Overrides the Claude Code version reported to Anthropic for both release lines. Must be `major.minor.patch` (for example, `2.1.258`). Defaults to the bundled version; a malformed value is logged and the bundled version is used instead. A value older than the bundled version is honored but logs a warning, since reporting an older version can make newer models reject the request. Read once when the plugin loads, so restart OpenCode after changing it.
 
-| Variable                          | Description                                                                                                                                                                                 |
-|-----------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `ANTHROPIC_BASE_URL`              | Override the API endpoint URL (e.g. for proxying). Must be a valid HTTP(S) URL.                                                                                                             |
-| `ANTHROPIC_INSECURE`              | Set to `1` or `true` to skip TLS certificate verification. Only effective when `ANTHROPIC_BASE_URL` is also set.                                                                            |
+Anthropic gates model access on the reported Claude Code version server-side, returning a 400 `claude_code_version_too_old` error for models that require a newer client. `ANTHROPIC_CLAUDE_CODE_VERSION` lets you raise the reported version without waiting for a plugin release.
 
 ## How It Works
 
-For Claude Pro/Max authentication, the plugin:
+For Claude Pro/Max authentication, both release lines:
+
+1. Initiate a PKCE OAuth flow against Anthropic's authorization endpoint
+2. Exchange the authorization code for access and refresh tokens
+3. Automatically refresh expired tokens
+4. Inject the required OAuth headers and beta flags into API requests
+5. Sanitize the system prompt for compatibility (see below)
 
-1. Initiates a PKCE OAuth flow against Anthropic's authorization endpoint
-2. Exchanges the authorization code for access and refresh tokens
-3. Automatically refreshes expired tokens
-4. Injects the required OAuth headers and beta flags into API requests
-5. Sanitizes the system prompt for compatibility (see below)
-6. Zeros out model costs (since usage is covered by the subscription)
+Model-cost display differs by OpenCode version:
+
+- **OpenCode v1** — The plugin zeros out displayed model costs because usage is covered by the subscription.
+- **OpenCode v2** — OpenCode continues to display Anthropic's API prices even though requests authenticated through Claude Pro/Max use the subscription. Dynamic cost display is deferred until the beta plugin API can safely cancel the required connection event subscription.
 
 ### System Prompt Sanitization
 
@@ -90,7 +159,19 @@ This does three things:
 2. Symlinks the build output into `.opencode/plugins/` so OpenCode loads it as a local plugin
 3. Starts `tsc --watch` for automatic rebuilds on source changes
 
-After starting the dev script, restart OpenCode in this project directory to pick up the local build. Any edits to `src/` will trigger a rebuild — restart OpenCode again to load the new version.
+After starting the dev script:
+
+- On the `main` branch, restart OpenCode in this project directory.
+- On the `v2/main` branch, restart OpenCode v2 (`opencode2`) in this project directory.
+
+Edits to `src/` trigger a rebuild; restart the corresponding OpenCode version again to load the new build.
+
+You can confirm that the v2 plugin loaded through the OpenCode v2 API:
+
+```bash
+opencode2 api get /api/plugin        # should list "ex-machina.anthropic-auth"
+opencode2 api get /api/integration   # anthropic should offer a "Claude Pro/Max" OAuth method
+```
 
 Ctrl+C stops the watcher and cleans up the symlink. If the process was killed without cleanup (e.g. `kill -9`), you can manually remove the symlink:
 
@@ -103,13 +184,18 @@ bun run dev:clean
 
 ### Publishing
 
-This project uses [changesets](https://github.com/changesets/changesets) for versioning and publishing. See the [changeset README](.changeset/README.md) for more details.
+This project uses [changesets](https://github.com/changesets/changesets) for versioning and publishing. See the [changeset README](.changeset/README.md) for contributor details.
 
 ```bash
 bun change          # create a changeset describing your changes
 ```
 
-When changesets are merged to `main`, CI will automatically open a release PR. Merging that PR publishes to npm.
+Changesets merged to a release branch cause CI to open a release PR; merging that PR publishes to npm. The repository has two release trains:
+
+- `main` publishes plugin v1 for OpenCode v1 to npm's `latest` tag.
+- `v2/main` publishes plugin v2 prereleases for OpenCode v2 to npm's `next` tag.
+
+Maintainers can find the complete two-train release and branch-sync process in the [release runbook](https://github.com/ex-machina-co/opencode-anthropic-auth/blob/v2/main/RELEASING.md).
 
 ## License
 

package/dist/config.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Environment variable that overrides the reported Claude Code version.
+ *
+ * Anthropic gates model access on the reported version server-side, and that
+ * gate moves on Anthropic's schedule rather than this plugin's release
+ * schedule. The override lets users unblock a newly-gated model without
+ * waiting for a published bump.
+ */
+export declare const ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR = "ANTHROPIC_CLAUDE_CODE_VERSION";
+/**
+ * Outcome of reading the version override.
+ *
+ * The invalid arm carries no version: a malformed override must never reach
+ * the request path, so callers cannot accidentally report one. The outdated
+ * arm does carry one — an explicit older version is still honoured — but pairs
+ * it with the warning explaining why reporting it is risky.
+ */
+export type ClaudeCodeVersionResolution = {
+    type: 'success';
+    version: string;
+} | {
+    type: 'outdated';
+    version: string;
+    warning: string;
+} | {
+    type: 'invalid';
+    error: string;
+};
+/**
+ * Resolve the Claude Code version to report to Anthropic.
+ *
+ * Returns the bundled version when the override is unset. A set override is
+ * trimmed and must look like a Claude Code release; anything else resolves to
+ * `invalid` with a message describing how to correct it. An override older
+ * than the bundled version resolves to `outdated`: it is still reported, since
+ * it was set deliberately, but it can lock the user out of newer models.
+ * Never throws.
+ */
+export declare function resolveClaudeCodeVersion(raw?: string | undefined): ClaudeCodeVersionResolution;

package/dist/config.js

@@ -0,0 +1,72 @@
+import { CLAUDE_CODE_VERSION } from "./constants.js";
+/**
+ * Environment variable that overrides the reported Claude Code version.
+ *
+ * Anthropic gates model access on the reported version server-side, and that
+ * gate moves on Anthropic's schedule rather than this plugin's release
+ * schedule. The override lets users unblock a newly-gated model without
+ * waiting for a published bump.
+ */
+export const ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR = 'ANTHROPIC_CLAUDE_CODE_VERSION';
+/** Claude Code releases are `major.minor.patch` with numeric components. */
+const VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+/**
+ * Is `candidate` an older Claude Code release than `baseline`?
+ *
+ * Both arguments must already match `VERSION_PATTERN`. Components are compared
+ * numerically rather than lexically — `2.1.99` sorts after `2.1.258` as a
+ * string but is the older release — and as `BigInt`, so an unbounded component
+ * cannot silently lose precision the way `Number` would.
+ */
+function isOlderVersion(candidate, baseline) {
+    // The `0n` defaults are unreachable — `VERSION_PATTERN` guarantees exactly
+    // three components — but they keep the destructuring free of assertions.
+    const [major = 0n, minor = 0n, patch = 0n] = candidate
+        .split('.')
+        .map((part) => BigInt(part));
+    const [baseMajor = 0n, baseMinor = 0n, basePatch = 0n] = baseline
+        .split('.')
+        .map((part) => BigInt(part));
+    if (major !== baseMajor)
+        return major < baseMajor;
+    if (minor !== baseMinor)
+        return minor < baseMinor;
+    return patch < basePatch;
+}
+/**
+ * Resolve the Claude Code version to report to Anthropic.
+ *
+ * Returns the bundled version when the override is unset. A set override is
+ * trimmed and must look like a Claude Code release; anything else resolves to
+ * `invalid` with a message describing how to correct it. An override older
+ * than the bundled version resolves to `outdated`: it is still reported, since
+ * it was set deliberately, but it can lock the user out of newer models.
+ * Never throws.
+ */
+export function resolveClaudeCodeVersion(raw = process.env[ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR]) {
+    if (raw === undefined) {
+        return { type: 'success', version: CLAUDE_CODE_VERSION };
+    }
+    const trimmed = raw.trim();
+    if (!VERSION_PATTERN.test(trimmed)) {
+        return {
+            type: 'invalid',
+            error: `${ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR} is set to ${JSON.stringify(raw)}, which is not a ` +
+                `Claude Code version. Expected major.minor.patch (e.g. ${CLAUDE_CODE_VERSION}). ` +
+                `Reporting the bundled version ${CLAUDE_CODE_VERSION} instead — correct or unset ` +
+                `${ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR} and restart OpenCode to use the override.`,
+        };
+    }
+    if (isOlderVersion(trimmed, CLAUDE_CODE_VERSION)) {
+        return {
+            type: 'outdated',
+            version: trimmed,
+            warning: `${ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR} is set to ${JSON.stringify(trimmed)}, which is older ` +
+                `than the bundled Claude Code version ${CLAUDE_CODE_VERSION}. Anthropic gates model access on ` +
+                `the reported version, so reporting an older one can make newer models reject the request. ` +
+                `Set ${ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR} to ${CLAUDE_CODE_VERSION} or newer — or unset it ` +
+                `to use the bundled version — and restart OpenCode.`,
+        };
+    }
+    return { type: 'success', version: trimmed };
+}

package/dist/constants.d.ts

@@ -24,7 +24,15 @@ export declare const CCH_POSITIONS: number[];
  */
 export declare const CLAUDE_CODE_VERSION = "2.1.258";
 export declare const CLAUDE_CODE_ENTRYPOINT = "sdk-cli";
-export declare const USER_AGENT = "claude-cli/2.1.258 (external, cli)";
+/**
+ * Build the `user-agent` value for a reported Claude Code version.
+ *
+ * Both places we report the version (this header and the billing header's
+ * `cc_version`) must agree, so callers pass the same resolved version to each
+ * rather than reading a second, independently-derived constant.
+ */
+export declare function formatUserAgent(version: string): string;
+export declare const USER_AGENT: string;
 /**
  * Anchors that identify paragraphs to remove from the system prompt.
  * Any paragraph (text between blank lines) containing one of these

package/dist/constants.js

@@ -34,7 +34,17 @@ export const CCH_POSITIONS = [4, 7, 20];
  */
 export const CLAUDE_CODE_VERSION = '2.1.258';
 export const CLAUDE_CODE_ENTRYPOINT = 'sdk-cli';
-export const USER_AGENT = `claude-cli/${CLAUDE_CODE_VERSION} (external, cli)`;
+/**
+ * Build the `user-agent` value for a reported Claude Code version.
+ *
+ * Both places we report the version (this header and the billing header's
+ * `cc_version`) must agree, so callers pass the same resolved version to each
+ * rather than reading a second, independently-derived constant.
+ */
+export function formatUserAgent(version) {
+    return `claude-cli/${version} (external, cli)`;
+}
+export const USER_AGENT = formatUserAgent(CLAUDE_CODE_VERSION);
 /**
  * Anchors that identify paragraphs to remove from the system prompt.
  * Any paragraph (text between blank lines) containing one of these

package/dist/index.js

@@ -1,7 +1,42 @@
 import { authorize, exchange } from "./auth.js";
-import { CLIENT_ID, TOKEN_URL } from "./constants.js";
+import { resolveClaudeCodeVersion } from "./config.js";
+import { CLAUDE_CODE_VERSION, CLIENT_ID, TOKEN_URL } from "./constants.js";
 import { createStrippedStream, isInsecure, mergeHeaders, rewriteRequestBody, rewriteUrl, setOAuthHeaders, } from "./transform.js";
+/**
+ * Report a problem with the version override to the server log.
+ *
+ * Best-effort: a misconfigured override either degrades to the bundled version
+ * or is honoured as set, so a logging failure must not take the plugin down
+ * with it.
+ */
+async function logVersionOverrideIssue(client, level, message) {
+    try {
+        // biome-ignore lint/suspicious/noExplicitAny: SDK types don't expose app.log
+        await client?.app?.log({
+            body: {
+                service: 'anthropic-auth',
+                level,
+                message,
+            },
+        });
+    }
+    catch {
+        /* Logging is best-effort; the resolved version still applies. */
+    }
+}
 export const AnthropicAuthPlugin = async ({ client }) => {
+    // Resolved once per plugin instance so every request reports the same
+    // version in both the user-agent and the billing header.
+    const resolution = resolveClaudeCodeVersion();
+    if (resolution.type === 'invalid') {
+        await logVersionOverrideIssue(client, 'error', resolution.error);
+    }
+    else if (resolution.type === 'outdated') {
+        await logVersionOverrideIssue(client, 'warn', resolution.warning);
+    }
+    // Only a malformed override lacks a usable version; an outdated one was set
+    // deliberately, so it is reported as configured.
+    const claudeCodeVersion = resolution.type === 'invalid' ? CLAUDE_CODE_VERSION : resolution.version;
     return {
         auth: {
             provider: 'anthropic',
@@ -104,10 +139,10 @@ export const AnthropicAuthPlugin = async ({ client }) => {
                             }
                             const requestHeaders = mergeHeaders(input, init);
                             // biome-ignore lint/style/noNonNullAssertion: access is guaranteed set above
-                            setOAuthHeaders(requestHeaders, auth.access);
+                            setOAuthHeaders(requestHeaders, auth.access, claudeCodeVersion);
                             let body = init?.body;
                             if (body && typeof body === 'string') {
-                                body = rewriteRequestBody(body);
+                                body = rewriteRequestBody(body, claudeCodeVersion);
                             }
                             const rewritten = rewriteUrl(input);
                             const response = await fetch(rewritten.input, {

package/dist/transform.d.ts

@@ -1,3 +1,5 @@
+export declare const MAX_SSE_LINE_BYTES: number;
+export declare const MAX_JSON_TOOL_NAME_BYTES = 1024;
 export type FetchInput = string | URL | Request;
 /**
  * Merge headers from a Request object and/or a RequestInit headers value
@@ -11,8 +13,11 @@ export declare function mergeBetaHeaders(headers: Headers): string;
 /**
  * Set OAuth-required headers on the request: authorization, beta, user-agent.
  * Removes x-api-key since we're using OAuth.
+ *
+ * `version` must be the same value passed to rewriteRequestBody for the same
+ * request, otherwise the two reported versions disagree.
  */
-export declare function setOAuthHeaders(headers: Headers, accessToken: string): Headers;
+export declare function setOAuthHeaders(headers: Headers, accessToken: string, version?: string): Headers;
 /**
  * Add TOOL_PREFIX to tool names in the request body.
  * Prefixes both tool definitions and tool_use blocks in messages.
@@ -64,8 +69,11 @@ type SystemBlock = {
 export declare function prependClaudeCodeIdentity(system: unknown): SystemBlock[];
 /**
  * Rewrite the full request body: sanitize system prompt and prefix tool names.
+ *
+ * `version` must be the same value passed to setOAuthHeaders for the same
+ * request, otherwise the two reported versions disagree.
  */
-export declare function rewriteRequestBody(body: string): string;
+export declare function rewriteRequestBody(body: string, version?: string): string;
 /**
  * Create a streaming response that strips the tool prefix from tool names.
  */

package/dist/transform.js

@@ -1,5 +1,208 @@
 import { buildBillingHeaderValue } from "./cch.js";
-import { CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, OPENCODE_IDENTITY_PREFIX, PARAGRAPH_REMOVAL_ANCHORS, REQUIRED_BETAS, TEXT_REPLACEMENTS, TOOL_PREFIX, USER_AGENT, } from "./constants.js";
+import { CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, CLAUDE_CODE_VERSION, formatUserAgent, OPENCODE_IDENTITY_PREFIX, PARAGRAPH_REMOVAL_ANCHORS, REQUIRED_BETAS, TEXT_REPLACEMENTS, TOOL_PREFIX, } from "./constants.js";
+// Bound an incomplete SSE line so malformed streams cannot grow memory forever.
+export const MAX_SSE_LINE_BYTES = 5 * 1024 * 1024;
+function headersAfterBodyTransform(source) {
+    const headers = new Headers(source);
+    for (const name of [
+        'content-digest',
+        'content-encoding',
+        'content-length',
+        'content-md5',
+        'content-range',
+        'digest',
+        'etag',
+    ]) {
+        headers.delete(name);
+    }
+    return headers;
+}
+const JSON_NAME_KEY_SUFFIX = new TextEncoder().encode('name"');
+const JSON_TOOL_PREFIX = new TextEncoder().encode(TOOL_PREFIX);
+const UTF8_ENCODER = new TextEncoder();
+const UTF8_FATAL_DECODER = new TextDecoder('utf-8', { fatal: true });
+export const MAX_JSON_TOOL_NAME_BYTES = 1024;
+function isJsonWhitespace(byte) {
+    return byte === 0x20 || byte === 0x09 || byte === 0x0a || byte === 0x0d;
+}
+/**
+ * Rewrite JSON `name` string values without buffering the whole document.
+ * Only a bounded tool-name candidate is retained across chunks; all document
+ * content outside that string value is emitted immediately.
+ */
+function createJsonToolNameStream(body) {
+    let state = 'outside';
+    let held = [];
+    let candidateIndex = 0;
+    let escaped = false;
+    const enterStringAfter = (byte) => {
+        if (byte === 0x22) {
+            state = 'outside';
+            escaped = false;
+            return;
+        }
+        state = 'string';
+        escaped = byte === 0x5c;
+    };
+    return body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            const output = new Uint8Array(chunk.byteLength + 32);
+            let outputLength = 0;
+            const write = (byte) => {
+                output[outputLength++] = byte;
+            };
+            const enqueueOutput = () => {
+                if (outputLength === 0)
+                    return;
+                controller.enqueue(output.slice(0, outputLength));
+                outputLength = 0;
+            };
+            const writeHeld = () => {
+                for (const byte of held)
+                    write(byte);
+                held = [];
+            };
+            const processOutside = (byte) => {
+                if (byte === 0x22) {
+                    held = [byte];
+                    candidateIndex = 0;
+                    state = 'key-candidate';
+                    return;
+                }
+                write(byte);
+            };
+            for (const byte of chunk) {
+                if (state === 'outside') {
+                    processOutside(byte);
+                    continue;
+                }
+                if (state === 'key-candidate') {
+                    if (byte === JSON_NAME_KEY_SUFFIX[candidateIndex]) {
+                        held.push(byte);
+                        candidateIndex++;
+                        if (candidateIndex === JSON_NAME_KEY_SUFFIX.byteLength) {
+                            writeHeld();
+                            state = 'after-name-key';
+                        }
+                        continue;
+                    }
+                    writeHeld();
+                    write(byte);
+                    enterStringAfter(byte);
+                    continue;
+                }
+                if (state === 'string') {
+                    write(byte);
+                    if (escaped) {
+                        escaped = false;
+                    }
+                    else if (byte === 0x5c) {
+                        escaped = true;
+                    }
+                    else if (byte === 0x22) {
+                        state = 'outside';
+                    }
+                    continue;
+                }
+                if (state === 'after-name-key') {
+                    if (isJsonWhitespace(byte)) {
+                        write(byte);
+                    }
+                    else if (byte === 0x3a) {
+                        write(byte);
+                        state = 'after-colon';
+                    }
+                    else {
+                        processOutside(byte);
+                    }
+                    continue;
+                }
+                if (state === 'after-colon') {
+                    if (isJsonWhitespace(byte)) {
+                        write(byte);
+                    }
+                    else if (byte === 0x22) {
+                        write(byte);
+                        held = [];
+                        candidateIndex = 0;
+                        state = 'prefix-candidate';
+                    }
+                    else {
+                        processOutside(byte);
+                    }
+                    continue;
+                }
+                if (state === 'prefix-candidate') {
+                    if (byte === JSON_TOOL_PREFIX[candidateIndex]) {
+                        held.push(byte);
+                        candidateIndex++;
+                        if (candidateIndex === JSON_TOOL_PREFIX.byteLength) {
+                            held = [];
+                            candidateIndex = 0;
+                            escaped = false;
+                            state = 'tool-name-candidate';
+                        }
+                        continue;
+                    }
+                    writeHeld();
+                    write(byte);
+                    enterStringAfter(byte);
+                    continue;
+                }
+                if (escaped) {
+                    held.push(byte);
+                    escaped = false;
+                    if (held.length > MAX_JSON_TOOL_NAME_BYTES) {
+                        throw new Error(`JSON tool name exceeds ${MAX_JSON_TOOL_NAME_BYTES} byte limit`);
+                    }
+                    continue;
+                }
+                if (byte === 0x5c) {
+                    held.push(byte);
+                    escaped = true;
+                    if (held.length > MAX_JSON_TOOL_NAME_BYTES) {
+                        throw new Error(`JSON tool name exceeds ${MAX_JSON_TOOL_NAME_BYTES} byte limit`);
+                    }
+                    continue;
+                }
+                if (byte === 0x22) {
+                    let replacement;
+                    if (held.length === 0) {
+                        replacement = JSON_TOOL_PREFIX;
+                    }
+                    else {
+                        try {
+                            replacement = UTF8_ENCODER.encode(unprefixName(UTF8_FATAL_DECODER.decode(Uint8Array.from(held))));
+                        }
+                        catch {
+                            replacement = Uint8Array.from([...JSON_TOOL_PREFIX, ...held]);
+                        }
+                    }
+                    enqueueOutput();
+                    controller.enqueue(replacement);
+                    write(byte);
+                    held = [];
+                    candidateIndex = 0;
+                    state = 'outside';
+                    continue;
+                }
+                held.push(byte);
+                if (held.length > MAX_JSON_TOOL_NAME_BYTES) {
+                    throw new Error(`JSON tool name exceeds ${MAX_JSON_TOOL_NAME_BYTES} byte limit`);
+                }
+            }
+            enqueueOutput();
+        },
+        flush(controller) {
+            const trailing = Uint8Array.from(state === 'tool-name-candidate'
+                ? [...JSON_TOOL_PREFIX, ...held]
+                : held);
+            if (trailing.byteLength === 0)
+                return;
+            controller.enqueue(trailing);
+        },
+    }));
+}
 /**
  * Prefix a tool name with TOOL_PREFIX and uppercase the first character.
  * Claude Code uses PascalCase tool names (e.g. mcp_Bash, mcp_Read);
@@ -68,11 +271,14 @@ export function mergeBetaHeaders(headers) {
 /**
  * Set OAuth-required headers on the request: authorization, beta, user-agent.
  * Removes x-api-key since we're using OAuth.
+ *
+ * `version` must be the same value passed to rewriteRequestBody for the same
+ * request, otherwise the two reported versions disagree.
  */
-export function setOAuthHeaders(headers, accessToken) {
+export function setOAuthHeaders(headers, accessToken, version = CLAUDE_CODE_VERSION) {
     headers.set('authorization', `Bearer ${accessToken}`);
     headers.set('anthropic-beta', mergeBetaHeaders(headers));
-    headers.set('user-agent', USER_AGENT);
+    headers.set('user-agent', formatUserAgent(version));
     headers.delete('x-api-key');
     return headers;
 }
@@ -264,13 +470,16 @@ export function prependClaudeCodeIdentity(system) {
 }
 /**
  * Rewrite the full request body: sanitize system prompt and prefix tool names.
+ *
+ * `version` must be the same value passed to setOAuthHeaders for the same
+ * request, otherwise the two reported versions disagree.
  */
-export function rewriteRequestBody(body) {
+export function rewriteRequestBody(body, version = CLAUDE_CODE_VERSION) {
     try {
         const parsed = JSON.parse(body);
         const billingHeader = Array.isArray(parsed.messages) &&
             parsed.messages.some((message) => message.role === 'user')
-            ? buildBillingHeaderValue(parsed.messages, undefined, CLAUDE_CODE_ENTRYPOINT)
+            ? buildBillingHeaderValue(parsed.messages, version, CLAUDE_CODE_ENTRYPOINT)
             : null;
         // Sanitize system prompt and prepend Claude Code identity
         parsed.system = prependClaudeCodeIdentity(parsed.system);
@@ -289,26 +498,83 @@ export function rewriteRequestBody(body) {
  * Create a streaming response that strips the tool prefix from tool names.
  */
 export function createStrippedStream(response) {
+    const mediaType = response.headers
+        .get('content-type')
+        ?.split(';', 1)[0]
+        ?.trim()
+        .toLowerCase();
     if (!response.body)
         return response;
-    const reader = response.body.getReader();
+    if (mediaType === 'application/json' || mediaType?.endsWith('+json')) {
+        const stream = createJsonToolNameStream(response.body);
+        const headers = headersAfterBodyTransform(response.headers);
+        return new Response(stream, {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+        });
+    }
+    if (mediaType !== 'text/event-stream')
+        return response;
     const decoder = new TextDecoder();
     const encoder = new TextEncoder();
-    const stream = new ReadableStream({
-        async pull(controller) {
-            const { done, value } = await reader.read();
-            if (done) {
-                controller.close();
+    let pending = new Uint8Array(0);
+    let pendingLength = 0;
+    const appendPending = (bytes) => {
+        const requiredLength = pendingLength + bytes.byteLength;
+        if (requiredLength > MAX_SSE_LINE_BYTES) {
+            throw new Error(`SSE line exceeds ${MAX_SSE_LINE_BYTES} byte limit`);
+        }
+        if (requiredLength > pending.byteLength) {
+            let capacity = Math.max(1024, pending.byteLength);
+            while (capacity < requiredLength) {
+                capacity = Math.min(MAX_SSE_LINE_BYTES, capacity * 2);
+            }
+            const expanded = new Uint8Array(capacity);
+            expanded.set(pending.subarray(0, pendingLength));
+            pending = expanded;
+        }
+        pending.set(bytes, pendingLength);
+        pendingLength = requiredLength;
+    };
+    const stream = response.body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            let lastLineBreak = -1;
+            let lineLength = pendingLength;
+            for (let index = 0; index < chunk.byteLength; index++) {
+                if (chunk[index] === 0x0a || chunk[index] === 0x0d) {
+                    lastLineBreak = index;
+                    lineLength = 0;
+                }
+                else {
+                    lineLength++;
+                    if (lineLength > MAX_SSE_LINE_BYTES) {
+                        throw new Error(`SSE line exceeds ${MAX_SSE_LINE_BYTES} byte limit`);
+                    }
+                }
+            }
+            if (lastLineBreak < 0) {
+                appendPending(chunk);
                 return;
             }
-            let text = decoder.decode(value, { stream: true });
-            text = stripToolPrefix(text);
-            controller.enqueue(encoder.encode(text));
+            const completeLines = decoder.decode(pending.subarray(0, pendingLength), {
+                stream: true,
+            }) + decoder.decode(chunk.subarray(0, lastLineBreak + 1));
+            pendingLength = 0;
+            appendPending(chunk.subarray(lastLineBreak + 1));
+            controller.enqueue(encoder.encode(stripToolPrefix(completeLines)));
         },
-    });
+        flush(controller) {
+            const trailing = decoder.decode(pending.subarray(0, pendingLength));
+            if (trailing) {
+                controller.enqueue(encoder.encode(stripToolPrefix(trailing)));
+            }
+        },
+    }));
+    const headers = headersAfterBodyTransform(response.headers);
     return new Response(stream, {
         status: response.status,
         statusText: response.statusText,
-        headers: response.headers,
+        headers,
     });
 }

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@ex-machina/opencode-anthropic-auth",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/ex-machina-co/opencode-anthropic-auth"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "packageManager": "bun@1.3.14",
   "engines": {
     "bun": "1.3.14"
   },
@@ -19,11 +20,12 @@
     "dev": "bun scripts/dev.ts",
     "dev:clean": "bun scripts/dev-clean.ts",
     "extract": "bun scripts/extract-system-prompt.ts",
+    "check": "bun turbo check:all",
     "test": "bun test",
     "types": "tsc",
     "format": "biome check --write --unsafe",
     "format:check": "biome format .",
-    "lint": "biome lint .",
+    "lint": "biome lint --error-on-warnings .",
     "change": "changeset",
     "release": "bun run build && bun change publish"
   },
@@ -39,6 +41,7 @@
     "@types/bun": "1.3.14",
     "dedent": "^1.7.2",
     "lefthook": "2.1.9",
+    "turbo": "2.9.18",
     "typescript": "6.0.3"
   }
 }