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

package/README.md

@@ -1,80 +1,137 @@
 # 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.
 
-## Version compatibility
+> [!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
 
-| 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 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` |
 
-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.
+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
 {
-  "plugins": ["@ex-machina/opencode-anthropic-auth"]
+  "plugin": ["@ex-machina/opencode-anthropic-auth"]
 }
 ```
 
-> [!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`.
 
-#### Example of pinned version
+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@<2.x.y-next.N>"]
+  "plugins": ["@ex-machina/opencode-anthropic-auth@next"]
 }
 ```
 
-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.
+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
+{
+  "plugins": ["@ex-machina/opencode-anthropic-auth@<version>"]
+}
+```
 
 ## 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` -> `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.
+### 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.
+
+### 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]
-> 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.
+> 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.275`). Defaults to the bundled version; a malformed value logs an actionable error without echoing its contents, 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`              | **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. |
+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. 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)
+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)
+
+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
 
@@ -102,9 +159,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 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.
+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.
 
-You can confirm the plugin loaded correctly via the OpenCode v2 API:
+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"
@@ -128,9 +190,12 @@ This project uses [changesets](https://github.com/changesets/changesets) for ver
 bun change          # create a changeset describing your changes
 ```
 
-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.
+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: see [RELEASING.md](RELEASING.md) for the full runbook, including how `main` is synced into `v2/main`.
+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/auth.d.ts

@@ -25,8 +25,8 @@ export type RefreshResult = {
 };
 /**
  * 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' }`.
+ * Refresh tokens may rotate after a request reaches the provider. Retrying an
+ * ambiguous 5xx, timeout, network failure, or response-body failure can replay
+ * an already consumed token, so each call makes exactly one token request.
  */
 export declare function refreshToken(refreshTokenValue: string): Promise<RefreshResult>;

package/dist/auth.js

@@ -1,6 +1,37 @@
+import { BodyLimitError, contentLength, InvalidUtf8Error, readBoundedText, } from "./bounded.js";
 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;
+const TOKEN_TIMEOUT_MS = 30_000;
+const MAX_TOKEN_RESPONSE_BYTES = 64 * 1024;
+const MAX_TOKEN_LENGTH = 8 * 1024;
+const MAX_CALLBACK_INPUT_BYTES = 16 * 1024;
+const MAX_VERIFIER_BYTES = 1024;
+const MAX_REDIRECT_URI_BYTES = 2 * 1024;
+function isWellFormedUtf16(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const unit = value.charCodeAt(index);
+        if (unit >= 0xd800 && unit <= 0xdbff) {
+            if (index + 1 >= value.length)
+                return false;
+            const next = value.charCodeAt(index + 1);
+            if (next < 0xdc00 || next > 0xdfff)
+                return false;
+            index += 1;
+        }
+        else if (unit >= 0xdc00 && unit <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}
+function isBoundedUtf8(value, maxBytes) {
+    if (value.length === 0 ||
+        value.length > maxBytes ||
+        !isWellFormedUtf16(value)) {
+        return false;
+    }
+    return new TextEncoder().encode(value).byteLength <= maxBytes;
+}
 function isTokenResponse(value) {
     if (typeof value !== 'object' || value === null)
         return false;
@@ -9,16 +40,23 @@ function isTokenResponse(value) {
     if (!('expires_in' in value))
         return false;
     return (typeof value.refresh_token === 'string' &&
-        value.refresh_token.length > 0 &&
+        isBoundedUtf8(value.refresh_token, MAX_TOKEN_LENGTH) &&
         typeof value.access_token === 'string' &&
-        value.access_token.length > 0 &&
+        isBoundedUtf8(value.access_token, MAX_TOKEN_LENGTH) &&
         typeof value.expires_in === 'number' &&
         Number.isSafeInteger(value.expires_in) &&
         value.expires_in > 0);
 }
 async function parseTokenResponse(response) {
+    const declaredLength = contentLength(response.headers);
+    if (declaredLength !== undefined &&
+        declaredLength > MAX_TOKEN_RESPONSE_BYTES) {
+        await response.body?.cancel().catch(() => { });
+        return undefined;
+    }
     try {
-        const value = await response.json();
+        const text = await readBoundedText(response.body, MAX_TOKEN_RESPONSE_BYTES, 'Anthropic token response');
+        const value = JSON.parse(text);
         if (!isTokenResponse(value))
             return undefined;
         const expires = Date.now() + value.expires_in * 1000;
@@ -31,11 +69,54 @@ async function parseTokenResponse(response) {
         };
     }
     catch (error) {
-        if (error instanceof SyntaxError)
+        if (error instanceof SyntaxError ||
+            error instanceof BodyLimitError ||
+            error instanceof InvalidUtf8Error) {
             return undefined;
+        }
         throw error;
     }
 }
+function isTransientNetworkError(error) {
+    const seen = new WeakSet();
+    let current = error;
+    for (let depth = 0; depth < 8; depth++) {
+        if (typeof current !== 'object' || current === null)
+            return false;
+        if (seen.has(current))
+            return false;
+        seen.add(current);
+        if ('name' in current &&
+            (current.name === 'TimeoutError' || current.name === 'AbortError')) {
+            return true;
+        }
+        if ('code' in current) {
+            const code = current.code;
+            if (code === 'ECONNRESET' ||
+                code === 'ECONNREFUSED' ||
+                code === 'ETIMEDOUT' ||
+                code === 'EPIPE' ||
+                code === 'ENETUNREACH' ||
+                code === 'EAI_AGAIN' ||
+                code === 'UND_ERR_CONNECT_TIMEOUT' ||
+                code === 'UND_ERR_SOCKET') {
+                return true;
+            }
+        }
+        const message = current instanceof Error ? current.message.toLowerCase() : '';
+        if (message === 'fetch failed' ||
+            message === 'terminated' ||
+            message === 'network error' ||
+            message.includes('socket hang up') ||
+            message.includes('other side closed')) {
+            return true;
+        }
+        if (!('cause' in current))
+            return false;
+        current = current.cause;
+    }
+    return false;
+}
 function generateState() {
     return crypto.randomUUID().replace(/-/g, '');
 }
@@ -65,23 +146,34 @@ function parseCallbackInput(input) {
     return null;
 }
 async function exchangeCode(callback, verifier, redirectUri) {
-    const result = 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({
-            code: callback.code,
-            state: callback.state,
-            grant_type: 'authorization_code',
-            client_id: CLIENT_ID,
-            redirect_uri: redirectUri,
-            code_verifier: verifier,
-        }),
-    });
+    let result;
+    try {
+        result = await fetch(TOKEN_URL, {
+            method: 'POST',
+            signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS),
+            redirect: 'error',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/plain, */*',
+                'User-Agent': 'axios/1.13.6',
+            },
+            body: JSON.stringify({
+                code: callback.code,
+                state: callback.state,
+                grant_type: 'authorization_code',
+                client_id: CLIENT_ID,
+                redirect_uri: redirectUri,
+                code_verifier: verifier,
+            }),
+        });
+    }
+    catch (error) {
+        if (isTransientNetworkError(error))
+            return { type: 'failed' };
+        throw error;
+    }
     if (!result.ok) {
+        await result.body?.cancel().catch(() => { });
         return {
             type: 'failed',
         };
@@ -114,6 +206,13 @@ export async function authorize(mode) {
     };
 }
 export async function exchange(input, verifier, redirectUri, expectedState) {
+    if (!isBoundedUtf8(input, MAX_CALLBACK_INPUT_BYTES) ||
+        !isBoundedUtf8(verifier, MAX_VERIFIER_BYTES) ||
+        !isBoundedUtf8(redirectUri, MAX_REDIRECT_URI_BYTES) ||
+        (expectedState !== undefined &&
+            !isBoundedUtf8(expectedState, MAX_TOKEN_LENGTH))) {
+        return { type: 'failed' };
+    }
     const callback = parseCallbackInput(input);
     if (!callback) {
         return {
@@ -125,73 +224,53 @@ export async function exchange(input, verifier, redirectUri, expectedState) {
             type: 'failed',
         };
     }
+    if (!isBoundedUtf8(callback.code, MAX_TOKEN_LENGTH) ||
+        !isBoundedUtf8(callback.state, MAX_TOKEN_LENGTH)) {
+        return { type: 'failed' };
+    }
     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' }`.
+ * Refresh tokens may rotate after a request reaches the provider. Retrying an
+ * ambiguous 5xx, timeout, network failure, or response-body failure can replay
+ * an already consumed token, so each call makes exactly one token request.
  */
 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;
+    if (!isBoundedUtf8(refreshTokenValue, MAX_TOKEN_LENGTH)) {
+        return { type: 'failed', status: 400 };
+    }
+    try {
+        const response = await fetch(TOKEN_URL, {
+            method: 'POST',
+            signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS),
+            redirect: 'error',
+            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) {
+            await response.body?.cancel().catch(() => { });
+            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) {
+        if (isTransientNetworkError(error))
+            return { type: 'failed', status: 0 };
+        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/bounded.d.ts

@@ -0,0 +1,8 @@
+export declare class BodyLimitError extends Error {
+    constructor(label: string, limit: number);
+}
+export declare class InvalidUtf8Error extends Error {
+    constructor(label: string);
+}
+export declare function contentLength(headers: Headers): number | undefined;
+export declare function readBoundedText(body: ReadableStream<Uint8Array> | null, limit: number, label: string): Promise<string>;

package/dist/bounded.js

@@ -0,0 +1,59 @@
+export class BodyLimitError extends Error {
+    constructor(label, limit) {
+        super(`${label} exceeds ${limit} byte limit`);
+        this.name = 'BodyLimitError';
+    }
+}
+export class InvalidUtf8Error extends Error {
+    constructor(label) {
+        super(`${label} is not valid UTF-8`);
+        this.name = 'InvalidUtf8Error';
+    }
+}
+export function contentLength(headers) {
+    const raw = headers.get('content-length');
+    if (!raw || !/^\d+$/.test(raw))
+        return undefined;
+    const value = Number(raw);
+    return Number.isSafeInteger(value) ? value : undefined;
+}
+export async function readBoundedText(body, limit, label) {
+    if (!body)
+        return '';
+    const reader = body.getReader();
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    const parts = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > limit) {
+                await reader.cancel().catch(() => { });
+                throw new BodyLimitError(label, limit);
+            }
+            try {
+                parts.push(decoder.decode(value, { stream: true }));
+            }
+            catch {
+                throw new InvalidUtf8Error(label);
+            }
+        }
+        try {
+            parts.push(decoder.decode());
+        }
+        catch {
+            throw new InvalidUtf8Error(label);
+        }
+        return parts.join('');
+    }
+    catch (error) {
+        await reader.cancel(error).catch(() => { });
+        throw error;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

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 = {
+    readonly type: 'success';
+    readonly version: string;
+} | {
+    readonly type: 'outdated';
+    readonly version: string;
+    readonly warning: string;
+} | {
+    readonly type: 'invalid';
+    readonly 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;