opencode-anthropic-fix 2.2.0 → 2.2.1

package/lib/host/v2-transport.mjs

@@ -1,8 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
+import { performance } from "node:perf_hooks";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createAnthropic } from "@ai-sdk/anthropic";
+import { redactString } from "../redact.mjs";
 import { adaptV2Language, V2_SDK_PACKAGE } from "./v2-language.mjs";
 
 const TICKET_HEADER = "x-opencode-anthropic-fix-request";
@@ -14,6 +16,14 @@ function abortError(message) {
   return error;
 }
 
+// Only scalar diagnostic fields may reach logs, never arbitrary error objects
+// (which can carry request bodies, headers or credentials).
+function diagnosticValue(value) {
+  if (typeof value === "string") return redactString(value).slice(0, 2000);
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  return undefined;
+}
+
 /**
  * OpenCode 2.0.21 does not pass an abortSignal to LanguageModelV3.doStream.
  * Associate the host's HTTP hook with the custom fetch using a single-use
@@ -29,7 +39,7 @@ function abortError(message) {
  * middleware; never put the returned internal fetch in provider/model settings.
  *
  * @param {{session: {hook: Function}, aisdk: {hook: Function}, event: {subscribe: Function}} context
- * @param {{fetch: typeof fetch, isManagedModel?: (model: object) => boolean, onError?: (error: Error) => void, auxiliaryDeadlineMs?: number}} options
+ * @param {{fetch: typeof fetch, isManagedModel?: (model: object) => boolean, onError?: (error: Error, summary?: object) => void, auxiliaryDeadlineMs?: number}} options
  * @returns {Promise<{fetch: typeof fetch, dispose: () => Promise<void>}>}
  */
 export async function setupV2Transport(context, options) {
@@ -70,8 +80,10 @@ export async function setupV2Transport(context, options) {
         } else if (["session.execution.succeeded", "session.execution.failed"].includes(event.type)) {
           for (const ticket of tickets.values()) {
             // A request that never reached fetch may have failed in another
-            // HTTP hook. Keep active auxiliary streams until their own EOF.
-            if (!ticket.started && ticket.sessionID === event.data.sessionID) release(ticket);
+            // HTTP hook. Keep active auxiliary streams until their own EOF, and
+            // claimed tickets whose body is still uploading: the bridge releases
+            // those on its own finish or cancel path.
+            if (!ticket.started && !ticket.claimed && ticket.sessionID === event.data.sessionID) release(ticket);
           }
         }
       }
@@ -79,7 +91,7 @@ export async function setupV2Transport(context, options) {
     } catch (error) {
       if (disposed) return;
       eventFailure = error instanceof Error ? error : new Error(String(error));
-      cancelAll(eventFailure);
+      cancelAll(abortError(`OpenCode session event subscription failed. ${eventFailure.message}`));
       onError(eventFailure);
     }
   })();
