@ex-machina/opencode-anthropic-auth 1.8.2 → 2.0.0-next.0

package/README.md

@@ -12,13 +12,22 @@
 
 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.
 
+## Version compatibility
+
+| Plugin version | OpenCode version | Package                                     |
+|-----------------|-------------------|---------------------------------------------|
+| 2.x (this readme) | OpenCode v2 (beta plugin API) | `@ex-machina/opencode-anthropic-auth` |
+| 1.x               | OpenCode v1       | `@ex-machina/opencode-anthropic-auth@1` |
+
+OpenCode v2's plugin API is still beta, and this plugin currently targets the `@opencode-ai/plugin@0.0.0-next-17444` prerelease of it — pin the plugin version and keep an eye on the changelog when bumping either side. If you're still on OpenCode v1, keep using a `1.x` release; v1 plugins are **not** loadable by OpenCode v2, and this v2 port is not loadable by OpenCode v1.
+
 ## Usage
 
 Add the plugin to your OpenCode configuration:
 
 ```json
 {
-  "plugin": ["@ex-machina/opencode-anthropic-auth"]
+  "plugins": ["@ex-machina/opencode-anthropic-auth"]
 }
 ```
 
@@ -31,18 +40,22 @@ Add the plugin to your OpenCode configuration:
 
 ```json
 {
-  "plugin": ["@ex-machina/opencode-anthropic-auth@1.8.1"]
+  "plugins": ["@ex-machina/opencode-anthropic-auth@<2.x.y-next.N>"]
 }
 ```
 
-## Authentication Methods
+The v2 line ships as prereleases on npm's `next` tag, so substitute a version that actually exists — `npm view @ex-machina/opencode-anthropic-auth dist-tags` shows the current one. Pin that exact version rather than tracking `@next`, which moves on every prerelease publish.
 
-The plugin provides three authentication options:
+## Authentication Methods
 
 - **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.
+    - run the `/connect` command, select `Anthropic` -> `Claude Pro/Max` and do OAuth
+- **Manually enter API Key / `ANTHROPIC_API_KEY`** - Handled by OpenCode's built-in Anthropic integration, not by this plugin.
+
+> [!NOTE]
+> The v1 release of this plugin also offered a "Create an API Key" OAuth flow (via `console.anthropic.com`) that minted and stored an API key for you. OpenCode v2's plugin API does not yet support an OAuth authorization flow that ends in a stored API key, so that flow isn't available in this v2 release. 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.
+>
+> OpenCode v2 continues to display Anthropic's API prices for these models 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.
 
 ## Configuration
 
