opencode-anthropic-fix 0.2.1 → 0.3.0

package/lib/mimicry/models.test.mjs

@@ -1,132 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import {
-  CLAUDE_3_MODEL_RE,
-  hasOneMillionContext,
-  isAdaptiveThinkingModel,
-  isEligibleFor1MContext,
-  isFable5Model,
-  isMythos5Model,
-  isOpus46Model,
-  isOpus47Model,
-  isOpus48Model,
-  isSonnet46Model,
-  normalizeThinkingBlock,
-} from "./models.mjs";
-
-afterEach(() => {
-  vi.unstubAllEnvs();
-});
-
-describe("model detection", () => {
-  it("detects Claude 3 model IDs", () => {
-    expect(CLAUDE_3_MODEL_RE.test("claude-3-5-sonnet-20241022")).toBe(true);
-    expect(CLAUDE_3_MODEL_RE.test("claude-sonnet-4-6")).toBe(false);
-  });
-
-  it("detects Opus 4.6 model IDs", () => {
-    expect(isOpus46Model("claude-opus-4-6-20260205")).toBe(true);
-    expect(isOpus46Model("arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-opus-4.6-v1")).toBe(true);
-    expect(isOpus46Model("claude-opus-4-7")).toBe(false);
-  });
-
-  it("detects Opus 4.7 model IDs", () => {
-    expect(isOpus47Model("claude-opus-4.7")).toBe(true);
-    expect(isOpus47Model("opus_4_7-eap")).toBe(true);
-    expect(isOpus47Model("claude-opus-4-8")).toBe(false);
-  });
-
-  it("detects Opus 4.8 model IDs", () => {
-    expect(isOpus48Model("claude-opus-4-8")).toBe(true);
-    expect(isOpus48Model("opus.4.8-fast")).toBe(true);
-    expect(isOpus48Model("claude-opus-4-7")).toBe(false);
-  });
-
-  it("detects Sonnet 4.6 model IDs", () => {
-    expect(isSonnet46Model("claude-sonnet-4-6")).toBe(true);
-    expect(isSonnet46Model("sonnet.4.6")).toBe(true);
-    expect(isSonnet46Model("claude-sonnet-4-5")).toBe(false);
-  });
-
-  it("detects 1M-context eligibility and explicit context markers", () => {
-    expect(isEligibleFor1MContext("claude-sonnet-4-5")).toBe(true);
-    expect(isEligibleFor1MContext("claude-opus-4-6[1m]")).toBe(true);
-    expect(hasOneMillionContext("claude-opus-4-6-1m")).toBe(true);
-    expect(hasOneMillionContext("claude-opus-4-6[1m]")).toBe(false);
-    expect(hasOneMillionContext("claude-opus-4-6")).toBe(false);
-  });
-
-  it("detects Fable 5 model IDs", () => {
-    expect(isFable5Model("claude-fable-5")).toBe(true);
-    expect(isFable5Model("fable_5-preview")).toBe(true);
-    expect(isFable5Model("claude-mythos-5")).toBe(false);
-  });
-
-  it("detects Mythos 5 model IDs", () => {
-    expect(isMythos5Model("claude-mythos-5")).toBe(true);
-    expect(isMythos5Model("mythos.5-preview")).toBe(true);
-    expect(isMythos5Model("claude-fable-5")).toBe(false);
-  });
-
-  it.each([
-    "claude-opus-4-6",
-    "claude-opus-4-7",
-    "claude-opus-4-8",
-    "claude-sonnet-4-6",
-    "claude-fable-5",
-    "claude-mythos-5",
-  ])("recognizes %s as an adaptive-thinking model", (model) => {
-    expect(isAdaptiveThinkingModel(model)).toBe(true);
-  });
-
-  it("rejects non-adaptive models", () => {
-    expect(isAdaptiveThinkingModel("claude-sonnet-4-5")).toBe(false);
-    expect(isAdaptiveThinkingModel(undefined)).toBe(false);
-  });
-});
-
-describe("normalizeThinkingBlock", () => {
-  it("passes absent and non-object values through", () => {
-    expect(normalizeThinkingBlock(undefined, "claude-opus-4-8")).toBeUndefined();
-    expect(normalizeThinkingBlock("enabled", "claude-opus-4-8")).toBe("enabled");
-  });
-
-  it("passes a non-adaptive model's block through unchanged", () => {
-    const thinking = { type: "enabled", budget_tokens: 8000 };
-
-    expect(normalizeThinkingBlock(thinking, "claude-sonnet-4-5")).toBe(thinking);
-  });
-
-  it("normalizes adaptive models to adaptive thinking", () => {
-    expect(normalizeThinkingBlock({ type: "enabled", budget_tokens: 8000 }, "claude-opus-4-8")).toEqual({
-      type: "adaptive",
-    });
-  });
-
-  it("preserves an enabled block when adaptive thinking is disabled", () => {
-    vi.stubEnv("OPENCODE_ANTHROPIC_DISABLE_ADAPTIVE_THINKING", "1");
-    const thinking = { type: "enabled", budget_tokens: 12000 };
-
-    expect(normalizeThinkingBlock(thinking, "claude-opus-4-8")).toBe(thinking);
-  });
-
-  it("uses the configured fallback budget when adaptive thinking is disabled", () => {
-    vi.stubEnv("OPENCODE_ANTHROPIC_DISABLE_ADAPTIVE_THINKING", "true");
-    vi.stubEnv("MAX_THINKING_TOKENS", "24000");
-
-    expect(normalizeThinkingBlock({ type: "adaptive" }, "claude-sonnet-4-6")).toEqual({
-      type: "enabled",
-      budget_tokens: 24000,
-    });
-  });
-
-  it("uses the default fallback budget when the configured value is invalid", () => {
-    vi.stubEnv("OPENCODE_ANTHROPIC_DISABLE_ADAPTIVE_THINKING", "yes");
-    vi.stubEnv("MAX_THINKING_TOKENS", "invalid");
-
-    expect(normalizeThinkingBlock({}, "claude-fable-5")).toEqual({
-      type: "enabled",
-      budget_tokens: 16000,
-    });
-  });
-});

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

