@vacbo/opencode-anthropic-fix 0.0.44 → 0.1.1

package/src/request/body.ts

@@ -2,39 +2,222 @@
 // Request body transformation
 // ---------------------------------------------------------------------------
 
+import { CLAUDE_CODE_IDENTITY_STRING, KNOWN_IDENTITY_STRINGS } from "../constants.js";
 import { buildSystemPromptBlocks } from "../system-prompt/builder.js";
 import { normalizeSystemTextBlocks } from "../system-prompt/normalize.js";
 import { normalizeThinkingBlock } from "../thinking.js";
 import type { RuntimeContext, SignatureConfig } from "../types.js";
 import { buildRequestMetadata } from "./metadata.js";
 
+const TOOL_PREFIX = "mcp_";
+
+function getBodyType(body: unknown): string {
+  if (body === null) return "null";
+  return typeof body;
+}
+
+function getInvalidBodyError(body: unknown): TypeError {
+  return new TypeError(
+    `opencode-anthropic-auth: expected string body, got ${getBodyType(body)}. This plugin does not support stream bodies. Please file a bug with the OpenCode version.`,
+  );
+}
+
+export function validateBodyType(body: unknown, throwOnInvalid = false): body is string {
+  if (body === undefined || body === null) {
+    return false;
+  }
+
+  if (typeof body === "string") {
+    return true;
+  }
+
+  if (throwOnInvalid) {
+    throw getInvalidBodyError(body);
+  }
+
+  return false;
+}
+
+export function cloneBodyForRetry(body: string): string {
+  validateBodyType(body, true);
+  return body;
+}
+
+export function detectDoublePrefix(name: string): boolean {
+  return name.startsWith(`${TOOL_PREFIX}${TOOL_PREFIX}`);
+}
+
+export function extractToolNamesFromBody(body: string): string[] {
+  const parsed = JSON.parse(body) as {
+    tools?: Array<{ name?: unknown }>;
+    messages?: Array<{ content?: unknown }>;
+  };
+  const names: string[] = [];
+
+  if (Array.isArray(parsed.tools)) {
+    for (const tool of parsed.tools) {
+      if (typeof tool?.name === "string") {
+        names.push(tool.name);
+      }
+    }
+  }
+
+  if (Array.isArray(parsed.messages)) {
+    for (const message of parsed.messages) {
+      if (!Array.isArray(message?.content)) {
+        continue;
+      }
+
+      for (const block of message.content) {
+        if (
+          block &&
+          typeof block === "object" &&
+          "type" in block &&
+          block.type === "tool_use" &&
+          "name" in block &&
+          typeof block.name === "string"
+        ) {
+          names.push(block.name);
+        }
+      }
+    }
+  }
+
+  return names;
+}
+
+function prefixToolDefinitionName(name: unknown): unknown {
+  if (typeof name !== "string") {
+    return name;
+  }
+
+  if (detectDoublePrefix(name)) {
+    throw new TypeError(`Double tool prefix detected: ${TOOL_PREFIX}${TOOL_PREFIX}`);
+  }
+
+  return `${TOOL_PREFIX}${name}`;
+}
+
+function prefixToolUseName(
+  name: unknown,
+  literalToolNames: ReadonlySet<string>,
+  debugLog?: (...args: unknown[]) => void,
+): unknown {
+  if (typeof name !== "string") {
+    return name;
+  }
+
+  if (detectDoublePrefix(name)) {
+    throw new TypeError(`Double tool prefix detected in tool_use block: ${name}`);
+  }
+
+  if (!name.startsWith(TOOL_PREFIX)) {
+    return `${TOOL_PREFIX}${name}`;
+  }
+
+  if (literalToolNames.has(name)) {
+    return `${TOOL_PREFIX}${name}`;
+  }
+
+  debugLog?.("prevented double-prefix drift for tool_use block", { name });
+  return name;
+}
+
 export function transformRequestBody(
   body: string | undefined,
   signature: SignatureConfig,
   runtime: RuntimeContext,
+  relocateThirdPartyPrompts = true,
+  debugLog?: (...args: unknown[]) => void,
 ): string | undefined {
-  if (!body || typeof body !== "string") return body;
-
-  const TOOL_PREFIX = "mcp_";
+  if (body === undefined || body === null) return body;
+  validateBodyType(body, true);
 
   try {
-    const parsed = JSON.parse(body);
+    const parsed = JSON.parse(body) as Record<string, unknown> & {
+      tools?: Array<Record<string, unknown>>;
+      messages?: Array<Record<string, unknown>>;
+      thinking?: unknown;
+      model?: string;
+      metadata?: Record<string, unknown>;
+      system?: unknown[] | undefined;
+    };
+    const parsedMessages = Array.isArray(parsed.messages) ? parsed.messages : [];
+    const literalToolNames = new Set<string>(
+      Array.isArray(parsed.tools)
+        ? parsed.tools
+            .map((tool: Record<string, unknown>) => tool.name)
+            .filter((name: unknown): name is string => typeof name === "string")
+        : [],
+    );
+
     if (Object.hasOwn(parsed, "betas")) {
       delete parsed.betas;
     }
     // Normalize thinking block for adaptive (Opus 4.6) vs manual (older models).
     if (Object.hasOwn(parsed, "thinking")) {
-      parsed.thinking = normalizeThinkingBlock(parsed.thinking, parsed.model || "");
+      parsed.thinking = normalizeThinkingBlock(parsed.thinking as unknown, parsed.model || "");
     }
-    const hasThinking = parsed.thinking && typeof parsed.thinking === "object" && parsed.thinking.type === "enabled";
+    const hasThinking =
+      parsed.thinking &&
+      typeof parsed.thinking === "object" &&
+      (parsed.thinking as { type?: string }).type === "enabled";
     if (hasThinking) {
       delete parsed.temperature;
     } else if (!Object.hasOwn(parsed, "temperature")) {
       parsed.temperature = 1;
     }
 
-    // Sanitize system prompt and optionally inject Claude Code identity/billing blocks.
-    parsed.system = buildSystemPromptBlocks(normalizeSystemTextBlocks(parsed.system), signature, parsed.messages);
+    // Sanitize system prompt and inject Claude Code identity/billing blocks.
+    const allSystemBlocks = buildSystemPromptBlocks(
+      normalizeSystemTextBlocks(parsed.system),
+      signature,
+      parsedMessages,
+    );
+
+    if (signature.enabled && relocateThirdPartyPrompts) {
+      // Keep CC blocks in system. Move blocks with third-party identifiers
+      // into messages to avoid system prompt content detection.
+      const THIRD_PARTY_MARKERS =
+        /sisyphus|ohmyclaude|oh\s*my\s*claude|morph[_ ]|\.sisyphus\/|ultrawork|autopilot mode|\bohmy\b|SwarmMode|\bomc\b|\bomo\b/i;
+
+      const ccBlocks: typeof allSystemBlocks = [];
+      const extraBlocks: typeof allSystemBlocks = [];
+      for (const block of allSystemBlocks) {
+        const isBilling = block.text.startsWith("x-anthropic-billing-header:");
+        const isIdentity = block.text === CLAUDE_CODE_IDENTITY_STRING || KNOWN_IDENTITY_STRINGS.has(block.text);
+        const hasThirdParty = THIRD_PARTY_MARKERS.test(block.text);
+
+        if (isBilling || isIdentity || !hasThirdParty) {
+          ccBlocks.push(block);
+        } else {
+          extraBlocks.push(block);
+        }
+      }
+      parsed.system = ccBlocks;
+
+      // Inject extra blocks as <system-instructions> in the first user message
+      if (extraBlocks.length > 0 && Array.isArray(parsed.messages) && parsed.messages.length > 0) {
+        const extraText = extraBlocks.map((b) => b.text).join("\n\n");
+        const wrapped = `<system-instructions>\n${extraText}\n</system-instructions>`;
+        const firstMsg = parsed.messages[0];
+        if (firstMsg && firstMsg.role === "user") {
+          if (typeof firstMsg.content === "string") {
+            firstMsg.content = `${wrapped}\n\n${firstMsg.content}`;
+          } else if (Array.isArray(firstMsg.content)) {
+            firstMsg.content.unshift({ type: "text", text: wrapped });
+          }
+        } else {
+          // No user message first — prepend a new user message
+          parsed.messages.unshift({
+            role: "user",
+            content: wrapped,
+          });
+        }
+      }
+    } else {
+      parsed.system = allSystemBlocks;
+    }
 
     if (signature.enabled) {
       const currentMetadata =
@@ -55,7 +238,7 @@ export function transformRequestBody(
     if (parsed.tools && Array.isArray(parsed.tools)) {
       parsed.tools = parsed.tools.map((tool: Record<string, unknown>) => ({
         ...tool,
-        name: tool.name ? `${TOOL_PREFIX}${tool.name}` : tool.name,
+        name: prefixToolDefinitionName(tool.name),
       }));
     }
     // Add prefix to tool_use blocks in messages
@@ -66,7 +249,7 @@ export function transformRequestBody(
             if (block.type === "tool_use" && block.name) {
               return {
                 ...block,
-                name: `${TOOL_PREFIX}${block.name}`,
+                name: prefixToolUseName(block.name, literalToolNames, debugLog),
               };
             }
             return block;
@@ -76,8 +259,12 @@ export function transformRequestBody(
       });
     }
     return JSON.stringify(parsed);
-  } catch {
-    // ignore parse errors
-    return body;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      debugLog?.("body parse failed:", err.message);
+      return body;
+    }
+
+    throw err;
   }
 }

