opencode-anthropic-fix 0.0.41 → 0.0.43

package/index.mjs

@@ -2354,28 +2354,35 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
               // pin the first attempt to that account so files are accessible.
               // Without this, round-robin could route to an account that doesn't
               // have the referenced files, causing file_not_found errors.
-              let pinnedAccount = null;
-              if (typeof requestInit.body === "string" && fileAccountMap.size > 0) {
+              // Parse body ONCE before the retry loop and reuse for all downstream logic.
+              // This eliminates 4-5 redundant JSON.parse calls per turn (file pinning,
+              // parseRequestBodyMetadata, adaptive context, toast, microcompact).
+              let _parsedBodyOnce = null;
+              if (typeof requestInit.body === "string") {
                 try {
-                  const bodyObj = JSON.parse(requestInit.body);
-                  const fileIds = extractFileIds(bodyObj);
-                  for (const fid of fileIds) {
-                    const pinnedIndex = fileAccountMap.get(fid);
-                    if (pinnedIndex !== undefined) {
-                      const candidates = accountManager.getEnabledAccounts();
-                      pinnedAccount = candidates.find((a) => a.index === pinnedIndex) ?? null;
-                      if (pinnedAccount) {
-                        debugLog("file-id pinning: routing to account", {
-                          fileId: fid,
-                          accountIndex: pinnedIndex,
-                          email: pinnedAccount.email,
-                        });
-                        break;
-                      }
+                  _parsedBodyOnce = JSON.parse(requestInit.body);
+                } catch {
+                  // Non-JSON body — downstream code handles gracefully
+                }
+              }
+
+              let pinnedAccount = null;
+              if (_parsedBodyOnce && fileAccountMap.size > 0) {
+                const fileIds = extractFileIds(_parsedBodyOnce);
+                for (const fid of fileIds) {
+                  const pinnedIndex = fileAccountMap.get(fid);
+                  if (pinnedIndex !== undefined) {
+                    const candidates = accountManager.getEnabledAccounts();
+                    pinnedAccount = candidates.find((a) => a.index === pinnedIndex) ?? null;
+                    if (pinnedAccount) {
+                      debugLog("file-id pinning: routing to account", {
+                        fileId: fid,
+                        accountIndex: pinnedIndex,
+                        email: pinnedAccount.email,
+                      });
+                      break;
                     }
                   }
-                } catch {
-                  // Non-JSON body or parse error — skip pinning
                 }
               }
 
@@ -2538,8 +2545,10 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
 
                 // Pre-compute the beta header so it can be injected into both the
                 // request body (betas field) and the anthropic-beta header.
+                // Reuse _parsedBodyOnce to avoid redundant JSON.parse.
                 const { model: _reqModel, hasFileReferences: _reqHasFileRefs } = parseRequestBodyMetadata(
                   requestInit.body,
+                  _parsedBodyOnce,
                 );
                 const _reqProvider = detectProvider(requestUrl);
 
@@ -2555,12 +2564,15 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                       escalation_threshold: 150_000,
                       deescalation_threshold: 100_000,
                     },
+                    _parsedBodyOnce,
                   );
                   // Emit visual cue on state transitions (only when adaptive mode is on)
                   if (config.adaptive_context?.enabled && _prevAdaptiveState !== adaptiveContextState.active) {
                     const label = adaptiveContextState.active ? "1M context ON" : "1M context OFF";
                     const variant = adaptiveContextState.active ? "info" : "success";
-                    const est = estimatePromptTokens(requestInit.body);
+                    const est = _parsedBodyOnce
+                      ? estimatePromptTokensFromParsed(_parsedBodyOnce)
+                      : estimatePromptTokens(requestInit.body);
                     toast(`⬡ ${label} (est. ${Math.round(est / 1000)}K tokens)`, variant, {
                       debounceKey: "adaptive-ctx",
                     }).catch(() => {});
@@ -2578,7 +2590,9 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                 // Microcompact: inject clear betas at high context utilization
                 let _microcompactBetas = null;
                 if (requestInit.body) {
-                  const estimatedTokens = estimatePromptTokens(requestInit.body);
+                  const estimatedTokens = _parsedBodyOnce
+                    ? estimatePromptTokensFromParsed(_parsedBodyOnce)
+                    : estimatePromptTokens(requestInit.body);
                   if (shouldMicrocompact(estimatedTokens, config)) {
                     _microcompactBetas = buildMicrocompactBetas();
                     if (!microcompactState.active) {
@@ -2973,7 +2987,10 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                           },
                           ...tail,
                         ];
-                        parsedBody.messages = trimmed;
+                        // Repair any orphaned tool_use blocks created by the trim boundary
+                        // (e.g. first 2 messages include an assistant tool_use whose
+                        // tool_result was in a trimmed middle message).
+                        parsedBody.messages = repairOrphanedToolUseBlocks(trimmed);
                         requestInit.body = JSON.stringify(parsedBody);
                         requestInit._reactiveCompactAttempted = true;
                         // Retry with trimmed messages (decrement attempt to not consume account slot)
@@ -3141,7 +3158,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                       consecutive529Count = 0;
                     }
 
-                    const baseDelay = Math.min(0.5 * Math.pow(2, serviceWideRetryCount), 8);
+                    const baseDelay = Math.min(0.5 * Math.pow(2, serviceWideRetryCount), 3);
                     const jitter = 1 - Math.random() * 0.25;
                     const sleepMs = Math.round(baseDelay * jitter * 1000);
                     const retryLabel = response.status === 529 ? "overloaded" : "unavailable";
@@ -4117,48 +4134,59 @@ function estimatePromptTokens(bodyString) {
   if (!bodyString || typeof bodyString !== "string") return 0;
   try {
     const parsed = JSON.parse(bodyString);
-    let charCount = 0;
+    return estimatePromptTokensFromParsed(parsed);
+  } catch {
+    // Fallback: raw body length / 4 if JSON parsing fails
+    return Math.ceil(bodyString.length / 4);
+  }
+}
 
-    // Count system prompt text
-    if (Array.isArray(parsed.system)) {
-      for (const block of parsed.system) {
-        if (block.type === "text" && typeof block.text === "string") {
-          charCount += block.text.length;
-        }
+/**
+ * Estimate prompt tokens from an already-parsed request body object.
+ * Avoids redundant JSON.parse when the caller already has the parsed object.
+ * @param {object} parsed - The parsed request body
+ * @returns {number} Estimated token count
+ */
+function estimatePromptTokensFromParsed(parsed) {
+  if (!parsed || typeof parsed !== "object") return 0;
+  let charCount = 0;
+
+  // Count system prompt text
+  if (Array.isArray(parsed.system)) {
+    for (const block of parsed.system) {
+      if (block.type === "text" && typeof block.text === "string") {
+        charCount += block.text.length;
       }
-    } else if (typeof parsed.system === "string") {
-      charCount += parsed.system.length;
     }
+  } else if (typeof parsed.system === "string") {
+    charCount += parsed.system.length;
+  }
 
-    // Count messages content (text blocks, tool results) — skip tool definitions
-    if (Array.isArray(parsed.messages)) {
-      for (const msg of parsed.messages) {
-        if (typeof msg.content === "string") {
-          charCount += msg.content.length;
-        } else if (Array.isArray(msg.content)) {
-          for (const block of msg.content) {
-            if (block.type === "text" && typeof block.text === "string") {
-              charCount += block.text.length;
-            } else if (block.type === "tool_result" && typeof block.content === "string") {
-              charCount += block.content.length;
-            } else if (block.type === "tool_use") {
-              // Count serialized input as tokens
-              charCount += JSON.stringify(block.input || {}).length;
-            } else if (block.type === "image" || block.type === "image_url") {
-              // Images: ~2000 tokens per image (Anthropic tile-based counting)
-              charCount += 8000; // 2000 tokens * 4 chars/token
-            }
+  // Count messages content (text blocks, tool results) — skip tool definitions
+  if (Array.isArray(parsed.messages)) {
+    for (const msg of parsed.messages) {
+      if (typeof msg.content === "string") {
+        charCount += msg.content.length;
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "text" && typeof block.text === "string") {
+            charCount += block.text.length;
+          } else if (block.type === "tool_result" && typeof block.content === "string") {
+            charCount += block.content.length;
+          } else if (block.type === "tool_use") {
+            // Count serialized input as tokens
+            charCount += JSON.stringify(block.input || {}).length;
+          } else if (block.type === "image" || block.type === "image_url") {
+            // Images: ~2000 tokens per image (Anthropic tile-based counting)
+            charCount += 8000; // 2000 tokens * 4 chars/token
           }
         }
       }
     }
-
-    // 4 chars/token heuristic for text content (reasonable for English + code + JSON)
-    return Math.ceil(charCount / 4);
-  } catch {
-    // Fallback: raw body length / 4 if JSON parsing fails
-    return Math.ceil(bodyString.length / 4);
   }
+
+  // 4 chars/token heuristic for text content (reasonable for English + code + JSON)
+  return Math.ceil(charCount / 4);
 }
 
 /**
@@ -4281,7 +4309,7 @@ function analyzeRequestContext(bodyStr) {
  * @param {import('./lib/config.mjs').AdaptiveContextConfig} adaptiveConfig
  * @returns {boolean}
  */
-function resolveAdaptiveContext(bodyString, model, adaptiveConfig) {
+function resolveAdaptiveContext(bodyString, model, adaptiveConfig, parsedBody) {
   // Non-adaptive: use static check (only explicit "1m" models)
   if (!adaptiveConfig.enabled) {
     return hasOneMillionContext(model);
@@ -4297,7 +4325,7 @@ function resolveAdaptiveContext(bodyString, model, adaptiveConfig) {
     return false;
   }
 
-  const estimatedTokens = estimatePromptTokens(bodyString);
+  const estimatedTokens = parsedBody ? estimatePromptTokensFromParsed(parsedBody) : estimatePromptTokens(bodyString);
   const turnsSinceTransition = sessionMetrics.turns - adaptiveContextState.lastTransitionTurn;
 
   if (adaptiveContextState.active) {
@@ -4739,6 +4767,94 @@ function computeBillingCacheHash(firstUserMessage, version) {
  * @param {Array} messages — The messages array from the parsed request body
  * @returns {Array} — Filtered messages array
  */
+
+/**
+ * Repair orphaned tool_use blocks in the message array.
+ *
+ * The Anthropic API requires that every assistant message containing `tool_use`
+ * blocks is immediately followed by a user message with `tool_result` blocks
+ * for each tool_use ID. When OpenCode crashes or hangs mid-tool-execution, the
+ * conversation may be persisted with assistant tool_use blocks that lack
+ * corresponding tool_result responses, causing:
+ *
+ *   "messages.N: `tool_use` ids were found without `tool_result` blocks
+ *    immediately after: toolu_XXXXX"
+ *
+ * This function scans the entire message array and inserts synthetic
+ * tool_result user messages wherever they are missing.
+ *
+ * @param {Array} messages — The messages array from the parsed request body
+ * @returns {Array} — Repaired messages array
+ */
+function repairOrphanedToolUseBlocks(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return messages;
+
+  const repaired = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    repaired.push(msg);
+
+    // Only check assistant messages with array content
+    if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+
+    // Collect tool_use IDs from this assistant message
+    const toolUseIds = [];
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id) {
+        toolUseIds.push(block.id);
+      }
+    }
+    if (toolUseIds.length === 0) continue;
+
+    // Check if the next message is a user message with matching tool_results
+    const next = messages[i + 1];
+    if (next && next.role === "user" && Array.isArray(next.content)) {
+      // Collect tool_result IDs present in the next user message
+      const resultIds = new Set();
+      for (const block of next.content) {
+        if (block.type === "tool_result" && block.tool_use_id) {
+          resultIds.add(block.tool_use_id);
+        }
+      }
+
+      // Find which tool_use IDs are missing from the tool_results
+      const missingIds = toolUseIds.filter((id) => !resultIds.has(id));
+      if (missingIds.length === 0) continue; // All paired, nothing to fix
+
+      // There are missing tool_results — inject them into the existing user message.
+      // Clone the next message to avoid mutating the original.
+      const patchedNext = {
+        ...next,
+        content: [
+          ...missingIds.map((id) => ({
+            type: "tool_result",
+            tool_use_id: id,
+            content: "[Result unavailable — tool execution was interrupted]",
+          })),
+          ...next.content,
+        ],
+      };
+      // Replace the next message in-place by skipping it and pushing the patched version
+      i++; // skip original next
+      repaired.push(patchedNext);
+    } else {
+      // Next message is missing or is not a user message — synthesize a full
+      // tool_result user message for all tool_use IDs.
+      repaired.push({
+        role: "user",
+        content: toolUseIds.map((id) => ({
+          type: "tool_result",
+          tool_use_id: id,
+          content: "[Result unavailable — tool execution was interrupted]",
+        })),
+      });
+    }
+  }
+
+  return repaired;
+}
+
 function stripSlashCommandMessages(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return messages;
 
@@ -5140,21 +5256,27 @@ function detectProvider(requestUrl) {
  * @param {any} body
  * @returns {{model: string, tools: any[], messages: any[], hasFileReferences: boolean}}
  */
-function parseRequestBodyMetadata(body) {
-  if (!body || typeof body !== "string") {
+function parseRequestBodyMetadata(body, parsedBody) {
+  const parsed =
+    parsedBody ||
+    (typeof body === "string"
+      ? (() => {
+          try {
+            return JSON.parse(body);
+          } catch {
+            return null;
+          }
+        })()
+      : null);
+  if (!parsed) {
     return { model: "", tools: [], messages: [], hasFileReferences: false };
   }
 
-  try {
-    const parsed = JSON.parse(body);
-    const model = typeof parsed?.model === "string" ? parsed.model : "";
-    const tools = Array.isArray(parsed?.tools) ? parsed.tools : [];
-    const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
-    const hasFileReferences = extractFileIds(parsed).length > 0;
-    return { model, tools, messages, hasFileReferences };
-  } catch {
-    return { model: "", tools: [], messages: [], hasFileReferences: false };
-  }
+  const model = typeof parsed?.model === "string" ? parsed.model : "";
+  const tools = Array.isArray(parsed?.tools) ? parsed.tools : [];
+  const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+  const hasFileReferences = extractFileIds(parsed).length > 0;
+  return { model, tools, messages, hasFileReferences };
 }
 
 /**
@@ -6130,14 +6252,20 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
       parsed.speed = "fast";
     }
 
-    // Guard: ensure messages array never ends with an assistant message.
-    // The API rejects this as "assistant message prefill" when extended thinking is active.
+    // Guard: repair orphaned tool_use blocks anywhere in the message array.
+    // The Anthropic API requires that every assistant message containing tool_use
+    // blocks is immediately followed by a user message with matching tool_result
+    // blocks. When OpenCode crashes/hangs mid-tool-execution, the conversation
+    // state may be saved with unpaired tool_use blocks. This causes:
+    //   "messages.N: `tool_use` ids were found without `tool_result` blocks
+    //    immediately after: toolu_XXXXX"
+    // We scan the full array and synthesize missing tool_result messages.
     if (Array.isArray(parsed.messages) && parsed.messages.length > 0) {
+      parsed.messages = repairOrphanedToolUseBlocks(parsed.messages);
+
+      // Also ensure the array never ends with an assistant message (prefill guard).
       const lastMsg = parsed.messages[parsed.messages.length - 1];
       if (lastMsg && lastMsg.role === "assistant") {
-        // Check if the assistant message contains tool_use blocks — if so,
-        // synthesize tool_result responses instead of bare "Continue." to
-        // respect the Anthropic tool protocol.
         const lastContent = Array.isArray(lastMsg.content) ? lastMsg.content : [];
         const toolUseBlocks = lastContent.filter((b) => b.type === "tool_use");
         if (toolUseBlocks.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "license": "GPL-3.0-or-later",
   "main": "./index.mjs",
   "files": [