@@ -1,34 +0,0 @@
-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.test.mjs

@@ -1,155 +0,0 @@
-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);
-  });
-});

package/lib/mimicry/response-stream.test.mjs

@@ -1,127 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-  createTransformedSSEStream,
-  extractUsageFromSSEEvent,
-  getMidStreamAccountError,
-  getSSEDataPayload,
-  resolveStreamIdleTimeoutMs,
-  stripMcpPrefixFromParsedEvent,
-} from "./response-stream.mjs";
-
-describe("response stream mimicry", () => {
-  afterEach(() => {
-    delete process.env.OPENCODE_ANTHROPIC_STREAM_IDLE_TIMEOUT_MS;
-  });
-
-  it("reverse-maps tool names in every supported tool_use location", () => {
-    const parsed = {
-      type: "message_start",
-      content_block: { type: "tool_use", name: "mcp_write_file" },
-      message: {
-        content: [
-          { type: "tool_use", name: "Bash" },
-          { type: "text", text: "call mcp_write_file", name: "mcp_keep_me" },
-        ],
-      },
-      content: [{ type: "tool_use", name: "WebFetch" }],
-    };
-
-    expect(stripMcpPrefixFromParsedEvent(parsed)).toBe(true);
-    expect(parsed.content_block.name).toBe("write_file");
-    expect(parsed.message.content[0].name).toBe("bash");
-    expect(parsed.message.content[1]).toEqual({ type: "text", text: "call mcp_write_file", name: "mcp_keep_me" });
-    expect(parsed.content[0].name).toBe("webfetch");
-  });
-
-  it("combines multiline data payloads and ignores the done sentinel", () => {
-    expect(getSSEDataPayload("event: message\ndata: first\ndata:  second")).toBe("first\n second");
-    expect(getSSEDataPayload("data: [DONE]")).toBeNull();
-  });
-
-  it("extracts final usage and stop reason from message_delta", () => {
-    const stats = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
-
-    extractUsageFromSSEEvent(
-      {
-        type: "message_delta",
-        delta: { stop_reason: "max_tokens" },
-        usage: {
-          input_tokens: 11,
-          output_tokens: 7,
-          cache_read_input_tokens: 5,
-          cache_creation_input_tokens: 3,
-          server_tool_use: { web_search_requests: 2 },
-        },
-      },
-      stats,
-    );
-
-    expect(stats).toEqual({
-      inputTokens: 11,
-      outputTokens: 7,
-      cacheReadTokens: 5,
-      cacheWriteTokens: 3,
-      webSearchRequests: 2,
-      lastStopReason: "max_tokens",
-    });
-  });
-
-  it("identifies an account-specific mid-stream authentication error", () => {
-    expect(
-      getMidStreamAccountError({
-        type: "error",
-        error: { type: "authentication_error", message: "invalid bearer token" },
-      }),
-    ).toEqual({ reason: "AUTH_FAILED", invalidateToken: true });
-  });
-
-  it("resolves idle timeout from env, config, then the disabled default", () => {
-    expect(resolveStreamIdleTimeoutMs({ streaming: { idle_timeout_ms: 1234.9 } })).toBe(1234);
-    expect(resolveStreamIdleTimeoutMs({})).toBe(0);
-
-    process.env.OPENCODE_ANTHROPIC_STREAM_IDLE_TIMEOUT_MS = "456.8";
-    expect(resolveStreamIdleTimeoutMs({ streaming: { idle_timeout_ms: 1234 } })).toBe(456);
-  });
-
-  it("round-trips thinking bytes, rewrites tool names, and reports final usage", async () => {
-    const thinkingFrame =
-      'data: {"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"consider mcp_write_file carefully"}}\n\n';
-    const toolFrame =
-      'data: {"type":"content_block_start","content_block":{"type":"tool_use","name":"mcp_write_file","id":"t1"}}\n\n';
-    const usageFrame =
-      'data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input_tokens":4,"output_tokens":2,"cache_read_input_tokens":1,"cache_creation_input_tokens":0}}\n\n';
-    const encoder = new TextEncoder();
-    const response = new Response(
-      new ReadableStream({
-        start(controller) {
-          controller.enqueue(encoder.encode(thinkingFrame.slice(0, 47)));
-          controller.enqueue(encoder.encode(thinkingFrame.slice(47) + toolFrame + usageFrame));
-          controller.close();
-        },
-      }),
-    );
-    const onUsage = vi.fn();
-    const stream = createTransformedSSEStream(response, {
-      onUsage,
-      onAccountError: null,
-      correlationId: undefined,
-      idleTimeoutMs: 0,
-      captureEnabled: false,
-      writeSseCapture: vi.fn(),
-    });
-
-    const output = await new Response(stream).text();
-
-    expect(output.startsWith(thinkingFrame)).toBe(true);
-    expect(output).toContain('"name":"write_file"');
-    expect(output).not.toContain('"name":"mcp_write_file"');
-    expect(onUsage).toHaveBeenCalledOnce();
-    expect(onUsage).toHaveBeenCalledWith({
-      inputTokens: 4,
-      outputTokens: 2,
-      cacheReadTokens: 1,
-      cacheWriteTokens: 0,
-      lastStopReason: "end_turn",
-    });
-  });
-});