package/src/request/metadata.ts

@@ -38,7 +38,10 @@ export function extractFileIds(parsed: unknown): string[] {
   return ids;
 }
 
-export function parseRequestBodyMetadata(body: string | undefined): RequestBodyMetadata {
+export function parseRequestBodyMetadata(
+  body: string | undefined,
+  debugLog?: (...args: unknown[]) => void,
+): RequestBodyMetadata {
   if (!body || typeof body !== "string") {
     return { model: "", tools: [], messages: [], hasFileReferences: false };
   }
@@ -50,7 +53,8 @@ export function parseRequestBodyMetadata(body: string | undefined): RequestBodyM
     const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
     const hasFileReferences = extractFileIds(parsed).length > 0;
     return { model, tools, messages, hasFileReferences };
-  } catch {
+  } catch (err) {
+    debugLog?.("extractFileIds failed:", (err as Error).message);
     return { model: "", tools: [], messages: [], hasFileReferences: false };
   }
 }

package/src/response/index.ts

@@ -1,4 +1,4 @@
-export { stripMcpPrefixFromParsedEvent, stripMcpPrefixFromSSE } from "./mcp.js";
+export { stripMcpPrefixFromJsonBody, stripMcpPrefixFromParsedEvent, stripMcpPrefixFromSSE } from "./mcp.js";
 export {
   extractUsageFromSSEEvent,
   getMidStreamAccountError,

package/src/response/mcp.ts

@@ -21,6 +21,45 @@ export function stripMcpPrefixFromSSE(text: string): string {
   });
 }
 
