@sahiljassal/opencode-anthropic-auth 2.6.0 → 2.7.0

package/README.md

@@ -41,6 +41,8 @@ Additional behaviours:
 - **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)
 - **Tool pair repair** — `/compact` and `/undo` can leave a `tool_use` and its `tool_result` matched by id but no longer adjacent. Orphaned `tool_result` blocks are dropped; orphaned `tool_use` blocks are never deleted (Anthropic rejects edits to `thinking`/`redacted_thinking` blocks in the latest assistant message) — instead a placeholder `tool_result` is synthesized to restore adjacency
+- **Assistant prefill strip** — trailing whitespace-only text after the latest assistant `tool_use` is removed before replay, so a valid tool-result continuation isn't rejected as an unsupported prefill
+- **Server-side safety fallback** — OAuth requests for `claude-fable-5`/`claude-opus-5` opt into Anthropic's `fallbacks: "default"` so a content-filter refusal is transparently rerouted instead of returned as an error. Since OpenCode has no concept of the returned `fallback` content block, it's hidden behind a signed marker on the way out and restored on the next replay before the request is sent. Only affects the OAuth fetch path — API-key auth is untouched
 - **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

package/dist/index.js

@@ -1,5 +1,6 @@
 import { authorize, exchange } from "./auth.js";
 import { CLIENT_ID, OAUTH_REFRESH_SKEW_MS, TOKEN_URL } from "./constants.js";
+import { isRecoverableRefusalModel } from "./server-fallback.js";
 import { computeRetryAfterDelayMs, createStrippedStream, extractModelId, isInsecure, mergeHeaders, rewriteRequestBody, rewriteUrl, setOAuthHeaders, } from "./transform.js";
 const MAX_429_RETRIES = 3;
 export const AnthropicAuthPlugin = async ({ client }) => {
@@ -121,12 +122,21 @@ export const AnthropicAuthPlugin = async ({ client }) => {
                             const modelId = typeof rawBody === 'string'
                                 ? extractModelId(rawBody)
                                 : undefined;
-                            // biome-ignore lint/style/noNonNullAssertion: access is guaranteed set above
-                            setOAuthHeaders(requestHeaders, auth.access, modelId);
                             let body = rawBody;
                             if (body && typeof body === 'string') {
                                 body = rewriteRequestBody(body);
                             }
+                            let parsedBody;
+                            if (typeof body === 'string') {
+                                try {
+                                    parsedBody = JSON.parse(body);
+                                }
+                                catch {
+                                    parsedBody = undefined;
+                                }
+                            }
+                            // biome-ignore lint/style/noNonNullAssertion: access is guaranteed set above
+                            setOAuthHeaders(requestHeaders, auth.access, modelId, parsedBody);
                             const rewritten = rewriteUrl(input);
                             let accessToken = auth.access;
                             let forcedRefreshAttempted = false;
@@ -150,7 +160,7 @@ export const AnthropicAuthPlugin = async ({ client }) => {
                                     if (refreshed === accessToken)
                                         break;
                                     accessToken = refreshed;
-                                    setOAuthHeaders(requestHeaders, refreshed, modelId);
+                                    setOAuthHeaders(requestHeaders, refreshed, modelId, parsedBody);
                                     continue;
                                 }
                                 if (response.status !== 429 || attempt >= MAX_429_RETRIES) {
@@ -160,7 +170,10 @@ export const AnthropicAuthPlugin = async ({ client }) => {
                                 await response.body?.cancel();
                                 await new Promise((resolve) => setTimeout(resolve, delay));
                             }
-                            return createStrippedStream(response);
+                            const serverFallbackModel = isRecoverableRefusalModel(modelId)
+                                ? modelId
+                                : undefined;
+                            return createStrippedStream(response, { serverFallbackModel });
                         },
                     };
                 }

package/dist/server-fallback.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Anthropic's server-side safety fallback (`server-side-fallback-2026-07-01`)
+ * transparently reroutes a refused Fable 5/Opus 5 request to Opus 5/Opus 4.8
+ * instead of returning a content-filter refusal. Opting OAuth requests into
+ * it means the returned `fallback` content block records the handoff.
+ * OpenCode has no concept of that block type, so it can't be persisted or
+ * replayed as-is — this module hides it behind a signed `thinking` marker on
+ * the way out and restores the original block on the way back in.
+ */
+export declare const SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-07-01";
+export declare function isRecoverableRefusalModel(model: unknown): model is string;
+/**
+ * Opts eligible Fable 5/Opus 5 requests into `fallbacks: "default"` and
+ * restores any hidden fallback-boundary markers left by a previous response.
+ */
+export declare function applyServerSideFallbackToBody(body: Record<string, unknown>): {
+    enabled: boolean;
+    restoredMarkers: number;
+    droppedMarkers: number;
+};
+/**
+ * Streaming SSE rewriter: converts a returned `fallback` content block into
+ * a hidden signed `thinking` marker, so OpenCode can store and later replay
+ * a response that crossed a server-side fallback boundary.
+ */
+export declare function createServerSideFallbackStreamRewriter(): {
+    push(text: string): string;
+    flush(): string;
+};

