opencode-anthropic-fix 0.1.31 → 0.2.0

package/lib/mimicry/request-body.test.mjs

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { CORE_TOOL_NAMES, transformRequestBody } from "./request-body.mjs";
+
+describe("request body mimicry", () => {
+  it("exports core tools and renames opencode tool names", () => {
+    expect(CORE_TOOL_NAMES).toBeInstanceOf(Set);
+    expect(CORE_TOOL_NAMES.has("Bash")).toBe(true);
+    expect(CORE_TOOL_NAMES.has("Read")).toBe(true);
+    expect(CORE_TOOL_NAMES.has("Task")).toBe(true);
+
+    const body = {
+      model: "claude-opus-4-1",
+      max_tokens: 8000,
+      system: [{ type: "text", text: "You are opencode" }],
+      messages: [{ role: "user", content: "hi" }],
+      tools: [{ name: "bash", description: "run", input_schema: { type: "object" } }],
+    };
+    const signature = { enabled: false };
+    const runtime = {
+      turns: 1,
+      usedTools: new Set(),
+      tokenEconomySession: null,
+      cacheBoundaryStability: new Map(),
+      persistentUserId: "d",
+      accountId: "a",
+      sessionId: "s",
+    };
+
+    const result = transformRequestBody(JSON.stringify(body), signature, runtime, "oauth-2025-04-20", {});
+
+    expect(typeof result).toBe("string");
+    expect(JSON.parse(result).tools[0].name).toBe("Bash");
+  });
+});

package/lib/mimicry/request-helpers.mjs

