@sahiljassal/opencode-anthropic-auth 2.0.0 → 2.1.1

package/README.md

@@ -5,7 +5,7 @@
 >
 > Use your best judgment and don't abuse your subscription.
 
-Fork of [ex-machina-co/opencode-anthropic-auth](https://github.com/ex-machina-co/opencode-anthropic-auth).
+Fork of [ex-machina-co/opencode-anthropic-auth](https://github.com/ex-machina-co/opencode-anthropic-auth), with caching improvements inspired by [cortexkit/anthropic-auth](https://github.com/cortexkit/anthropic-auth).
 
 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.
 
@@ -27,18 +27,28 @@ Add to your OpenCode config (`~/.config/opencode/opencode.json`):
 
 ## Prompt Caching
 
-This fork applies **hybrid 1-hour ephemeral prompt caching** on every request:
+This fork applies **hybrid 1-hour ephemeral prompt caching** on every request, placing up to 4 breakpoints strategically:
 
-- Strips any existing `cache_control` blocks from the request
-- Anchors a `1h` ephemeral cache on the last system block (after identity) and the first two user messages
+| Breakpoint | Behaviour |
+|---|---|
+| **System anchor** | Last system block after the identity block (skipped when bridge occupies the slot) |
+| **messages[0]** | Magic-context split: anchors block[0] + block[1] when stable prefix and volatile delta are merged; otherwise anchors the last cacheable block |
+| **messages[1] / bridge** | Last cacheable block of messages[1]; replaced by a bridge anchor when a tool-heavy session pushes the latest user boundary outside Anthropic's 20-block lookback window |
+| **Rolling latest** | Most recent user message beyond index 1, keeping cache hot across long sessions |
+
+Additional behaviours:
 
-This reduces token usage and latency on repeated requests by reusing cached prompt prefixes.
+- **System tail coalescing** — plugin-added system blocks beyond the primary prompt are merged into one block before placing the system anchor, preventing cache busts when block layout changes between requests
+- **Trailing assistant strip** — assistant messages at the tail of the request are removed before forwarding (OAuth rejects assistant prefill)
+- **Thinking block guard** — `thinking` and `redacted_thinking` blocks are excluded from cache anchor placement; messages containing only thinking blocks receive no `cache_control` (avoids Anthropic 400)
+- **SSE retryable errors** — transient server errors (`api_error`, `overloaded_error`, `server_error`) emitted inside HTTP 200 streams are detected and thrown as connection-reset errors so OpenCode auto-retries
+- **Buffered stream rewriting** — tool name stripping buffers partial `"name"` tokens across chunk boundaries to avoid corruption
 
 ## Configuration
 
-| Variable | Description |
-|---|---|
-| `ANTHROPIC_BASE_URL` | Override API endpoint URL (e.g. for proxying). Must be a valid HTTP(S) URL. |
+| Variable             | Description                                                                              |
+| -------------------- | ---------------------------------------------------------------------------------------- |
+| `ANTHROPIC_BASE_URL` | Override API endpoint URL (e.g. for proxying). Must be a valid HTTP(S) URL.              |
 | `ANTHROPIC_INSECURE` | Set to `1` or `true` to skip TLS verification. Only effective with `ANTHROPIC_BASE_URL`. |
 
 ## License

package/dist/constants.d.ts

@@ -7,14 +7,21 @@ export declare const CODE_CALLBACK_URL = "https://platform.claude.com/oauth/code
 export declare const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
 export declare const OAUTH_SCOPES: string[];
 export declare const TOOL_PREFIX = "mcp_";
+/**
+ * Anthropic's sliding-window lookback for cache breakpoints.
+ * If the distance (in content blocks) between the previous user-role
+ * message anchor and the latest one exceeds this threshold, a bridge
+ * anchor is needed so the earlier slots are still within the window.
+ */
+export declare const ANTHROPIC_CACHE_LOOKBACK_BLOCKS = 20;
 export declare const REQUIRED_BETAS: string[];
 export declare const OPENCODE_IDENTITY_PREFIX = "You are OpenCode";
 export declare const CLAUDE_CODE_IDENTITY = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
 export declare const CCH_SALT = "59cf53e54c78";
 export declare const CCH_POSITIONS: number[];
-export declare const CLAUDE_CODE_VERSION = "2.1.87";
-export declare const CLAUDE_CODE_ENTRYPOINT = "sdk-cli";
-export declare const USER_AGENT = "claude-cli/2.1.87 (external, cli)";
+export declare const CLAUDE_CODE_VERSION = "2.1.177";
+export declare const CLAUDE_CODE_ENTRYPOINT = "cli";
+export declare const USER_AGENT = "claude-cli/2.1.177 (external, cli)";
 /**
  * Anchors that identify paragraphs to remove from the system prompt.
  * Any paragraph (text between blank lines) containing one of these

package/dist/constants.js

@@ -14,6 +14,13 @@ export const OAUTH_SCOPES = [
     'user:file_upload',
 ];
 export const TOOL_PREFIX = 'mcp_';
+/**
+ * Anthropic's sliding-window lookback for cache breakpoints.
+ * If the distance (in content blocks) between the previous user-role
+ * message anchor and the latest one exceeds this threshold, a bridge
+ * anchor is needed so the earlier slots are still within the window.
+ */
+export const ANTHROPIC_CACHE_LOOKBACK_BLOCKS = 20;
 export const REQUIRED_BETAS = [
     'oauth-2025-04-20',
     'interleaved-thinking-2025-05-14',
@@ -22,9 +29,9 @@ export const OPENCODE_IDENTITY_PREFIX = 'You are OpenCode';
 export const CLAUDE_CODE_IDENTITY = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
 export const CCH_SALT = '59cf53e54c78';
 export const CCH_POSITIONS = [4, 7, 20];
-export const CLAUDE_CODE_VERSION = '2.1.87';
-export const CLAUDE_CODE_ENTRYPOINT = 'sdk-cli';
-export const USER_AGENT = 'claude-cli/2.1.87 (external, cli)';
+export const CLAUDE_CODE_VERSION = '2.1.177';
+export const CLAUDE_CODE_ENTRYPOINT = 'cli';
+export const USER_AGENT = 'claude-cli/2.1.177 (external, cli)';
 /**
  * Anchors that identify paragraphs to remove from the system prompt.
  * Any paragraph (text between blank lines) containing one of these

package/dist/transform.d.ts

@@ -67,8 +67,20 @@ export declare function prependClaudeCodeIdentity(system: unknown): SystemBlock[
  * and apply hybrid 1h prompt caching.
  */
 export declare function rewriteRequestBody(body: string): string;
+/**
+ * Error thrown when Anthropic emits a retryable server-side error *inside*
+ * an HTTP 200 stream.  OpenCode recognises ECONNRESET + anthropic-sse syscall
+ * and applies its normal auto-retry flow instead of surfacing an unknown error.
+ */
+export type RetryableAnthropicStreamError = Error & {
+    code: 'ECONNRESET';
+    syscall: 'anthropic-sse';
+    providerErrorType?: string;
+};
 /**
  * Create a streaming response that strips the tool prefix from tool names.
+ * Detects retryable Anthropic server errors inside HTTP 200 streams and
+ * throws a connection-reset-style error so OpenCode can auto-retry.
  */
 export declare function createStrippedStream(response: Response): Response;
 export {};

package/dist/transform.js

@@ -1,4 +1,4 @@
-import { CLAUDE_CODE_IDENTITY, OPENCODE_IDENTITY_PREFIX, PARAGRAPH_REMOVAL_ANCHORS, REQUIRED_BETAS, TEXT_REPLACEMENTS, TOOL_PREFIX, USER_AGENT, } from "./constants.js";
+import { ANTHROPIC_CACHE_LOOKBACK_BLOCKS, CLAUDE_CODE_IDENTITY, OPENCODE_IDENTITY_PREFIX, PARAGRAPH_REMOVAL_ANCHORS, REQUIRED_BETAS, TEXT_REPLACEMENTS, TOOL_PREFIX, USER_AGENT, } from "./constants.js";
 /**
  * Prefix a tool name with TOOL_PREFIX and uppercase the first character.
  * Claude Code uses PascalCase tool names (e.g. mcp_Bash, mcp_Read);
@@ -217,6 +217,9 @@ function isRecord(value) {
     return value != null && typeof value === 'object' && !Array.isArray(value);
 }
 const CACHE_1H = { type: 'ephemeral', ttl: '1h' };
+// ---------------------------------------------------------------------------
+// Cache control primitives
+// ---------------------------------------------------------------------------
 function removeCacheControl(value) {
     if (!isRecord(value))
         return;
@@ -245,36 +248,245 @@ function setWireCacheControl(value) {
     value.cache_control = { ...CACHE_1H };
     return true;
 }
-function setMessageCacheAnchor(message) {
+// ---------------------------------------------------------------------------
+// Content-block helpers
+// ---------------------------------------------------------------------------
+/**
+ * Returns true for content block types that accept cache_control.
+ * Anthropic rejects cache_control on thinking / redacted_thinking blocks.
+ */
+function isCacheableContentBlock(block) {
+    if (!isRecord(block))
+        return false;
+    return block.type !== 'thinking' && block.type !== 'redacted_thinking';
+}
+/**
+ * Normalises message content to an array of blocks, then filters to only
+ * cacheable types.  Returns undefined when there is nothing to anchor.
+ */
+function getCacheableContentBlocks(message) {
     if (!isRecord(message))
+        return undefined;
+    let blocks;
+    if (Array.isArray(message.content)) {
+        blocks = message.content;
+    }
+    else if (typeof message.content === 'string') {
+        // Normalise inline string to block array in place so downstream sees array
+        const normalised = [{ type: 'text', text: message.content }];
+        message.content = normalised;
+        blocks = normalised;
+    }
+    else {
+        return undefined;
+    }
+    const cacheable = blocks.filter(isCacheableContentBlock);
+    return cacheable.length > 0 ? cacheable : undefined;
+}
+/**
+ * Total cacheable content-block count for a message (used for lookback math).
+ */
+function messageContentBlockCount(message) {
+    return getCacheableContentBlocks(message)?.length ?? 0;
+}
+// ---------------------------------------------------------------------------
+// Message-anchor setters
+// ---------------------------------------------------------------------------
+/**
+ * Anchor the last cacheable block of a message.
+ * Returns false (and sets nothing) when there are no cacheable blocks.
+ */
+function setMessageCacheAnchor(message) {
+    const blocks = getCacheableContentBlocks(message);
+    if (!blocks)
         return false;
-    const content = Array.isArray(message.content)
-        ? message.content
-        : typeof message.content === 'string'
-            ? [{ type: 'text', text: message.content }]
-            : null;
-    if (!content?.length)
-        return setWireCacheControl(message);
-    message.content = content;
-    const target = [...content]
-        .reverse()
-        .find((b) => isRecord(b) && b.type !== 'thinking');
-    return setWireCacheControl(target ?? message);
+    return setWireCacheControl(blocks[blocks.length - 1]);
 }
-function applyHybridCache1h(parsed) {
-    removeAllCacheControls(parsed);
-    // Cache last system block after the identity block
-    if (Array.isArray(parsed.system)) {
-        const identityIdx = parsed.system.findIndex((b) => isRecord(b) && b.text === CLAUDE_CODE_IDENTITY);
-        const cacheableSystem = parsed.system
-            .slice(identityIdx >= 0 ? identityIdx + 1 : 0)
-            .filter(isRecord);
-        setWireCacheControl(cacheableSystem[cacheableSystem.length - 1]);
+/**
+ * Anchor the FIRST cacheable block of a message (for magic-context split).
+ */
+function setFirstMessageCacheAnchor(message) {
+    const blocks = getCacheableContentBlocks(message);
+    if (!blocks)
+        return false;
+    return setWireCacheControl(blocks[0]);
+}
+/**
+ * Anchor the SECOND cacheable block of a message (for magic-context split).
+ * Returns false when fewer than two cacheable blocks exist.
+ */
+function setSecondMessageCacheAnchor(message) {
+    const blocks = getCacheableContentBlocks(message);
+    if (!blocks || blocks.length < 2)
+        return false;
+    return setWireCacheControl(blocks[1]);
+}
+/**
+ * Walk all messages and collect user-role (or tool_result) anchor positions.
+ * Returns the `latest` position (index > 1) and a `bridge` position placed
+ * whenever the cumulative block distance from bridge→latest exceeds
+ * ANTHROPIC_CACHE_LOOKBACK_BLOCKS, ensuring both are within the sliding window.
+ */
+function selectHybridMessageAnchors(messages) {
+    // Collect positions of user-role messages that have cacheable content
+    const userPositions = messages
+        .map((msg, index) => {
+        if (!isRecord(msg))
+            return null;
+        if (msg.role !== 'user')
+            return null;
+        const blockCount = messageContentBlockCount(msg);
+        if (blockCount === 0)
+            return null;
+        return { index, blockCount };
+    })
+        .filter((p) => p !== null);
+    // We only care about positions beyond index 1 (0 and 1 are always anchored)
+    const rollingPositions = userPositions.filter((p) => p.index > 1);
+    if (rollingPositions.length === 0) {
+        return { latest: undefined, bridge: undefined };
+    }
+    // Non-null: rollingPositions is non-empty (early return guards above)
+    // biome-ignore lint/style/noNonNullAssertion: guarded by length check above
+    const latest = rollingPositions[rollingPositions.length - 1];
+    // Find a bridge: walk back from latest until cumulative blocks exceed window
+    let bridge;
+    let cumulativeBlocks = latest.blockCount;
+    for (let i = rollingPositions.length - 2; i >= 0; i--) {
+        // biome-ignore lint/style/noNonNullAssertion: index is within bounds
+        cumulativeBlocks += rollingPositions[i].blockCount;
+        if (cumulativeBlocks > ANTHROPIC_CACHE_LOOKBACK_BLOCKS) {
+            bridge = rollingPositions[i];
+            break;
+        }
     }
+    return { latest, bridge };
+}
+// ---------------------------------------------------------------------------
+// System-anchor setter
+// ---------------------------------------------------------------------------
+function systemBlockText(block) {
+    return isRecord(block) && typeof block.text === 'string' ? block.text : '';
+}
+/**
+ * Merge all plugin-added system instruction blocks (those after the primary
+ * OpenCode/system prompt block) into a single block before placing the hybrid
+ * system cache anchor.
+ *
+ * OpenCode normally emits these as one merged block, but some hooks can cause
+ * them to arrive split across multiple blocks.  Without coalescing, byte-
+ * identical system text flips between merged/split layouts and moves the
+ * cache_control breakpoint — busting the cache every turn.
+ *
+ * Block layout after prependClaudeCodeIdentity:
+ *   [billing-header?] [identity] [primary system prompt] [plugin blocks…]
+ * We preserve everything up to and including the primary prompt block and
+ * merge all remaining plugin blocks into one.
+ */
+function coalesceHybridSystemTail(parsed) {
+    if (!Array.isArray(parsed.system))
+        return;
+    const system = parsed.system;
+    let prefixCount = 0;
+    // Skip optional billing-header block (not present in this fork but guard is safe)
+    if (systemBlockText(system[prefixCount]).startsWith('x-anthropic-billing-header:')) {
+        prefixCount++;
+    }
+    // Skip identity block
+    if (systemBlockText(system[prefixCount]) === CLAUDE_CODE_IDENTITY) {
+        prefixCount++;
+    }
+    // tailStart points to the first plugin-added block (one after primary prompt)
+    const tailStart = prefixCount + 1;
+    if (tailStart >= system.length - 1)
+        return;
+    const firstTail = system[tailStart];
+    if (!isRecord(firstTail))
+        return;
+    const mergedText = system.slice(tailStart).map(systemBlockText).join('\n');
+    system.splice(tailStart, system.length - tailStart, {
+        ...firstTail,
+        type: 'text',
+        text: mergedText,
+    });
+}
+/**
+ * Place a cache anchor on the last system block that follows the
+ * CLAUDE_CODE_IDENTITY block.  When there are no system blocks, or all
+ * system blocks precede the identity, nothing is anchored.
+ */
+function setHybridSystemAnchor(parsed) {
+    if (!Array.isArray(parsed.system))
+        return;
+    const identityIdx = parsed.system.findIndex((b) => isRecord(b) && b.text === CLAUDE_CODE_IDENTITY);
+    const afterIdentity = parsed.system
+        .slice(identityIdx >= 0 ? identityIdx + 1 : 0)
+        .filter(isRecord);
+    setWireCacheControl(afterIdentity[afterIdentity.length - 1]);
+}
+// ---------------------------------------------------------------------------
+// Trailing-assistant strip (Tier 2)
+// ---------------------------------------------------------------------------
+/**
+ * Remove trailing assistant-role messages.  OAuth endpoints reject requests
+ * that end with an assistant turn (assistant prefill is not supported).
+ */
+function stripTrailingAssistantMessages(parsed) {
     if (!Array.isArray(parsed.messages))
         return;
-    setMessageCacheAnchor(parsed.messages[0]);
-    setMessageCacheAnchor(parsed.messages[1]);
+    while (parsed.messages.length > 0 &&
+        isRecord(parsed.messages[parsed.messages.length - 1]) &&
+        parsed.messages[parsed.messages.length - 1].role === 'assistant') {
+        parsed.messages.pop();
+    }
+}
+// ---------------------------------------------------------------------------
+// Main hybrid cache logic
+// ---------------------------------------------------------------------------
+/**
+ * Apply hybrid 1h prompt-caching breakpoints to parsed request body.
+ *
+ * Breakpoint slots (Anthropic supports max 4 per request):
+ *   1. Last system block after the identity block  (skipped when bridge used)
+ *   2. messages[0] — first cacheable block         (magic-context: slot 2a)
+ *   3. messages[0] — second cacheable block        (magic-context split only)
+ *      OR messages[1] last cacheable block         (normal path)
+ *      OR bridge user message                      (when bridge detected)
+ *   4. Latest user/tool-result message (index > 1) (when present)
+ */
+function applyHybridCache1h(parsed) {
+    removeAllCacheControls(parsed);
+    coalesceHybridSystemTail(parsed);
+    const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+    const { latest, bridge } = selectHybridMessageAnchors(messages);
+    // --- Slot 1: system anchor (skip when bridge will occupy a slot) ---
+    if (!bridge) {
+        setHybridSystemAnchor(parsed);
+    }
+    // --- Slots 2 & 3: messages[0] ---
+    const msg0 = messages[0];
+    const msg0Blocks = getCacheableContentBlocks(msg0);
+    if (msg0Blocks && msg0Blocks.length >= 2) {
+        // Magic-context split: stable prefix is in block[0] and block[1];
+        // anchoring last block would bust cache every turn.
+        setFirstMessageCacheAnchor(msg0);
+        setSecondMessageCacheAnchor(msg0);
+    }
+    else {
+        setMessageCacheAnchor(msg0);
+        // --- Slot 3 (normal): messages[1] or bridge ---
+        if (bridge) {
+            setHybridSystemAnchor(parsed); // system anchor reclaimed for bridge support
+            setMessageCacheAnchor(messages[bridge.index]);
+        }
+        else {
+            setMessageCacheAnchor(messages[1]);
+        }
+    }
+    // --- Slot 4: rolling latest user anchor ---
+    if (latest) {
+        setMessageCacheAnchor(messages[latest.index]);
+    }
 }
 /**
  * Sanitize system prompt and prepend Claude Code identity.
@@ -329,6 +541,7 @@ export function rewriteRequestBody(body) {
     try {
         const parsed = JSON.parse(body);
         parsed.system = prependClaudeCodeIdentity(parsed.system);
+        stripTrailingAssistantMessages(parsed);
         applyHybridCache1h(parsed);
         return prefixToolNames(parsed);
     }
@@ -336,8 +549,146 @@ export function rewriteRequestBody(body) {
         return body;
     }
 }
+/** Find the first SSE event boundary (\n\n or \r\n\r\n) in a text buffer. */
+function findSseBoundary(value) {
+    const lf = value.indexOf('\n\n');
+    const crlf = value.indexOf('\r\n\r\n');
+    if (lf === -1)
+        return crlf === -1 ? null : { index: crlf, length: 4 };
+    if (crlf === -1 || lf < crlf)
+        return { index: lf, length: 2 };
+    return { index: crlf, length: 4 };
+}
+function asDiagnosticRecord(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringField(record, key) {
+    const v = record?.[key];
+    return typeof v === 'string' ? v : undefined;
+}
+function isRetryableAnthropicStreamError(errorType, message) {
+    const t = errorType?.toLowerCase();
+    const m = message.toLowerCase();
+    return (t === 'api_error' ||
+        t === 'overloaded_error' ||
+        t === 'server_error' ||
+        t === 'internal_server_error' ||
+        m.includes('internal server error') ||
+        m.includes('server overloaded'));
+}
+function retryableAnthropicStreamError(errorType, message) {
+    const detail = errorType ? `${errorType}: ${message}` : message;
+    const err = new Error(`Anthropic stream error: ${detail}`);
+    err.code = 'ECONNRESET';
+    err.syscall = 'anthropic-sse';
+    if (errorType)
+        err.providerErrorType = errorType;
+    return err;
+}
+function retryableAnthropicStreamErrorFromRawEvent(rawEvent) {
+    if (!rawEvent.includes('error'))
+        return null;
+    let eventName;
+    const dataLines = [];
+    for (const line of rawEvent.split(/\r?\n/)) {
+        if (line.startsWith('event:')) {
+            eventName = line.slice('event:'.length).trim();
+        }
+        else if (line.startsWith('data:')) {
+            const v = line.slice('data:'.length);
+            dataLines.push(v.startsWith(' ') ? v.slice(1) : v);
+        }
+    }
+    const dataText = dataLines.join('\n');
+    if (!dataText || dataText === '[DONE]')
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(dataText);
+    }
+    catch {
+        return null;
+    }
+    const data = asDiagnosticRecord(parsed);
+    if (eventName !== 'error' && stringField(data, 'type') !== 'error')
+        return null;
+    const errorObj = asDiagnosticRecord(data?.error);
+    const errorType = stringField(errorObj, 'type') ??
+        stringField(errorObj, 'code') ??
+        undefined;
+    const message = stringField(errorObj, 'message') ??
+        stringField(data, 'message') ??
+        errorType ??
+        'Anthropic stream error';
+    if (!isRetryableAnthropicStreamError(errorType, message))
+        return null;
+    return retryableAnthropicStreamError(errorType, message);
+}
+function createSseErrorState() {
+    return { pending: '' };
+}
+function updateSseErrorState(state, text) {
+    if (!text)
+        return null;
+    state.pending += text;
+    while (true) {
+        const boundary = findSseBoundary(state.pending);
+        if (!boundary)
+            break;
+        const rawEvent = state.pending.slice(0, boundary.index);
+        state.pending = state.pending.slice(boundary.index + boundary.length);
+        const err = retryableAnthropicStreamErrorFromRawEvent(rawEvent);
+        if (err)
+            return err;
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Buffered tool-prefix rewriting (v1.10.0)
+// ---------------------------------------------------------------------------
+/**
+ * Rewrite the tool prefix from the safe portion of a text buffer.
+ * Holds back any suffix that could be the start of a partial `"name"` marker
+ * spanning a chunk boundary.  Pass flush=true on stream end to emit everything.
+ */
+function splitToolPrefixRewriteBuffer(buffer, flush = false) {
+    if (flush)
+        return { ready: stripToolPrefix(buffer), pending: '' };
+    let keepFrom = buffer.length;
+    const marker = '"name"';
+    // Hold back any suffix that starts a partial marker
+    const partialStart = Math.max(0, buffer.length - marker.length + 1);
+    for (let i = partialStart; i < buffer.length; i++) {
+        if (marker.startsWith(buffer.slice(i))) {
+            keepFrom = Math.min(keepFrom, i);
+            break;
+        }
+    }
+    // Also hold back if the last occurrence of the marker is incomplete
+    const lastMarker = buffer.lastIndexOf(marker);
+    if (lastMarker !== -1) {
+        const tail = buffer.slice(lastMarker);
+        if (/^"name"\s*(?::\s*(?:"[^"]*)?)?$/.test(tail)) {
+            keepFrom = Math.min(keepFrom, lastMarker);
+        }
+    }
+    if (keepFrom < buffer.length) {
+        return {
+            ready: stripToolPrefix(buffer.slice(0, keepFrom)),
+            pending: buffer.slice(keepFrom),
+        };
+    }
+    return { ready: stripToolPrefix(buffer), pending: '' };
+}
+// ---------------------------------------------------------------------------
+// Stream response wrapper
+// ---------------------------------------------------------------------------
 /**
  * Create a streaming response that strips the tool prefix from tool names.
+ * Detects retryable Anthropic server errors inside HTTP 200 streams and
+ * throws a connection-reset-style error so OpenCode can auto-retry.
  */
 export function createStrippedStream(response) {
     if (!response.body)
@@ -345,16 +696,56 @@ export function createStrippedStream(response) {
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     const encoder = new TextEncoder();
+    let pending = '';
+    let readerReleased = false;
+    const sseErrors = createSseErrorState();
+    const releaseReader = () => {
+        if (readerReleased)
+            return;
+        readerReleased = true;
+        reader.releaseLock();
+    };
     const stream = new ReadableStream({
         async pull(controller) {
-            const { done, value } = await reader.read();
-            if (done) {
-                controller.close();
-                return;
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    const finalDecoded = decoder.decode();
+                    const retryableError = updateSseErrorState(sseErrors, finalDecoded);
+                    if (retryableError) {
+                        releaseReader();
+                        throw retryableError;
+                    }
+                    const { ready } = splitToolPrefixRewriteBuffer(`${pending}${finalDecoded}`, true);
+                    if (ready)
+                        controller.enqueue(encoder.encode(ready));
+                    releaseReader();
+                    controller.close();
+                    return;
+                }
+                const decoded = decoder.decode(value, { stream: true });
+                const retryableError = updateSseErrorState(sseErrors, decoded);
+                if (retryableError) {
+                    releaseReader();
+                    throw retryableError;
+                }
+                const { ready, pending: nextPending } = splitToolPrefixRewriteBuffer(pending + decoded);
+                pending = nextPending;
+                if (ready)
+                    controller.enqueue(encoder.encode(ready));
+            }
+            catch (error) {
+                releaseReader();
+                throw error;
+            }
+        },
+        async cancel(reason) {
+            try {
+                await reader.cancel(reason);
+            }
+            finally {
+                releaseReader();
             }
-            let text = decoder.decode(value, { stream: true });
-            text = stripToolPrefix(text);
-            controller.enqueue(encoder.encode(text));
         },
     });
     return new Response(stream, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sahiljassal/opencode-anthropic-auth",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shljsl75891/opencode-anthropic-auth.git"
@@ -31,14 +31,14 @@
     "@opencode-ai/plugin": "*"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.15",
+    "@biomejs/biome": "2.4.16",
     "@changesets/changelog-github": "^0.7.0",
     "@changesets/cli": "^2.31.0",
-    "@opencode-ai/plugin": "1.14.50",
+    "@opencode-ai/plugin": "1.17.3",
     "@tsconfig/bun": "1.0.10",
     "@types/bun": "1.3.14",
     "dedent": "^1.7.2",
-    "lefthook": "2.1.6",
+    "lefthook": "2.1.9",
     "typescript": "6.0.3"
   }
 }