@sahiljassal/opencode-anthropic-auth 2.5.0 → 2.6.0

package/README.md

@@ -40,6 +40,7 @@ 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
 - **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/constants.d.ts

@@ -7,6 +7,11 @@ 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_";
+/**
+ * Content for a synthesized tool_result whose real output was removed by a
+ * /compact or /undo summary insertion (see repairOrphanedToolPairs).
+ */
+export declare const TOOL_RESULT_PLACEHOLDER = "Tool result unavailable (removed during context compaction).";
 /**
  * Anthropic's cache lookback window size. Each explicit breakpoint scans at
  * most this many content blocks backward (counting the breakpoint block as

package/dist/constants.js

@@ -14,6 +14,11 @@ export const OAUTH_SCOPES = [
     'user:file_upload',
 ];
 export const TOOL_PREFIX = 'mcp_';
+/**
+ * Content for a synthesized tool_result whose real output was removed by a
+ * /compact or /undo summary insertion (see repairOrphanedToolPairs).
+ */
+export const TOOL_RESULT_PLACEHOLDER = 'Tool result unavailable (removed during context compaction).';
 /**
  * Anthropic's cache lookback window size. Each explicit breakpoint scans at
  * most this many content blocks backward (counting the breakpoint block as

package/dist/transform.js

@@ -1,4 +1,4 @@
-import { ADAPTIVE_THINKING_MODEL_PATTERN, ANTHROPIC_CACHE_LOOKBACK_BLOCKS, CLAUDE_CODE_IDENTITY, OPENCODE_IDENTITY_PREFIX, PARAGRAPH_REMOVAL_ANCHORS, REQUIRED_BETAS, TEXT_REPLACEMENTS, TOOL_PREFIX, USER_AGENT, } from "./constants.js";
+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";
 function prefixName(name) {
     return `${TOOL_PREFIX}${name.charAt(0).toUpperCase()}${name.slice(1)}`;
 }
@@ -499,60 +499,104 @@ function stripRestrictedSamplingParams(parsed) {
     delete parsed.top_p;
     delete parsed.top_k;
 }
+function toolUseIdOf(block) {
+    return isRecord(block) &&
+        block.type === 'tool_use' &&
+        typeof block.id === 'string'
+        ? block.id
+        : undefined;
+}
+function toolResultIdOf(block) {
+    return isRecord(block) &&
+        block.type === 'tool_result' &&
+        typeof block.tool_use_id === 'string'
+        ? block.tool_use_id
+        : undefined;
+}
 /**
- * Remove tool_use/tool_result blocks that are not adjacent pairs. Anthropic
- * requires a tool_result to be the first content in the message immediately
- * following its tool_use — a summary inserted by /undo or /compact can leave
- * the ids matched but no longer adjacent, which the API rejects with a 400.
- * Messages left with no content blocks are dropped entirely.
+ * Reconcile tool_use/tool_result adjacency broken by a /compact or /undo
+ * summary insertion. Anthropic requires a tool_result to be the first
+ * content in the message immediately following its tool_use, and rejects
+ * partial edits to an assistant message that holds thinking/redacted_thinking
+ * blocks ("thinking blocks in the latest assistant message cannot be
+ * modified") — so orphaned tool_use blocks can't simply be deleted. Two
+ * passes:
+ *
+ *  1. Remove tool_result blocks with no adjacent preceding tool_use (these
+ *     only live in user turns, so no thinking block is affected).
+ *  2. Synthesize a placeholder tool_result, adjacent, for every tool_use
+ *     that still lacks one — assistant message content is never rewritten.
  */
 function repairOrphanedToolPairs(parsed) {
     if (!Array.isArray(parsed.messages))
         return;
     const messages = parsed.messages;
-    const useMsgIndex = new Map();
-    const resultMsgIndex = new Map();
-    messages.forEach((msg, index) => {
-        if (!isRecord(msg) || !Array.isArray(msg.content))
-            return;
-        for (const block of msg.content) {
-            if (!isRecord(block))
-                continue;
-            if (block.type === 'tool_use' &&
-                typeof block.id === 'string' &&
-                !useMsgIndex.has(block.id)) {
-                useMsgIndex.set(block.id, index);
-            }
-            else if (block.type === 'tool_result' &&
-                typeof block.tool_use_id === 'string' &&
-                !resultMsgIndex.has(block.tool_use_id)) {
-                resultMsgIndex.set(block.tool_use_id, index);
-            }
-        }
-    });
-    const isAdjacentPair = (id) => {
-        const useIndex = useMsgIndex.get(id);
-        return useIndex !== undefined && resultMsgIndex.get(id) === useIndex + 1;
+    const hasAdjacentUse = (index, id) => {
+        const prev = messages[index - 1];
+        return (isRecord(prev) &&
+            Array.isArray(prev.content) &&
+            prev.content.some((block) => toolUseIdOf(block) === id));
     };
-    parsed.messages = messages.filter((msg, index) => {
+    const pass1 = messages.flatMap((msg, index) => {
         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 isAdjacentPair(block.id) && useMsgIndex.get(block.id) === index;
-            }
-            if (block.type === 'tool_result' &&
-                typeof block.tool_use_id === 'string') {
-                return (isAdjacentPair(block.tool_use_id) &&
-                    resultMsgIndex.get(block.tool_use_id) === index);
-            }
-            return true;
+            return [msg];
+        const filtered = msg.content.filter((block) => {
+            const resultId = toolResultIdOf(block);
+            return resultId === undefined || hasAdjacentUse(index, resultId);
         });
-        msg.content = filteredContent;
-        return filteredContent.length > 0;
+        if (filtered.length === 0 && msg.content.length > 0)
+            return [];
+        return [
+            filtered.length === msg.content.length
+                ? msg
+                : { ...msg, content: filtered },
+        ];
     });
+    const out = [];
+    for (let i = 0; i < pass1.length; i++) {
+        const msg = pass1[i];
+        out.push(msg);
+        if (!isRecord(msg) || !Array.isArray(msg.content))
+            continue;
+        const useIds = msg.content
+            .map(toolUseIdOf)
+            .filter((id) => id !== undefined);
+        if (useIds.length === 0)
+            continue;
+        const next = pass1[i + 1];
+        const presentIds = new Set(isRecord(next) && Array.isArray(next.content)
+            ? next.content
+                .map(toolResultIdOf)
+                .filter((id) => id !== undefined)
+            : []);
+        const missing = useIds.filter((id) => !presentIds.has(id));
+        if (missing.length === 0)
+            continue;
+        const synthetic = missing.map((id) => ({
+            type: 'tool_result',
+            tool_use_id: id,
+            content: TOOL_RESULT_PLACEHOLDER,
+            is_error: true,
+        }));
+        if (isRecord(next) && next.role === 'user' && Array.isArray(next.content)) {
+            out.push({ ...next, content: [...synthetic, ...next.content] });
+            i++;
+        }
+        else if (isRecord(next) &&
+            next.role === 'user' &&
+            typeof next.content === 'string') {
+            const text = next.content;
+            out.push({
+                ...next,
+                content: text.length > 0 ? [...synthetic, { type: 'text', text }] : synthetic,
+            });
+            i++;
+        }
+        else {
+            out.push({ role: 'user', content: synthetic });
+        }
+    }
+    parsed.messages = out;
 }
 /**
  * Anthropic requires tool_result blocks to precede any text in a message

package/package.json

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