package/dist/server-fallback.js

@@ -0,0 +1,215 @@
+/**
+ * Anthropic's server-side safety fallback (`server-side-fallback-2026-07-01`)
+ * transparently reroutes a refused Fable 5/Opus 5 request to Opus 5/Opus 4.8
+ * instead of returning a content-filter refusal. Opting OAuth requests into
+ * it means the returned `fallback` content block records the handoff.
+ * OpenCode has no concept of that block type, so it can't be persisted or
+ * replayed as-is — this module hides it behind a signed `thinking` marker on
+ * the way out and restores the original block on the way back in.
+ */
+export const SERVER_SIDE_FALLBACK_BETA = 'server-side-fallback-2026-07-01';
+const MARKER_TEXT = '\u2060';
+const SIGNATURE_PREFIX = 'opencode-anthropic-auth-server-fallback-v1:';
+const RECOVERABLE_REFUSAL_MODEL_PATTERN = /^claude-(fable-5|opus-5)(-.*)?$/i;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function stringField(value, key) {
+    const field = value?.[key];
+    return typeof field === 'string' ? field : undefined;
+}
+export function isRecoverableRefusalModel(model) {
+    return (typeof model === 'string' && RECOVERABLE_REFUSAL_MODEL_PATTERN.test(model));
+}
+function encodeMarkerSignature(marker) {
+    return `${SIGNATURE_PREFIX}${marker.fromModel}|${marker.toModel}`;
+}
+function decodeMarkerSignature(value) {
+    if (typeof value !== 'string' || !value.startsWith(SIGNATURE_PREFIX)) {
+        return null;
+    }
+    const encoded = value.slice(SIGNATURE_PREFIX.length);
+    const separator = encoded.indexOf('|');
+    if (separator <= 0 || separator !== encoded.lastIndexOf('|'))
+        return null;
+    const fromModel = encoded.slice(0, separator);
+    const toModel = encoded.slice(separator + 1);
+    if (!fromModel || !toModel)
+        return null;
+    return { fromModel, toModel };
+}
+function markerFromFallbackBlock(block) {
+    if (block.type !== 'fallback')
+        return null;
+    const fromModel = stringField(isRecord(block.from) ? block.from : undefined, 'model');
+    const toModel = stringField(isRecord(block.to) ? block.to : undefined, 'model');
+    if (!fromModel || !toModel)
+        return null;
+    return { fromModel, toModel };
+}
+function fallbackBlock(marker) {
+    return {
+        type: 'fallback',
+        from: { model: marker.fromModel },
+        to: { model: marker.toModel },
+    };
+}
+function rewriteStoredMarkers(body, enabled) {
+    let restoredMarkers = 0;
+    let droppedMarkers = 0;
+    if (!Array.isArray(body.messages))
+        return { restoredMarkers, droppedMarkers };
+    for (const rawMessage of body.messages) {
+        if (!isRecord(rawMessage) ||
+            rawMessage.role !== 'assistant' ||
+            !Array.isArray(rawMessage.content)) {
+            continue;
+        }
+        const content = rawMessage.content;
+        const rewritten = [];
+        let messageRestored = 0;
+        let messageDropped = 0;
+        for (const rawBlock of content) {
+            const block = isRecord(rawBlock) ? rawBlock : undefined;
+            const isMarker = block?.type === 'thinking' &&
+                block.thinking === MARKER_TEXT &&
+                typeof block.signature === 'string' &&
+                block.signature.startsWith(SIGNATURE_PREFIX);
+            if (!isMarker) {
+                rewritten.push(rawBlock);
+                continue;
+            }
+            const marker = decodeMarkerSignature(block.signature);
+            if (enabled && marker) {
+                messageRestored++;
+                rewritten.push(fallbackBlock(marker));
+                continue;
+            }
+            messageDropped++;
+        }
+        // Dropping every block would leave an empty content array, which
+        // Anthropic rejects — leave the message untouched instead.
+        if (rewritten.length === 0 && content.length > 0)
+            continue;
+        restoredMarkers += messageRestored;
+        droppedMarkers += messageDropped;
+        rawMessage.content = rewritten;
+    }
+    return { restoredMarkers, droppedMarkers };
+}
+/**
+ * Opts eligible Fable 5/Opus 5 requests into `fallbacks: "default"` and
+ * restores any hidden fallback-boundary markers left by a previous response.
+ */
+export function applyServerSideFallbackToBody(body) {
+    const enabled = isRecoverableRefusalModel(body.model);
+    const markerResult = rewriteStoredMarkers(body, enabled);
+    if (enabled) {
+        body.fallbacks = 'default';
+    }
+    else if (body.fallbacks === 'default') {
+        delete body.fallbacks;
+    }
+    return { enabled, ...markerResult };
+}
+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 parseSseEvent(rawEvent) {
+    let event;
+    const dataLines = [];
+    for (const line of rawEvent.split(/\r?\n/)) {
+        if (line.startsWith('event:')) {
+            event = line.slice('event:'.length).trim();
+        }
+        else if (line.startsWith('data:')) {
+            const value = line.slice('data:'.length);
+            dataLines.push(value.startsWith(' ') ? value.slice(1) : value);
+        }
+    }
+    const text = dataLines.join('\n');
+    if (!text || text === '[DONE]')
+        return { event };
+    try {
+        const parsed = JSON.parse(text);
+        return { event, data: isRecord(parsed) ? parsed : undefined };
+    }
+    catch {
+        return { event };
+    }
+}
+function sseFrame(event, data) {
+    return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+function hiddenMarkerFrames(index, marker) {
+    return (sseFrame('content_block_start', {
+        type: 'content_block_start',
+        index,
+        content_block: { type: 'thinking', thinking: MARKER_TEXT },
+    }) +
+        sseFrame('content_block_delta', {
+            type: 'content_block_delta',
+            index,
+            delta: {
+                type: 'signature_delta',
+                signature: encodeMarkerSignature(marker),
+            },
+        }));
+}
+/**
+ * Streaming SSE rewriter: converts a returned `fallback` content block into
+ * a hidden signed `thinking` marker, so OpenCode can store and later replay
+ * a response that crossed a server-side fallback boundary.
+ */
+export function createServerSideFallbackStreamRewriter() {
+    let pending = '';
+    const rewriteEvent = (rawEvent, boundary) => {
+        const parsed = parseSseEvent(rawEvent);
+        const data = parsed.data;
+        const type = stringField(data, 'type') ?? parsed.event;
+        if (type === 'content_block_start') {
+            const block = isRecord(data?.content_block)
+                ? data.content_block
+                : undefined;
+            const marker = block ? markerFromFallbackBlock(block) : null;
+            if (marker) {
+                const index = typeof data?.index === 'number' ? data.index : 0;
+                return hiddenMarkerFrames(index, marker);
+            }
+        }
+        return rawEvent + boundary;
+    };
+    const drain = () => {
+        let output = '';
+        while (true) {
+            const boundary = findSseBoundary(pending);
+            if (!boundary)
+                break;
+            const rawEvent = pending.slice(0, boundary.index);
+            const delimiter = pending.slice(boundary.index, boundary.index + boundary.length);
+            pending = pending.slice(boundary.index + boundary.length);
+            output += rewriteEvent(rawEvent, delimiter);
+        }
+        return output;
+    };
+    return {
+        push(text) {
+            pending += text;
+            return drain();
+        },
+        flush() {
+            const output = drain();
+            if (!pending)
+                return output;
+            const tail = rewriteEvent(pending, '');
+            pending = '';
+            return output + tail;
+        },
+    };
+}

package/dist/transform.d.ts

@@ -14,7 +14,7 @@ export declare function mergeBetaHeaders(headers: Headers, modelId?: string): st
  * 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, modelId?: string): Headers;