+function stripMcpPrefixFromToolUseBlock(block: unknown): boolean {
+  if (!block || typeof block !== "object") return false;
+
+  const parsedBlock = block as Record<string, unknown>;
+  if (parsedBlock.type !== "tool_use" || typeof parsedBlock.name !== "string") {
+    return false;
+  }
+
+  if (!parsedBlock.name.startsWith("mcp_")) {
+    return false;
+  }
+
+  parsedBlock.name = parsedBlock.name.slice(4);
+  return true;
+}
+
+function stripMcpPrefixFromContentBlocks(content: unknown): boolean {
+  if (!Array.isArray(content)) return false;
+
+  let modified = false;
+  for (const block of content) {
+    modified = stripMcpPrefixFromToolUseBlock(block) || modified;
+  }
+
+  return modified;
+}
+
+function stripMcpPrefixFromMessages(messages: unknown): boolean {
+  if (!Array.isArray(messages)) return false;
+
+  let modified = false;
+  for (const message of messages) {
+    if (!message || typeof message !== "object") continue;
+    modified = stripMcpPrefixFromContentBlocks((message as Record<string, unknown>).content) || modified;
+  }
+
+  return modified;
+}
+
 /**
  * Mutate a parsed SSE event object, removing `mcp_` prefix from tool_use
  * name fields. Returns true if any modification was made.
@@ -32,42 +71,32 @@ export function stripMcpPrefixFromParsedEvent(parsed: unknown): boolean {
   let modified = false;
 
   // content_block_start: { content_block: { type: "tool_use", name: "mcp_..." } }
-  if (
-    p.content_block &&
-    typeof p.content_block === "object" &&
-    (p.content_block as Record<string, unknown>).type === "tool_use" &&
-    typeof (p.content_block as Record<string, unknown>).name === "string" &&
-    ((p.content_block as Record<string, unknown>).name as string).startsWith("mcp_")
-  ) {
-    (p.content_block as Record<string, unknown>).name = (
-      (p.content_block as Record<string, unknown>).name as string
-    ).slice(4);
-    modified = true;
-  }
+  modified = stripMcpPrefixFromToolUseBlock(p.content_block) || modified;
 
   // message_start: { message: { content: [{ type: "tool_use", name: "mcp_..." }] } }
-  if (p.message && Array.isArray((p.message as Record<string, unknown>).content)) {
-    for (const block of (p.message as Record<string, unknown>).content as unknown[]) {
-      if (!block || typeof block !== "object") continue;
-      const b = block as Record<string, unknown>;
-      if (b.type === "tool_use" && typeof b.name === "string" && b.name.startsWith("mcp_")) {
-        b.name = b.name.slice(4);
-        modified = true;
-      }
-    }
+  if (p.message && typeof p.message === "object") {
+    modified = stripMcpPrefixFromContentBlocks((p.message as Record<string, unknown>).content) || modified;
   }
 
   // Top-level content array (non-streaming responses forwarded through SSE)
-  if (Array.isArray(p.content)) {
-    for (const block of p.content) {
-      if (!block || typeof block !== "object") continue;
-      const b = block as Record<string, unknown>;
-      if (b.type === "tool_use" && typeof b.name === "string" && b.name.startsWith("mcp_")) {
-        b.name = b.name.slice(4);
-        modified = true;
-      }
-    }
-  }
+  modified = stripMcpPrefixFromContentBlocks(p.content) || modified;
 
   return modified;
 }
+
+export function stripMcpPrefixFromJsonBody(body: string): string {
+  try {
+    const parsed = JSON.parse(body) as Record<string, unknown>;
+    let modified = false;
+
+    modified = stripMcpPrefixFromContentBlocks(parsed.content) || modified;
+    modified = stripMcpPrefixFromMessages(parsed.messages) || modified;
+    if (parsed.message && typeof parsed.message === "object") {
+      modified = stripMcpPrefixFromContentBlocks((parsed.message as Record<string, unknown>).content) || modified;
+    }
+
+    return modified ? JSON.stringify(parsed) : body;
+  } catch {
+    return body;
+  }
+}