@@ -0,0 +1,243 @@
+// ---------------------------------------------------------------------------
+// Request-body mimicry helpers (W3·P3.1)
+// ---------------------------------------------------------------------------
+//
+// Leaf helpers used by transformRequestBody, extracted from index.mjs so the
+// orchestrator can become a thin importer. All are pure except resolveMaxTokens,
+// which reads/writes the shared sessionMetrics.lastStopReason singleton.
+
+import { sessionMetrics } from "../session-metrics.mjs";
+
+/**
+ * Ensure every assistant tool_use block has a matching tool_result in the next
+ * user message; synthesize placeholders for interrupted/orphaned tool calls so
+ * the API never rejects the conversation for unbalanced tool blocks.
+ * @param {any[]} messages
+ * @returns {any[]}
+ */
+export 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;
+}
+
+/**
+ * Strip internal `/anthropic` slash-command messages and their `▣ Anthropic`
+ * responses from the conversation before it is sent upstream.
+ * @param {any[]} messages
+ * @returns {any[]}
+ */
+export function stripSlashCommandMessages(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return messages;
+
+  // Pattern: /anthropic followed by optional subcommand
+  const CMD_RE = /^\s*\/anthropic\b/i;
+  // Pattern: ▣ Anthropic — prefix used by all sendCommandMessage outputs
+  const RESP_RE = /^▣\s*Anthropic/;
+
+  /**
+   * Extract the first text content from a message's content field.
+   * Handles both string content and array-of-blocks content.
+   */
+  function getFirstText(msg) {
+    if (typeof msg.content === "string") return msg.content;
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "text" && typeof block.text === "string") return block.text;
+      }
+    }
+    return "";
+  }
+
+  /**
+   * Check if a user message is a /anthropic command.
+   * A message is a command if its text content starts with /anthropic.
+   */
+  function isCommandMessage(msg) {
+    if (msg.role !== "user") return false;
+    const text = getFirstText(msg);
+    return CMD_RE.test(text);
+  }
+
+  /**
+   * Check if an assistant message is a sendCommandMessage response.
+   * These always start with ▣ Anthropic.
+   */
+  function isCommandResponse(msg) {
+    if (msg.role !== "assistant") return false;
+    const text = getFirstText(msg);
+    return RESP_RE.test(text);
+  }
+
+  const filtered = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+
+    // Drop /anthropic command messages
+    if (isCommandMessage(msg)) {
+      // Also drop the immediately following assistant response if it's a command response
+      if (i + 1 < messages.length && isCommandResponse(messages[i + 1])) {
+        i++; // Skip the response too
+      }
+      continue;
+    }
+
+    // Drop orphaned command responses (in case the command message was already removed
+    // or the ordering is different)
+    if (isCommandResponse(msg)) {
+      continue;
+    }
+
+    filtered.push(msg);
+  }
+
+  // Safety: if filtering removed ALL messages, return the original to avoid sending
+  // an empty messages array to the API.
+  if (filtered.length === 0) return messages;
+
+  return filtered;
+}
+
+/**
+ * Return the first user message's text (string or first text block), or "".
+ * @param {any[]} messages
+ * @returns {string}
+ */
+export function extractFirstUserMessageText(messages) {
+  if (!Array.isArray(messages)) return "";
+  for (const msg of messages) {
+    if (msg.role !== "user") continue;
+    if (typeof msg.content === "string") return msg.content;
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "text" && typeof block.text === "string") return block.text;
+      }
+    }
+    return "";
+  }
+  return "";
+}
+
+/**
+ * Build the request `metadata` field mimicking Claude Code's user_id envelope.
+ * Honors OPENCODE_ANTHROPIC_SIGNATURE_USER_ID (raw override) and merges
+ * CLAUDE_CODE_EXTRA_METADATA (JSON object) into the encoded user_id.
+ * @param {{persistentUserId: string, accountId: string, sessionId: string}} input
+ * @returns {{user_id: string}}
+ */
+export function buildRequestMetadata(input) {
+  // Backward-compat override: raw user_id passed through without JSON-encoding.
+  const envUserId = process.env.OPENCODE_ANTHROPIC_SIGNATURE_USER_ID?.trim();
+  if (envUserId) return { user_id: envUserId };
+
+  const extraMetadataEnv = process.env.CLAUDE_CODE_EXTRA_METADATA?.trim();
+  let extraMetadata = {};
+  if (extraMetadataEnv) {
+    try {
+      const parsed = JSON.parse(extraMetadataEnv);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        extraMetadata = parsed;
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+
+  return {
+    user_id: JSON.stringify({
+      ...extraMetadata,
+      device_id: input.persistentUserId,
+      account_uuid: input.accountId,
+      session_id: input.sessionId,
+    }),
+  };
+}
+
+/**
+ * Resolve the outgoing max_tokens honoring the output_cap config and a
+ * one-turn escalation when the previous stream stopped on max_tokens.
+ * Reads/writes the shared sessionMetrics.lastStopReason singleton.
+ * @param {{max_tokens?: number}} body
+ * @param {any} config
+ * @returns {number|undefined}
+ */
+export function resolveMaxTokens(body, config) {
+  if (!config.output_cap?.enabled) return body.max_tokens; // passthrough
+  if (body.max_tokens != null) return body.max_tokens; // caller-specified wins
+  // QA note L-escalation: lastStopReason is set by extractUsageFromSSEEvent AFTER the stream
+  // completes. The timing works correctly for "escalate for one turn" because this function runs
+  // BEFORE the next request's stream starts. If the response pipeline changes to update stop
+  // reason mid-stream or before response completion, this ordering assumption would break.
+  const escalated = sessionMetrics.lastStopReason === "max_tokens";
+  const result = escalated
+    ? (config.output_cap.escalated_max_tokens ?? 64_000)
+    : (config.output_cap.default_max_tokens ?? 8_000);
+  // Reset after escalation is consumed (sticky for exactly one turn)
+  if (escalated) {
+    sessionMetrics.lastStopReason = null;
+  }
+  return result;
+}

package/lib/mimicry/request-helpers.test.mjs

@@ -0,0 +1,155 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  repairOrphanedToolUseBlocks,
+  stripSlashCommandMessages,
+  extractFirstUserMessageText,
+  buildRequestMetadata,
+  resolveMaxTokens,
+} from "./request-helpers.mjs";
+import { sessionMetrics } from "../session-metrics.mjs";
+
+describe("repairOrphanedToolUseBlocks", () => {
+  it("injects placeholder tool_result into the following user message when missing", () => {
+    const messages = [
+      { role: "assistant", content: [{ type: "tool_use", id: "t1", name: "Read", input: {} }] },
+      { role: "user", content: [{ type: "text", text: "no result here" }] },
+    ];
+    const out = repairOrphanedToolUseBlocks(messages);
+    const userBlocks = out[1].content;
+    expect(userBlocks[0]).toMatchObject({ type: "tool_result", tool_use_id: "t1" });
+    expect(userBlocks[0].content).toContain("interrupted");
+    // original text block preserved after the injected result
+    expect(userBlocks.some((b) => b.type === "text")).toBe(true);
+  });
+
+  it("synthesizes a user tool_result message when the assistant is the last message", () => {
+    const messages = [{ role: "assistant", content: [{ type: "tool_use", id: "t9", name: "Bash", input: {} }] }];
+    const out = repairOrphanedToolUseBlocks(messages);
+    expect(out).toHaveLength(2);
+    expect(out[1]).toMatchObject({ role: "user" });
+    expect(out[1].content[0]).toMatchObject({ type: "tool_result", tool_use_id: "t9" });
+  });
+
+  it("leaves already-paired tool_use/tool_result untouched", () => {
+    const messages = [
+      { role: "assistant", content: [{ type: "tool_use", id: "t1", name: "Read", input: {} }] },
+      { role: "user", content: [{ type: "tool_result", tool_use_id: "t1", content: "ok" }] },
+    ];
+    const out = repairOrphanedToolUseBlocks(messages);
+    expect(out).toEqual(messages);
+  });
+
+  it("passes non-array / empty through", () => {
+    expect(repairOrphanedToolUseBlocks([])).toEqual([]);
+    expect(repairOrphanedToolUseBlocks(null)).toBe(null);
+  });
+});
+
+describe("stripSlashCommandMessages", () => {
+  it("drops a /anthropic command and its ▣ Anthropic response", () => {
+    const messages = [
+      { role: "user", content: "/anthropic status" },
+      { role: "assistant", content: "▣ Anthropic — account 1 active" },
+      { role: "user", content: "real question" },
+    ];
+    const out = stripSlashCommandMessages(messages);
+    expect(out).toEqual([{ role: "user", content: "real question" }]);
+  });
+
+  it("drops orphaned ▣ Anthropic responses", () => {
+    const messages = [
+      { role: "assistant", content: [{ type: "text", text: "▣ Anthropic done" }] },
+      { role: "user", content: "hi" },
+    ];
+    const out = stripSlashCommandMessages(messages);
+    expect(out).toEqual([{ role: "user", content: "hi" }]);
+  });
+
+  it("returns the original array when filtering would remove everything", () => {
+    const messages = [{ role: "user", content: "/anthropic login" }];
+    expect(stripSlashCommandMessages(messages)).toBe(messages);
+  });
+});
+
+describe("extractFirstUserMessageText", () => {
+  it("returns string content of the first user message", () => {
+    expect(extractFirstUserMessageText([{ role: "user", content: "hello" }])).toBe("hello");
+  });
+
+  it("returns first text block for array content", () => {
+    expect(
+      extractFirstUserMessageText([
+        { role: "assistant", content: "ignored" },
+        { role: "user", content: [{ type: "image" }, { type: "text", text: "found" }] },
+      ]),
+    ).toBe("found");
+  });
+
+  it("returns empty string when no user message", () => {
+    expect(extractFirstUserMessageText([{ role: "assistant", content: "x" }])).toBe("");
+    expect(extractFirstUserMessageText(null)).toBe("");
+  });
+});
+
+describe("buildRequestMetadata", () => {
+  const ORIG = { ...process.env };
+  beforeEach(() => {
+    delete process.env.OPENCODE_ANTHROPIC_SIGNATURE_USER_ID;
+    delete process.env.CLAUDE_CODE_EXTRA_METADATA;
+    process.env = { ...ORIG };
+    delete process.env.OPENCODE_ANTHROPIC_SIGNATURE_USER_ID;
+    delete process.env.CLAUDE_CODE_EXTRA_METADATA;
+  });
+
+  it("encodes device/account/session ids as JSON user_id", () => {
+    const md = buildRequestMetadata({ persistentUserId: "dev", accountId: "acct", sessionId: "sess" });
+    expect(JSON.parse(md.user_id)).toEqual({ device_id: "dev", account_uuid: "acct", session_id: "sess" });
+  });
+
+  it("honors the raw OPENCODE_ANTHROPIC_SIGNATURE_USER_ID override verbatim", () => {
+    process.env.OPENCODE_ANTHROPIC_SIGNATURE_USER_ID = "raw-id";
+    expect(buildRequestMetadata({ persistentUserId: "d", accountId: "a", sessionId: "s" })).toEqual({
+      user_id: "raw-id",
+    });
+  });
+
+  it("merges CLAUDE_CODE_EXTRA_METADATA object into the encoded user_id", () => {
+    process.env.CLAUDE_CODE_EXTRA_METADATA = JSON.stringify({ org: "acme" });
+    const md = buildRequestMetadata({ persistentUserId: "d", accountId: "a", sessionId: "s" });
+    expect(JSON.parse(md.user_id)).toMatchObject({ org: "acme", device_id: "d" });
+  });
+
+  it("ignores malformed extra metadata JSON", () => {
+    process.env.CLAUDE_CODE_EXTRA_METADATA = "{not json";
+    const md = buildRequestMetadata({ persistentUserId: "d", accountId: "a", sessionId: "s" });
+    expect(JSON.parse(md.user_id)).toEqual({ device_id: "d", account_uuid: "a", session_id: "s" });
+  });
+});
+
+describe("resolveMaxTokens", () => {
+  beforeEach(() => {
+    sessionMetrics.lastStopReason = null;
+  });
+
+  it("passes through when output_cap disabled", () => {
+    expect(resolveMaxTokens({ max_tokens: 123 }, {})).toBe(123);
+  });
+
+  it("honors caller-specified max_tokens even when cap enabled", () => {
+    expect(resolveMaxTokens({ max_tokens: 500 }, { output_cap: { enabled: true } })).toBe(500);
+  });
+
+  it("uses default_max_tokens when unset and not escalating", () => {
+    expect(resolveMaxTokens({}, { output_cap: { enabled: true, default_max_tokens: 8000 } })).toBe(8000);
+    expect(resolveMaxTokens({}, { output_cap: { enabled: true } })).toBe(8000);
+  });
+
+  it("escalates for exactly one turn after a max_tokens stop, then resets", () => {
+    sessionMetrics.lastStopReason = "max_tokens";
+    const cfg = { output_cap: { enabled: true, default_max_tokens: 8000, escalated_max_tokens: 64000 } };
+    expect(resolveMaxTokens({}, cfg)).toBe(64000);
+    // sticky for one turn only
+    expect(sessionMetrics.lastStopReason).toBe(null);
+    expect(resolveMaxTokens({}, cfg)).toBe(8000);
+  });
+});