@@ -170,7 +182,7 @@ export async function setupV2Transport(context, options) {
           // Remove our listener before aborting: cancellation already owns the
           // reader, and must not error a stream that the consumer just closed.
           signal.removeEventListener("abort", abort);
-          ticket.controller.abort(reason ?? abortError("Anthropic response cancelled."));
+          ticket.controller.abort(reason ?? abortError("Anthropic response consumer cancelled."));
           try {
             await reader.cancel(reason);
           } finally {
@@ -203,9 +215,10 @@ export async function setupV2Transport(context, options) {
       };
       response.once("close", disconnect);
       void (async () => {
+        const startedAt = performance.now();
+        let size = 0;
         try {
           const chunks = [];
-          let size = 0;
           for await (const chunk of request) {
             size += chunk.length;
             if (size > 32 * 1024 * 1024) throw new Error("Anthropic request exceeds 32 MiB.");
@@ -226,7 +239,9 @@ export async function setupV2Transport(context, options) {
           else response.end();
         } catch (error) {
           const interrupted = ticket.controller.signal.aborted;
-          cancel(ticket, error);
+          const reason = interrupted ? ticket.controller.signal.reason : undefined;
+          const headersSent = response.headersSent;
+          cancel(ticket, abortError("Anthropic bridge request failed."));
           if (!response.headersSent && !response.destroyed) {
             response.writeHead(502, { "content-type": "application/json" });
             response.end(
@@ -236,7 +251,32 @@ export async function setupV2Transport(context, options) {
               }),
             );
           } else response.destroy();
-          if (!interrupted) onError(new Error("Anthropic compatibility transport failed."));
+          const summary = {
+            name: diagnosticValue(error?.name),
+            message: diagnosticValue(error?.message ?? error),
+            code: diagnosticValue(error?.code),
+            status: diagnosticValue(error?.status),
+            cause: {
+              code: diagnosticValue(error?.cause?.code),
+              message: diagnosticValue(error?.cause?.message),
+            },
+            interrupted,
+            ...(interrupted && {
+              reason: {
+                name: diagnosticValue(reason?.name),
+                message: diagnosticValue(reason?.message ?? reason),
+              },
+            }),
+            headersSent,
+            started: ticket.started,
+            kind: diagnosticValue(ticket.kind),
+            bodyBytes: size,
+            elapsedMs: Math.round(performance.now() - startedAt),
+          };
+          onError(
+            new Error(`Anthropic compatibility transport failed. ${JSON.stringify(summary)}`, { cause: error }),
+            summary,
+          );
         } finally {
           response.removeListener("close", disconnect);
         }
@@ -270,7 +310,7 @@ export async function setupV2Transport(context, options) {
   async function releaseResources(reason) {
     disposed = true;
     cancelAll(reason);
-    subscription.abort();
+    subscription.abort(abortError("Anthropic transport event subscription stopped."));
     const results = await Promise.allSettled([
       ...registrations.map(async (registration) => registration.dispose()),
       closeBridge(),
@@ -294,6 +334,7 @@ export async function setupV2Transport(context, options) {
             id: randomUUID(),
             url,
             sessionID: event.sessionID,
+            kind: event.kind,
             controller: new AbortController(),
             started: false,
           };
@@ -320,7 +361,7 @@ export async function setupV2Transport(context, options) {
               headers,
             });
           } catch (error) {
-            cancel(ticket, error);
+            cancel(ticket, abortError("Anthropic HTTP request hook failed."));
             throw error;
           }
         },
@@ -355,7 +396,7 @@ export async function setupV2Transport(context, options) {
     );
   } catch (error) {
     try {
-      await releaseResources(error);
+      await releaseResources(abortError("Anthropic transport initialization failed."));
     } catch (cleanupError) {
       throw new AggregateError([error, cleanupError], "Anthropic transport initialization and cleanup failed.", {
         cause: cleanupError,
@@ -368,7 +409,7 @@ export async function setupV2Transport(context, options) {
     fetch: managedFetch,
     async dispose() {
       if (disposed) return;
-      await releaseResources(abortError("Anthropic plugin has been disposed."));
+      await releaseResources(abortError("Anthropic transport disposed."));
     },
   };
 }

package/lib/host/v2.mjs

@@ -1,4 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync, mkdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { createAnthropicRuntime } from "./runtime.mjs";
 import { registerAnthropicCommandRpc, registerAnthropicServerCommand } from "./command-rpc.mjs";
 import { setupV2Transport } from "./v2-transport.mjs";
@@ -6,6 +8,8 @@ import { V2_SDK_PACKAGE } from "./v2-language.mjs";
 import { prepareV2Tools } from "./tool-names.mjs";
 import { applyV2MessagePolicies, assertPortableV2History } from "./v2-context.mjs";
 import { isTruthyEnv } from "../env.mjs";
+import { getConfigDir } from "../config.mjs";
+import { redactString } from "../redact.mjs";
 import { hasOneMillionContext, isOpus46Model, isOpus47Model, isOpus48Model } from "../mimicry/wire-compat.mjs";
 
 export const OAUTH_METHOD_ID = "opencode-anthropic-fix";
@@ -13,6 +17,9 @@ export const OAUTH_METHOD_ID = "opencode-anthropic-fix";
 // built-in dynamic hook executes before ours, so a registry spec adds an install.
 export const V2_MODEL_PACKAGE = `aisdk:${V2_SDK_PACKAGE}`;
 
+// Shared by plugin instances so reload/disposal and user cancels do not spam stderr.
+let reportedInterruptedFailure = false;
+
 /** @param {object} auth */
 function credential(auth) {
   if (!auth?.access || !auth?.refresh) throw new Error("No enabled Anthropic OAuth account. Use /anthropic login.");
@@ -29,7 +36,7 @@ function credential(auth) {
  * v2 owns registration and presentation; the shared runtime owns credentials,
  * request construction and retries. No v1 hooks are returned to the v2 host.
  * @param {import('@opencode/plugin').Plugin.Context} context
- * @param {{createRuntime?: typeof createAnthropicRuntime, setupTransport?: typeof setupV2Transport}} [dependencies]
+ * @param {{createRuntime?: typeof createAnthropicRuntime, setupTransport?: typeof setupV2Transport, transportErrorDir?: string}} [dependencies]
  */
 export async function setupV2(context, dependencies = {}) {
   const runtime = (dependencies.createRuntime ?? createAnthropicRuntime)({
@@ -155,6 +162,37 @@ export async function setupV2(context, dependencies = {}) {
     const isManagedModel = (model) => managed && model?.providerID === "anthropic";
     transport = await (dependencies.setupTransport ?? setupV2Transport)(context, {
       isManagedModel,
+      onError(error, summary) {
+        // Never log the Error itself: its preserved cause may contain secrets.
+        const message = redactString(error.message);
+        const interrupted = summary?.interrupted === true;
+        const reportInterruption = interrupted && !reportedInterruptedFailure;
+        if (interrupted) reportedInterruptedFailure = true;
+        if (!interrupted) console.error(`[anthropic] ${message}`);
+        let sinkFailure;
+        try {
+          const directory = dependencies.transportErrorDir ?? getConfigDir();
+          mkdirSync(directory, { recursive: true });
+          const file = join(directory, "transport-errors.log");
+          const rotatedFile = `${file}.1`;
+          if (existsSync(file) && statSync(file).size > 2 * 1024 * 1024) {
+            if (existsSync(rotatedFile)) unlinkSync(rotatedFile);
+            renameSync(file, rotatedFile);
+          }
+          const entry = {
+            timestamp: new Date().toISOString(),
+            ...(summary ?? { name: redactString(error.name), message }),
+          };
+          writeFileSync(file, `${JSON.stringify(entry)}\n`, { flag: "a", mode: 0o600 });
+        } catch (sinkError) {
+          const detail = sinkError instanceof Error ? sinkError.message : sinkError;
+          sinkFailure = `Failed to write transport-errors.log: ${redactString(detail)}`;
+          if (!interrupted) console.error(`[anthropic] ${sinkFailure}`);
+        }
+        if (reportInterruption) {
+          console.error(`[anthropic] ${message}${sinkFailure ? ` ${sinkFailure}` : ""}`);
+        }
+      },
       async fetch(input, init) {
         if (disposed) throw new Error("Anthropic plugin is disposed");
         if (!managed) throw new Error("The Anthropic OAuth connection changed. Retry with the selected connection.");

package/lib/mimicry/request-body.mjs

@@ -94,6 +94,62 @@ export const CORE_TOOL_NAMES = new Set([
   "Compress",
 ]);
 
+/**
+ * True for a text block that holds only an opencode-model-router turn-state tail
+ * (`<router-state>…</router-state>`): per-request state the host never persists.
+ *
+ * @param {unknown} block
+ * @returns {boolean}
+ */
+function isRouterStateBlock(block) {
+  if (!block || typeof block !== "object" || block.type !== "text" || typeof block.text !== "string") return false;
+  const text = block.text.trim();
+  return text.startsWith("<router-state>") && text.endsWith("</router-state>");
+}
+
+/**
+ * Put the one message cache breakpoint on the last block of the last user
+ * message (real CC behaviour). When that block is a trailing `<router-state>`
+ * tail, the breakpoint goes on the nearest earlier block instead, so the cache
+ * entry ends on content the next request repeats; thinking, redacted thinking
+ * and blank text blocks are never marked. Without a tail, behaviour is unchanged.
+ *
+ * @param {Array<{role?: string, content?: unknown}>} messages
+ * @param {{type: string, ttl?: string}} marker
+ */
+function placeMessageBreakpoint(messages, marker) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== "user" || !Array.isArray(msg.content) || msg.content.length === 0) continue;
+    const lastBlock = msg.content[msg.content.length - 1];
+    if (!isRouterStateBlock(lastBlock)) {
+      if (lastBlock && typeof lastBlock === "object") lastBlock.cache_control = marker;
+      return;
+    }
+    for (let m = i; m >= 0; m--) {
+      const content = messages[m].content;
+      if (typeof content === "string") {
+        // Anthropic's string shorthand is one text block; normalize it so the
+        // breakpoint can sit on it (same tokens, so the cached prefix is unchanged).
+        if (content.trim() === "" || isRouterStateBlock({ type: "text", text: content })) continue;
+        messages[m].content = [{ type: "text", text: content, cache_control: marker }];
+        return;
+      }
+      if (!Array.isArray(content)) continue;
+      const start = m === i ? content.length - 2 : content.length - 1;
+      for (let b = start; b >= 0; b--) {
+        const block = content[b];
+        if (!block || typeof block !== "object" || isRouterStateBlock(block)) continue;
+        if (block.type === "thinking" || block.type === "redacted_thinking") continue;
+        if (block.type === "text" && (typeof block.text !== "string" || block.text.trim() === "")) continue;
+        block.cache_control = marker;
+        return;
+      }
+    }
+    return;
+  }
+}
+
 /**
  * Transform the request body: system prompt sanitization and tool prefixing.
  * Preserves behaviors E1-E7.
@@ -508,18 +564,18 @@ export function transformRequestBody(body, signature, runtime, taskBudgetsActive
             }
           }
         }
-        // Add cache_control to last user message (real CC does this).
-        // (User messages never contain thinking blocks, so the guard above
-        // does not affect this breakpoint.)
-        for (let i = parsed.messages.length - 1; i >= 0; i--) {
-          const msg = parsed.messages[i];
-          if (msg.role !== "user" || !Array.isArray(msg.content) || msg.content.length === 0) continue;
-          const lastBlock = msg.content[msg.content.length - 1];
-          if (lastBlock && typeof lastBlock === "object") {
-            lastBlock.cache_control = { type: "ephemeral", ttl: ccTtl };
-          }
-          break;
-        }
+        // At most one message breakpoint (see placeMessageBreakpoint). Normally
+        // it goes on the last block of the last user message with array
+        // content (real CC does this). When that block is a per-request
+        // `<router-state>` tail (opencode-model-router's turn state, never
+        // persisted, so a breakpoint on it writes an entry the next request
+        // cannot read), it walks back to the nearest earlier eligible block:
+        // the rest of that message, then earlier messages of any role, newest
+        // first, including assistant messages. The walk-back skips thinking,
+        // redacted_thinking, blank text and other router-state blocks, so the
+        // guard above still holds; earlier string content is normalized to one
+        // text block. With no eligible block, no message breakpoint is placed.
+        placeMessageBreakpoint(parsed.messages, { type: "ephemeral", ttl: ccTtl });
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "license": "GPL-3.0-or-later",
   "repository": {
     "type": "git",