@sahiljassal/opencode-anthropic-auth 2.2.0 → 2.4.1

package/dist/index.js

@@ -1,6 +1,7 @@
 import { authorize, exchange } from "./auth.js";
 import { CLIENT_ID, TOKEN_URL } from "./constants.js";
-import { createStrippedStream, isInsecure, mergeHeaders, rewriteRequestBody, rewriteUrl, setOAuthHeaders, } from "./transform.js";
+import { computeRetryAfterDelayMs, createStrippedStream, extractModelId, isInsecure, mergeHeaders, rewriteRequestBody, rewriteUrl, setOAuthHeaders, } from "./transform.js";
+const MAX_429_RETRIES = 3;
 export const AnthropicAuthPlugin = async ({ client }) => {
     return {
         auth: {
@@ -103,19 +104,32 @@ export const AnthropicAuthPlugin = async ({ client }) => {
                                 auth.access = await refreshPromise;
                             }
                             const requestHeaders = mergeHeaders(input, init);
+                            const rawBody = init?.body;
+                            const modelId = typeof rawBody === 'string'
+                                ? extractModelId(rawBody)
+                                : undefined;
                             // biome-ignore lint/style/noNonNullAssertion: access is guaranteed set above
-                            setOAuthHeaders(requestHeaders, auth.access);
-                            let body = init?.body;
+                            setOAuthHeaders(requestHeaders, auth.access, modelId);
+                            let body = rawBody;
                             if (body && typeof body === 'string') {
                                 body = rewriteRequestBody(body);
                             }
                             const rewritten = rewriteUrl(input);
-                            const response = await fetch(rewritten.input, {
-                                ...init,
-                                body,
-                                headers: requestHeaders,
-                                ...(isInsecure() && { tls: { rejectUnauthorized: false } }),
-                            });
+                            let response;
+                            for (let attempt = 0;; attempt++) {
+                                response = await fetch(rewritten.input, {
+                                    ...init,
+                                    body,
+                                    headers: requestHeaders,
+                                    ...(isInsecure() && { tls: { rejectUnauthorized: false } }),
+                                });
+                                if (response.status !== 429 || attempt >= MAX_429_RETRIES) {
+                                    break;
+                                }
+                                const delay = computeRetryAfterDelayMs(response.headers.get('retry-after'), attempt);
+                                await response.body?.cancel();
+                                await new Promise((resolve) => setTimeout(resolve, delay));
+                            }
                             return createStrippedStream(response);
                         },
                     };

package/dist/transform.d.ts

@@ -6,13 +6,21 @@ export type FetchInput = string | URL | Request;
 export declare function mergeHeaders(input: FetchInput, init?: RequestInit): Headers;
 /**
  * Merge incoming beta headers with the required OAuth betas, deduplicating.
+ * Excludes betas unsupported by the target model (e.g. interleaved-thinking
+ * on Haiku models).
  */
-export declare function mergeBetaHeaders(headers: Headers): string;
+export declare function mergeBetaHeaders(headers: Headers, modelId?: string): string;
 /**
  * Set OAuth-required headers: authorization, beta, user-agent.
  * Removes x-api-key since we're using OAuth.
  */
-export declare function setOAuthHeaders(headers: Headers, accessToken: string): Headers;
+export declare function setOAuthHeaders(headers: Headers, accessToken: string, modelId?: string): Headers;
+/**
+ * Extract the `model` field from a JSON request body string, if present.
+ * Used to make header rewriting (e.g. beta exclusions) model-aware before
+ * the body itself is parsed and transformed.
+ */
+export declare function extractModelId(body: string): string | undefined;
 /**
  * Add TOOL_PREFIX to tool names in the request body.
  * Prefixes both tool definitions and tool_use blocks in messages.
@@ -56,6 +64,13 @@ type SystemBlock = {
     text: string;
     [k: string]: unknown;
 };
+/**
+ * Compute the delay before retrying a 429 response. Prefers the
+ * `retry-after` header (seconds) when present and valid, otherwise falls
+ * back to exponential backoff. Always capped at RETRY_AFTER_CAP_MS to avoid
+ * honouring an excessively long server-provided wait.
+ */
+export declare function computeRetryAfterDelayMs(retryAfterHeader: string | null, attempt: number): number;
 /**
  * Sanitize system prompt and prepend Claude Code identity.
  * Handles all Anthropic API system formats: undefined, string, or array of text blocks.

package/dist/transform.js

@@ -44,28 +44,54 @@ export function mergeHeaders(input, init) {
     }
     return headers;
 }
+/**
+ * Anthropic rejects interleaved-thinking on Haiku models — this checks
+ * whether a model id refers to a Haiku model.
+ */
+function isHaikuModel(modelId) {
+    return /haiku/i.test(modelId ?? '');
+}
 /**
  * Merge incoming beta headers with the required OAuth betas, deduplicating.
+ * Excludes betas unsupported by the target model (e.g. interleaved-thinking
+ * on Haiku models).
  */
-export function mergeBetaHeaders(headers) {
+export function mergeBetaHeaders(headers, modelId) {
     const incomingBeta = headers.get('anthropic-beta') || '';
     const incomingBetasList = incomingBeta
         .split(',')
         .map((b) => b.trim())
         .filter(Boolean);
-    return [...new Set([...REQUIRED_BETAS, ...incomingBetasList])].join(',');
+    const requiredBetas = isHaikuModel(modelId)
+        ? REQUIRED_BETAS.filter((beta) => beta !== 'interleaved-thinking-2025-05-14')
+        : REQUIRED_BETAS;
+    return [...new Set([...requiredBetas, ...incomingBetasList])].join(',');
 }
 /**
  * Set OAuth-required headers: authorization, beta, user-agent.
  * Removes x-api-key since we're using OAuth.
  */
-export function setOAuthHeaders(headers, accessToken) {
+export function setOAuthHeaders(headers, accessToken, modelId) {
     headers.set('authorization', `Bearer ${accessToken}`);
-    headers.set('anthropic-beta', mergeBetaHeaders(headers));
+    headers.set('anthropic-beta', mergeBetaHeaders(headers, modelId));
     headers.set('user-agent', USER_AGENT);
     headers.delete('x-api-key');
     return headers;
 }
+/**
+ * Extract the `model` field from a JSON request body string, if present.
+ * Used to make header rewriting (e.g. beta exclusions) model-aware before
+ * the body itself is parsed and transformed.
+ */
+export function extractModelId(body) {
+    try {
+        const parsed = JSON.parse(body);
+        return typeof parsed?.model === 'string' ? parsed.model : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Add TOOL_PREFIX to tool names in the request body.
  * Prefixes both tool definitions and tool_use blocks in messages.
@@ -399,6 +425,88 @@ function setHybridSystemAnchor(parsed) {
         .filter(isRecord);
     setWireCacheControl(afterIdentity[afterIdentity.length - 1]);
 }
+const RETRY_AFTER_CAP_MS = 30000;
+const RETRY_BASE_DELAY_MS = 500;
+/**
+ * Compute the delay before retrying a 429 response. Prefers the
+ * `retry-after` header (seconds) when present and valid, otherwise falls
+ * back to exponential backoff. Always capped at RETRY_AFTER_CAP_MS to avoid
+ * honouring an excessively long server-provided wait.
+ */
+export function computeRetryAfterDelayMs(retryAfterHeader, attempt) {
+    const seconds = retryAfterHeader ? Number(retryAfterHeader) : Number.NaN;
+    const delay = Number.isFinite(seconds)
+        ? seconds * 1000
+        : RETRY_BASE_DELAY_MS * 2 ** attempt;
+    return Math.min(delay, RETRY_AFTER_CAP_MS);
+}
+/**
+ * Anthropic rejects the `effort` parameter for Haiku models. Strips
+ * `output_config.effort` and `thinking.effort`, removing the parent object
+ * entirely if `effort` was its only field.
+ */
+function stripUnsupportedEffortForHaiku(parsed) {
+    if (!isHaikuModel(typeof parsed.model === 'string' ? parsed.model : undefined))
+        return;
+    const outputConfig = parsed.output_config;
+    if (isRecord(outputConfig) && 'effort' in outputConfig) {
+        delete outputConfig.effort;
+        if (Object.keys(outputConfig).length === 0)
+            delete parsed.output_config;
+    }
+    const thinking = parsed.thinking;
+    if (isRecord(thinking) && 'effort' in thinking) {
+        delete thinking.effort;
+        if (Object.keys(thinking).length === 0)
+            delete parsed.thinking;
+    }
+}
+/**
+ * Remove tool_use blocks with no matching tool_result, and tool_result
+ * blocks that reference a non-existent tool_use. Anthropic rejects requests
+ * with unpaired tool_use/tool_result blocks — this can happen when OpenCode
+ * truncates or reconstructs conversation history after an interruption.
+ * Messages left with no content blocks are dropped entirely.
+ */
+function repairOrphanedToolPairs(parsed) {
+    if (!Array.isArray(parsed.messages))
+        return;
+    const toolUseIds = new Set();
+    const toolResultIds = new Set();
+    for (const msg of parsed.messages) {
+        if (!isRecord(msg) || !Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (!isRecord(block))
+                continue;
+            if (block.type === 'tool_use' && typeof block.id === 'string') {
+                toolUseIds.add(block.id);
+            }
+            else if (block.type === 'tool_result' &&
+                typeof block.tool_use_id === 'string') {
+                toolResultIds.add(block.tool_use_id);
+            }
+        }
+    }
+    parsed.messages = parsed.messages.filter((msg) => {
+        if (!isRecord(msg) || !Array.isArray(msg.content))
+            return true;
+        const filteredContent = msg.content.filter((block) => {
+            if (!isRecord(block))
+                return true;
+            if (block.type === 'tool_use' && typeof block.id === 'string') {
+                return toolResultIds.has(block.id);
+            }
+            if (block.type === 'tool_result' &&
+                typeof block.tool_use_id === 'string') {
+                return toolUseIds.has(block.tool_use_id);
+            }
+            return true;
+        });
+        msg.content = filteredContent;
+        return filteredContent.length > 0;
+    });
+}
 /**
  * Remove trailing assistant-role messages. OAuth endpoints reject requests
  * that end with an assistant turn (assistant prefill is not supported).
@@ -516,6 +624,8 @@ export function rewriteRequestBody(body) {
     try {
         const parsed = JSON.parse(body);
         parsed.system = prependClaudeCodeIdentity(parsed.system);
+        repairOrphanedToolPairs(parsed);
+        stripUnsupportedEffortForHaiku(parsed);
         stripTrailingAssistantMessages(parsed);
         applyHybridCache1h(parsed);
         return prefixToolNames(parsed);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sahiljassal/opencode-anthropic-auth",
-  "version": "2.2.0",
+  "version": "2.4.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shljsl75891/opencode-anthropic-auth.git"
@@ -31,10 +31,10 @@
     "@opencode-ai/plugin": "*"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.16",
+    "@biomejs/biome": "2.5.2",
     "@changesets/changelog-github": "^0.7.0",
     "@changesets/cli": "^2.31.0",
-    "@opencode-ai/plugin": "1.17.3",
+    "@opencode-ai/plugin": "1.17.13",
     "@tsconfig/bun": "1.0.10",
     "@types/bun": "1.3.14",
     "dedent": "^1.7.2",