+export declare function setOAuthHeaders(headers: Headers, accessToken: string, modelId?: string, body?: unknown): 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
@@ -92,5 +92,7 @@ export type RetryableAnthropicStreamError = Error & {
  * 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 declare function createStrippedStream(response: Response, options?: {
+    serverFallbackModel?: string;
+}): Response;
 export {};

package/dist/transform.js

@@ -1,4 +1,5 @@
 import { ADAPTIVE_THINKING_MODEL_PATTERN, ANTHROPIC_CACHE_LOOKBACK_BLOCKS, CLAUDE_CODE_IDENTITY, OPENCODE_IDENTITY_PREFIX, PARAGRAPH_REMOVAL_ANCHORS, REQUIRED_BETAS, TEXT_REPLACEMENTS, TOOL_PREFIX, TOOL_RESULT_PLACEHOLDER, USER_AGENT, } from "./constants.js";
+import { applyServerSideFallbackToBody, createServerSideFallbackStreamRewriter, SERVER_SIDE_FALLBACK_BETA, } from "./server-fallback.js";
 function prefixName(name) {
     return `${TOOL_PREFIX}${name.charAt(0).toUpperCase()}${name.slice(1)}`;
 }
@@ -71,9 +72,18 @@ export function mergeBetaHeaders(headers, modelId) {
  * Set OAuth-required headers: authorization, beta, user-agent.
  * Removes x-api-key since we're using OAuth.
  */
-export function setOAuthHeaders(headers, accessToken, modelId) {
+export function setOAuthHeaders(headers, accessToken, modelId, body) {
     headers.set('authorization', `Bearer ${accessToken}`);
-    headers.set('anthropic-beta', mergeBetaHeaders(headers, modelId));
+    let beta = mergeBetaHeaders(headers, modelId);
+    if (isRecord(body) && body.fallbacks === 'default') {
+        beta = [
+            ...new Set([
+                ...beta.split(',').filter(Boolean),
+                SERVER_SIDE_FALLBACK_BETA,
+            ]),
+        ].join(',');
+    }
+    headers.set('anthropic-beta', beta);
     headers.set('user-agent', USER_AGENT);
     headers.delete('x-api-key');
     return headers;
@@ -630,6 +640,37 @@ function stripTrailingAssistantMessages(parsed) {
         parsed.messages.pop();
     }
 }
+/**
+ * Anthropic can classify whitespace-only text after the latest assistant
+ * tool_use as assistant prefill on a later tool-result continuation, even
+ * though the request ends with a user turn. Strip it; preserve meaningful
+ * text and all earlier turns.
+ */
+function stripLatestAssistantToolUseTrailingWhitespace(parsed) {
+    if (!Array.isArray(parsed.messages))
+        return;
+    for (let index = parsed.messages.length - 1; index >= 0; index--) {
+        const message = parsed.messages[index];
+        if (!isRecord(message) || message.role !== 'assistant')
+            continue;
+        if (!Array.isArray(message.content))
+            return;
+        const hasToolUse = message.content.some((block) => isRecord(block) && block.type === 'tool_use');
+        if (!hasToolUse)
+            return;
+        while (message.content.length) {
+            const block = message.content[message.content.length - 1];
+            if (!isRecord(block) ||
+                block.type !== 'text' ||
+                typeof block.text !== 'string' ||
+                block.text.trim()) {
+                break;
+            }
+            message.content.pop();
+        }
+        return;
+    }
+}
 /**
  * Returns true when messages[0] carries a merged stable-prefix layout
  * (≥2 cacheable blocks). In that case anchoring the last block would bust
@@ -740,6 +781,8 @@ export function rewriteRequestBody(body) {
         stripRestrictedSamplingParams(parsed);
         stripUnsupportedEffortForHaiku(parsed);
         stripTrailingAssistantMessages(parsed);
+        stripLatestAssistantToolUseTrailingWhitespace(parsed);
+        applyServerSideFallbackToBody(parsed);
         applyHybridCache1h(parsed);
         return prefixToolNames(parsed);
     }
@@ -877,7 +920,7 @@ function splitToolPrefixRewriteBuffer(buffer, flush = false) {
  * 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) {
+export function createStrippedStream(response, options) {
     if (!response.body)
         return response;
     const reader = response.body.getReader();
@@ -886,6 +929,9 @@ export function createStrippedStream(response) {
     let pending = '';
     let readerReleased = false;
     const sseErrors = createSseErrorState();
+    const fallbackRewriter = options?.serverFallbackModel
+        ? createServerSideFallbackStreamRewriter()
+        : undefined;
     const releaseReader = () => {
         if (readerReleased)
             return;
@@ -897,7 +943,9 @@ export function createStrippedStream(response) {
             try {
                 const { done, value } = await reader.read();
                 if (done) {
-                    const finalDecoded = decoder.decode();
+                    const finalDecoded = fallbackRewriter
+                        ? fallbackRewriter.push(decoder.decode()) + fallbackRewriter.flush()
+                        : decoder.decode();
                     let retryableError = updateSseErrorState(sseErrors, finalDecoded);
                     if (!retryableError && sseErrors.pending) {
                         retryableError = retryableAnthropicStreamErrorFromRawEvent(sseErrors.pending);
@@ -919,7 +967,9 @@ export function createStrippedStream(response) {
                     controller.close();
                     return;
                 }
-                const decoded = decoder.decode(value, { stream: true });
+                const decoded = fallbackRewriter
+                    ? fallbackRewriter.push(decoder.decode(value, { stream: true }))
+                    : decoder.decode(value, { stream: true });
                 const retryableError = updateSseErrorState(sseErrors, decoded);
                 if (retryableError) {
                     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sahiljassal/opencode-anthropic-auth",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shljsl75891/opencode-anthropic-auth.git"