package/lib/mimicry/system-prompt.test.mjs

@@ -1,73 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  buildSystemPromptBlocks,
-  dedupeSystemBlocks,
-  getCacheControlForScope,
-  getCachedCCPrompt,
-  isTitleGeneratorSystemBlocks,
-  resetCachedCCPrompt,
-  sanitizeSystemText,
-  tailSystemBlock,
-} from "./system-prompt.mjs";
-
-describe("system prompt mimicry", () => {
-  it("sanitizes OpenCode branding with the existing case rules", () => {
-    expect(sanitizeSystemText("OpenCode opencode openCode opencode_helper")).toBe(
-      "Claude Code Claude Claude opencode_helper",
-    );
-  });
-
-  it("removes duplicate normalized text blocks", () => {
-    const first = { type: "text", text: "First line\nSecond line" };
-    const duplicate = { type: "text", text: " First line \r\n Second line " };
-    const unique = { type: "text", text: "Unique" };
-
-    expect(dedupeSystemBlocks([first, duplicate, unique])).toEqual([first, unique]);
-  });
-
-  it("tails a system block while retaining key constraints", () => {
-    expect(tailSystemBlock("Identity\n\ndiscard this\n# Keep\nMUST remain", 200, 3)).toBe(
-      "Identity\n\n# Keep\nMUST remain\n\n[Verbose instructions trimmed after turn 3. Key constraints preserved above.]",
-    );
-  });
-
-  it("detects title-generator system blocks", () => {
-    expect(isTitleGeneratorSystemBlocks([{ type: "text", text: "You are a title generator." }])).toBe(true);
-    expect(isTitleGeneratorSystemBlocks([{ type: "text", text: "You are a coding assistant." }])).toBe(false);
-  });
-
-  it("builds cache-control wire shapes for each scope", () => {
-    const policy = { ttl: "1h", ttl_supported: true };
-
-    expect(getCacheControlForScope("global", policy)).toEqual({ type: "ephemeral", ttl: "1h", scope: "global" });
-    expect(getCacheControlForScope("org", policy)).toEqual({ type: "ephemeral", ttl: "1h" });
-    expect(getCacheControlForScope(null, policy)).toBeNull();
-    expect(getCacheControlForScope("org", { ttl: "off", ttl_supported: true })).toEqual({ type: "ephemeral" });
-  });
-
-  it("builds system prompt blocks from a minimal prompt and signature", () => {
-    expect(
-      buildSystemPromptBlocks([{ type: "text", text: "OpenCode assistant" }], {
-        enabled: false,
-        claudeCliVersion: "2.1.0",
-        promptCompactionMode: "off",
-      }),
-    ).toEqual([{ type: "text", text: "Claude Code assistant" }]);
-  });
-
-  it("exposes cache reset and round-trip helpers", () => {
-    resetCachedCCPrompt();
-    expect(getCachedCCPrompt()).toBeNull();
-
-    buildSystemPromptBlocks([{ type: "text", text: "You are an interactive assistant." }], {
-      enabled: true,
-      claudeCliVersion: "2.1.0",
-      promptCompactionMode: "off",
-      cachePolicy: { ttl: "1h", ttl_supported: true },
-    });
-
-    expect(getCachedCCPrompt()).toBe("You are an interactive assistant.");
-    resetCachedCCPrompt();
-    expect(getCachedCCPrompt()).toBeNull();
-  });
-});