@@ -51,7 +64,7 @@ The plugin supports the following environment variables:
 | 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_INSECURE`              | **Not supported under OpenCode v2.** OpenCode v2 plugin request hooks can rewrite a request but cannot disable TLS verification for it. If this is set, the plugin logs a warning and leaves TLS verification enabled — requests to a self-signed/untrusted `ANTHROPIC_BASE_URL` will fail. |
 
 ## How It Works
 
@@ -62,7 +75,6 @@ For Claude Pro/Max authentication, the plugin:
 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)
 
 ### System Prompt Sanitization
 
@@ -90,7 +102,14 @@ 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, restart OpenCode v2 (`opencode2`) 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.
+
+You can confirm the plugin loaded correctly via 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 +122,15 @@ 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. This repository runs two release trains — `main` publishes the v1 line to npm's `latest`, and `v2/main` publishes the v2 line to `next` as `2.x.y-next.N` prereleases.
+
+Maintainers: see [RELEASING.md](RELEASING.md) for the full runbook, including how `main` is synced into `v2/main`.
 
 ## License
 

package/dist/auth.d.ts

@@ -14,3 +14,19 @@ export type ExchangeResult = {
     type: 'failed';
 };
 export declare function exchange(input: string, verifier: string, redirectUri: string, expectedState?: string): Promise<ExchangeResult>;
+export type RefreshResult = {
+    type: 'success';
+    refresh: string;
+    access: string;
+    expires: number;
+} | {
+    type: 'failed';
+    status: number;
+};
+/**
+ * Exchange a refresh token for a new access/refresh token pair.
+ * Retries transient (5xx, network) failures with exponential backoff;
+ * non-transient failures (e.g. 403 on a revoked/rotated-away token)
+ * are returned immediately as `{ type: 'failed' }`.
+ */
+export declare function refreshToken(refreshTokenValue: string): Promise<RefreshResult>;

package/dist/auth.js

@@ -1,5 +1,41 @@
 import { AUTHORIZE_URLS, CLIENT_ID, CODE_CALLBACK_URL, OAUTH_SCOPES, TOKEN_URL, } from "./constants.js";
 import { generatePKCE } from "./pkce.js";
+const REFRESH_TIMEOUT_MS = 30_000;
+function isTokenResponse(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    if (!('refresh_token' in value) || !('access_token' in value))
+        return false;
+    if (!('expires_in' in value))
+        return false;
+    return (typeof value.refresh_token === 'string' &&
+        value.refresh_token.length > 0 &&
+        typeof value.access_token === 'string' &&
+        value.access_token.length > 0 &&
+        typeof value.expires_in === 'number' &&
+        Number.isSafeInteger(value.expires_in) &&
+        value.expires_in > 0);
+}
+async function parseTokenResponse(response) {
+    try {
+        const value = await response.json();
+        if (!isTokenResponse(value))
+            return undefined;
+        const expires = Date.now() + value.expires_in * 1000;
+        if (!Number.isSafeInteger(expires))
+            return undefined;
+        return {
+            refresh: value.refresh_token,
+            access: value.access_token,
+            expires,
+        };
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
 function generateState() {
     return crypto.randomUUID().replace(/-/g, '');
 }
@@ -50,12 +86,12 @@ async function exchangeCode(callback, verifier, redirectUri) {
             type: 'failed',
         };
     }
-    const json = (await result.json());
+    const tokens = await parseTokenResponse(result);
+    if (!tokens)
+        return { type: 'failed' };
     return {
         type: 'success',
-        refresh: json.refresh_token,
-        access: json.access_token,
-        expires: Date.now() + json.expires_in * 1000,
+        ...tokens,
     };
 }
 export async function authorize(mode) {
@@ -91,3 +127,71 @@ export async function exchange(input, verifier, redirectUri, expectedState) {
     }
     return exchangeCode(callback, verifier, redirectUri);
 }
+/**
+ * Exchange a refresh token for a new access/refresh token pair.
+ * Retries transient (5xx, network) failures with exponential backoff;
+ * non-transient failures (e.g. 403 on a revoked/rotated-away token)
+ * are returned immediately as `{ type: 'failed' }`.
+ */
+export async function refreshToken(refreshTokenValue) {
+    const maxRetries = 2;
+    const baseDelayMs = 500;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            if (attempt > 0) {
+                const delay = baseDelayMs * 2 ** (attempt - 1);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+            const response = await fetch(TOKEN_URL, {
+                method: 'POST',
+                signal: AbortSignal.timeout(REFRESH_TIMEOUT_MS),
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json, text/plain, */*',
+                    'User-Agent': 'axios/1.13.6',
+                },
+                body: JSON.stringify({
+                    grant_type: 'refresh_token',
+                    refresh_token: refreshTokenValue,
+                    client_id: CLIENT_ID,
+                }),
+            });
+            if (!response.ok) {
+                if (response.status >= 500 && attempt < maxRetries) {
+                    await response.body?.cancel();
+                    continue;
+                }
+                await response.body?.cancel();
+                return { type: 'failed', status: response.status };
+            }
+            const tokens = await parseTokenResponse(response);
+            if (!tokens) {
+                return { type: 'failed', status: response.status };
+            }
+            return {
+                type: 'success',
+                ...tokens,
+            };
+        }
+        catch (error) {
+            const isNetworkError = (typeof error === 'object' &&
+                error !== null &&
+                'name' in error &&
+                (error.name === 'TimeoutError' || error.name === 'AbortError')) ||
+                (error instanceof Error &&
+                    (error.message.includes('fetch failed') ||
+                        ('code' in error &&
+                            (error.code === 'ECONNRESET' ||
+                                error.code === 'ECONNREFUSED' ||
+                                error.code === 'ETIMEDOUT' ||
+                                error.code === 'UND_ERR_CONNECT_TIMEOUT'))));
+            if (attempt < maxRetries && isNetworkError) {
+                continue;
+            }
+            throw error;
+        }
+    }
+    // Unreachable — each iteration either returns or throws.
+    // Kept as a TypeScript exhaustiveness guard.
+    throw new Error('Token refresh exhausted all retries');
+}

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-import type { Plugin } from '@opencode-ai/plugin';
-export declare const AnthropicAuthPlugin: Plugin;
+import { Plugin } from '@opencode-ai/plugin';
+declare const _default: Plugin.Plugin;
+export default _default;

package/dist/index.js

@@ -1,175 +1,145 @@
-import { authorize, exchange } from "./auth.js";
-import { CLIENT_ID, TOKEN_URL } from "./constants.js";
+import { Plugin } from '@opencode-ai/plugin';
+import { authorize, exchange, refreshToken } from "./auth.js";
+import { REQUIRED_BETAS } from "./constants.js";
 import { createStrippedStream, isInsecure, mergeHeaders, rewriteRequestBody, rewriteUrl, setOAuthHeaders, } from "./transform.js";
-export const AnthropicAuthPlugin = async ({ client }) => {
+const PLUGIN_ID = 'ex-machina.anthropic-auth';
+const INTEGRATION_ID = 'anthropic';
+const REFRESH_CACHE_GRACE_MS = 30_000;
+// `methodID` is a branded `Integration.MethodID` at the type level (a
+// compile-time-only tag — there's no runtime representation), so a plain
+// string literal needs a cast to satisfy the branded field.
+const METHOD_ID = 'claude-max';
+function toCredential(exchanged) {
     return {
-        auth: {
-            provider: 'anthropic',
-            async loader(getAuth, provider) {
-                const auth = await getAuth();
-                if (auth.type === 'oauth') {
-                    // zero out cost for max plan
-                    for (const model of Object.values(provider.models)) {
-                        model.cost = {
-                            input: 0,
-                            output: 0,
-                            cache: {
-                                read: 0,
-                                write: 0,
-                            },
-                        };
+        type: 'oauth',
+        methodID: METHOD_ID,
+        refresh: exchanged.refresh,
+        access: exchanged.access,
+        expires: exchanged.expires,
+    };
+}
+async function resolveActiveOAuth(ctx) {
+    const connection = await ctx.integration.connection.active(INTEGRATION_ID);
+    if (!connection)
+        return undefined;
+    const credential = await ctx.integration.connection.resolve(connection);
+    if (credential?.type === 'oauth' && credential.methodID === METHOD_ID) {
+        return credential;
+    }
+    return undefined;
+}
+function warnIfInsecureUnsupported() {
+    if (!isInsecure())
+        return;
+    console.warn('[ex-machina.anthropic-auth] ANTHROPIC_INSECURE is set, but OpenCode v2 ' +
+        'plugin request hooks cannot disable TLS verification for a custom ' +
+        'ANTHROPIC_BASE_URL endpoint. TLS verification remains enabled — ' +
+        'requests to an untrusted/self-signed endpoint will fail.');
+}
+function isTransformedOAuthRequest(request) {
+    const betas = new Set((request.headers.get('anthropic-beta') ?? '')
+        .split(',')
+        .map((beta) => beta.trim()));
+    return (request.headers.get('authorization')?.startsWith('Bearer ') === true &&
+        REQUIRED_BETAS.every((beta) => betas.has(beta)) &&
+        new URL(request.url).searchParams.get('beta') === 'true');
+}
+export default Plugin.define({
+    id: PLUGIN_ID,
+    setup: async (ctx) => {
+        warnIfInsecureUnsupported();
+        // Retain successful refreshes for this plugin generation so a host call
+        // holding the rotated token cannot submit it again before persistence.
+        const refreshInFlight = new Map();
+        const refreshCredential = async (credential) => {
+            const existing = refreshInFlight.get(credential.refresh);
+            if (existing)
+                return existing;
+            const pending = (async () => {
+                const result = await refreshToken(credential.refresh);
+                if (result.type === 'failed') {
+                    throw new Error(`Anthropic token refresh failed: ${result.status}`);
+                }
+                return toCredential(result);
+            })();
+            refreshInFlight.set(credential.refresh, pending);
+            try {
+                const rotated = await pending;
+                const timer = setTimeout(() => {
+                    if (refreshInFlight.get(credential.refresh) === pending) {
+                        refreshInFlight.delete(credential.refresh);
                     }
-                    // Shared inflight refresh promise — prevents concurrent token refreshes
-                    // from racing against each other (and causing 401 cascades with token rotation)
-                    let refreshPromise = null;
+                }, REFRESH_CACHE_GRACE_MS);
+                timer.unref?.();
+                return rotated;
+            }
+            catch (error) {
+                if (refreshInFlight.get(credential.refresh) === pending) {
+                    refreshInFlight.delete(credential.refresh);
+                }
+                throw error;
+            }
+        };
+        await ctx.integration.transform((draft) => {
+            draft.method.update({
+                integrationID: INTEGRATION_ID,
+                method: {
+                    id: METHOD_ID,
+                    type: 'oauth',
+                    label: 'Claude Pro/Max',
+                },
+                authorize: async () => {
+                    const result = await authorize('max');
                     return {
-                        apiKey: '',
-                        async fetch(input, init) {
-                            const auth = await getAuth();
-                            if (auth.type !== 'oauth')
-                                return fetch(input, init);
-                            if (!auth.access || !auth.expires || auth.expires < Date.now()) {
-                                if (!refreshPromise) {
-                                    refreshPromise = (async () => {
-                                        const maxRetries = 2;
-                                        const baseDelayMs = 500;
-                                        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-                                            try {
-                                                if (attempt > 0) {
-                                                    const delay = baseDelayMs * 2 ** (attempt - 1);
-                                                    await new Promise((resolve) => setTimeout(resolve, delay));
-                                                }
-                                                // Re-read auth to get the latest refresh token.
-                                                // The outer `auth` snapshot may be stale if tokens
-                                                // were rotated since the fetch() call was made.
-                                                const freshAuth = await getAuth();
-                                                const response = await fetch(TOKEN_URL, {
-                                                    method: 'POST',
-                                                    headers: {
-                                                        'Content-Type': 'application/json',
-                                                        Accept: 'application/json, text/plain, */*',
-                                                        'User-Agent': 'axios/1.13.6',
-                                                    },
-                                                    body: JSON.stringify({
-                                                        grant_type: 'refresh_token',
-                                                        refresh_token: freshAuth.refresh,
-                                                        client_id: CLIENT_ID,
-                                                    }),
-                                                });
-                                                if (!response.ok) {
-                                                    if (response.status >= 500 && attempt < maxRetries) {
-                                                        await response.body?.cancel();
-                                                        continue;
-                                                    }
-                                                    const body = await response.text().catch(() => '');
-                                                    throw new Error(`Token refresh failed: ${response.status} — ${body}`);
-                                                }
-                                                const json = (await response.json());
-                                                // biome-ignore lint/suspicious/noExplicitAny: SDK types don't expose auth.set
-                                                await client.auth.set({
-                                                    path: {
-                                                        id: 'anthropic',
-                                                    },
-                                                    body: {
-                                                        type: 'oauth',
-                                                        refresh: json.refresh_token,
-                                                        access: json.access_token,
-                                                        expires: Date.now() + json.expires_in * 1000,
-                                                    },
-                                                });
-                                                return json.access_token;
-                                            }
-                                            catch (error) {
-                                                const isNetworkError = error instanceof Error &&
-                                                    (error.message.includes('fetch failed') ||
-                                                        ('code' in error &&
-                                                            (error.code === 'ECONNRESET' ||
-                                                                error.code === 'ECONNREFUSED' ||
-                                                                error.code === 'ETIMEDOUT' ||
-                                                                error.code === 'UND_ERR_CONNECT_TIMEOUT')));
-                                                if (attempt < maxRetries && isNetworkError) {
-                                                    continue;
-                                                }
-                                                throw error;
-                                            }
-                                        }
-                                        // Unreachable — each iteration either returns or throws.
-                                        // Kept as a TypeScript exhaustiveness guard.
-                                        throw new Error('Token refresh exhausted all retries');
-                                    })().finally(() => {
-                                        refreshPromise = null;
-                                    });
-                                }
-                                auth.access = await refreshPromise;
-                            }
-                            const requestHeaders = mergeHeaders(input, init);
-                            // biome-ignore lint/style/noNonNullAssertion: access is guaranteed set above
-                            setOAuthHeaders(requestHeaders, auth.access);
-                            let body = init?.body;
-                            if (body && typeof body === 'string') {
-                                body = rewriteRequestBody(body);
+                        url: result.url,
+                        instructions: 'Paste the authorization code here:',
+                        mode: 'code',
+                        callback: async (code) => {
+                            const exchanged = await exchange(code, result.verifier, result.redirectUri, result.state);
+                            if (exchanged.type === 'failed') {
+                                throw new Error('Failed to exchange the Claude Pro/Max authorization code. ' +
+                                    'Double-check that you pasted the full code and try again.');
                             }
-                            const rewritten = rewriteUrl(input);
-                            const response = await fetch(rewritten.input, {
-                                ...init,
-                                body,
-                                headers: requestHeaders,
-                                ...(isInsecure() && { tls: { rejectUnauthorized: false } }),
-                            });
-                            return createStrippedStream(response);
+                            return toCredential(exchanged);
                         },
                     };
-                }
-                return {};
-            },
-            methods: [
-                {
-                    label: 'Claude Pro/Max',
-                    type: 'oauth',
-                    authorize: async () => {
-                        const result = await authorize('max');
-                        return {
-                            url: result.url,
-                            instructions: 'Paste the authorization code here:',
-                            method: 'code',
-                            callback: async (code) => {
-                                return exchange(code, result.verifier, result.redirectUri, result.state);
-                            },
-                        };
-                    },
                 },
-                {
-                    label: 'Create an API Key',
-                    type: 'oauth',
-                    authorize: async () => {
-                        const result = await authorize('console');
-                        return {
-                            url: result.url,
-                            instructions: 'Paste the authorization code here:',
-                            method: 'code',
-                            callback: async (code) => {
-                                const credentials = await exchange(code, result.verifier, result.redirectUri, result.state);
-                                if (credentials.type === 'failed')
-                                    return credentials;
-                                const apiKey = await fetch(`https://api.anthropic.com/api/oauth/claude_cli/create_api_key`, {
-                                    method: 'POST',
-                                    headers: {
-                                        'Content-Type': 'application/json',
-                                        authorization: `Bearer ${credentials.access}`,
-                                    },
-                                }).then((r) => r.json());
-                                return { type: 'success', key: apiKey.raw_key };
-                            },
-                        };
-                    },
-                },
-                {
-                    provider: 'anthropic',
-                    label: 'Manually enter API Key',
-                    type: 'api',
-                },
-            ],
-        },
-        // biome-ignore lint/suspicious/noExplicitAny: Plugin type doesn't include undocumented auth/hooks
-    };
-};
+                refresh: refreshCredential,
+            });
+        });
+        await ctx.session.hook('http.request', async (event) => {
+            if (event.model.providerID !== INTEGRATION_ID)
+                return;
+            const credential = await resolveActiveOAuth(ctx);
+            if (!credential)
+                return;
+            const request = event.request;
+            const hasBody = request.method !== 'GET' && request.method !== 'HEAD';
+            const bodyText = hasBody ? await request.clone().text() : undefined;
+            const rewrittenBody = bodyText !== undefined ? rewriteRequestBody(bodyText) : undefined;
+            const headers = mergeHeaders(request);
+            setOAuthHeaders(headers, credential.access);
+            if (rewrittenBody !== undefined)
+                headers.delete('content-length');
+            const { input: rewrittenInput } = rewriteUrl(request.url);
+            const url = typeof rewrittenInput === 'string'
+                ? rewrittenInput
+                : rewrittenInput instanceof Request
+                    ? rewrittenInput.url
+                    : rewrittenInput.toString();
+            event.request = new Request(url, {
+                method: request.method,
+                headers,
+                body: rewrittenBody,
+                signal: request.signal,
+            });
+        });
+        await ctx.session.hook('http.response', (event) => {
+            if (event.model.providerID !== INTEGRATION_ID)
+                return;
+            if (!isTransformedOAuthRequest(event.request))
+                return;
+            event.response = createStrippedStream(event.response);
+        });
+    },
+});

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

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";
+// 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);
@@ -289,26 +492,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,14 @@
 {
   "name": "@ex-machina/opencode-anthropic-auth",
-  "version": "1.8.2",
+  "version": "2.0.0-next.0",
+  "type": "module",
   "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,26 +21,28 @@
     "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"
+    "release": "bun run build && bun change publish",
+    "release:next": "bun scripts/validate-next-release.ts && bun run release"
   },
-  "peerDependencies": {
-    "@opencode-ai/plugin": "*"
+  "dependencies": {
+    "@opencode-ai/plugin": "0.0.0-next-17444"
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.2",
     "@changesets/changelog-github": "^0.7.0",
     "@changesets/cli": "^2.31.0",
-    "@opencode-ai/plugin": "1.17.13",
     "@tsconfig/bun": "1.0.10",
     "@types/bun": "1.3.14",
     "dedent": "^1.7.2",
     "lefthook": "2.1.9",
+    "turbo": "2.9.18",
     "typescript": "6.0.3"
   }
 }