opencode-anthropic-fix 0.2.1 → 0.3.0

package/lib/context-hint-persist.mjs

@@ -1,68 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { getConfigDir } from "./config.mjs";
-
-const FLAG_FILENAME = "context-hint-disabled.flag";
-const FLAG_VERSION = 1;
-
-/**
- * @typedef {object} ContextHintFlag
- * @property {true} disabled
- * @property {string} [reason]
- * @property {number} [status]
- * @property {number} [timestamp]
- * @property {number} [version]
- */
-
-/**
- * @returns {string}
- */
-export function getContextHintFlagPath() {
-  return join(getConfigDir(), FLAG_FILENAME);
-}
-
-/**
- * @returns {{ disabled: boolean, reason?: string, status?: number, timestamp?: number }}
- */
-export function loadContextHintDisabledFlag() {
-  const p = getContextHintFlagPath();
-  if (!existsSync(p)) return { disabled: false };
-  try {
-    const raw = readFileSync(p, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed && parsed.disabled === true) {
-      return {
-        disabled: true,
-        reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
-        status: typeof parsed.status === "number" ? parsed.status : undefined,
-        timestamp: typeof parsed.timestamp === "number" ? parsed.timestamp : undefined,
-      };
-    }
-  } catch {
-    // Corrupted or unreadable — treat as not disabled.
-  }
-  return { disabled: false };
-}
-
-/**
- * Persist a permanent disable flag for the context-hint beta. Best-effort;
- * disk failures are swallowed so they never abort a session.
- * @param {{ reason: string, status: number }} params
- */
-export function saveContextHintDisabledFlag({ reason, status }) {
-  const p = getContextHintFlagPath();
-  try {
-    mkdirSync(dirname(p), { recursive: true });
-    /** @type {ContextHintFlag} */
-    const payload = {
-      disabled: true,
-      reason,
-      status,
-      timestamp: Date.now(),
-      version: FLAG_VERSION,
-    };
-    writeFileSync(p, JSON.stringify(payload, null, 2), "utf-8");
-  } catch {
-    // Best-effort.
-  }
-}

package/lib/diagnose.test.mjs

@@ -1,122 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const state = vi.hoisted(() => ({
-  accounts: null,
-  config: {},
-  configDir: "/diagnose/config",
-  debugHeadersExists: false,
-  directoryExists: false,
-  entries: [],
-  fileContents: new Map(),
-  home: "/diagnose/home",
-}));
-
-vi.mock("node:fs", () => ({
-  existsSync: vi.fn((filePath) => {
-    const value = String(filePath);
-    if (value.endsWith("debug-headers.log")) return state.debugHeadersExists;
-    if (value.endsWith("request-dumps")) return state.directoryExists;
-    return false;
-  }),
-  readFileSync: vi.fn((filePath) => {
-    const value = String(filePath);
-    if (value.endsWith("package.json")) return JSON.stringify({ version: "1.2.3-test" });
-    const file = value.split(/[\\/]/).at(-1);
-    if (!state.fileContents.has(file)) throw new Error(`Missing fixture: ${file}`);
-    return state.fileContents.get(file);
-  }),
-  readdirSync: vi.fn(() => [...state.entries]),
-  statSync: vi.fn((filePath) => {
-    const file = String(filePath).split(/[\\/]/).at(-1);
-    const contents = state.fileContents.get(file) ?? "";
-    return { size: Buffer.byteLength(contents) };
-  }),
-}));
-
-vi.mock("node:os", () => ({
-  default: { homedir: vi.fn(() => state.home) },
-}));
-
-vi.mock("./config.mjs", () => ({
-  getConfigDir: vi.fn(() => state.configDir),
-  loadConfig: vi.fn(() => state.config),
-}));
-
-vi.mock("./storage.mjs", () => ({
-  loadAccounts: vi.fn(async () => state.accounts),
-}));
-
-import { buildDiagnosticBundle } from "./diagnose.mjs";
-
-describe("buildDiagnosticBundle", () => {
-  beforeEach(() => {
-    state.accounts = null;
-    state.config = {};
-    state.debugHeadersExists = false;
-    state.directoryExists = false;
-    state.entries = [];
-    state.fileContents.clear();
-  });
-
-  it("returns all sections without leaking seeded secrets", async () => {
-    const bearer = "Bearer diagnoseBearerToken123";
-    const apiKey = "sk-ant-diagnoseSecret123";
-    const oauthToken = "oat01DiagnoseSecret123";
-    const refreshToken = "literal-refresh-secret";
-    const access = "literal-access-secret";
-
-    state.config = {
-      authorization: bearer,
-      apiKey,
-      metadata: oauthToken,
-      refreshToken,
-    };
-    state.accounts = {
-      accounts: [
-        {
-          email: "alice@example.com",
-          enabled: true,
-          consecutiveFailures: 2,
-          rateLimitResetTimes: { primary: 1234 },
-          access,
-          refreshToken,
-        },
-      ],
-    };
-
-    const bundle = await buildDiagnosticBundle();
-    const serialized = JSON.stringify(bundle);
-
-    expect(Object.keys(bundle)).toEqual(["meta", "config", "env", "accounts", "artifacts"]);
-    expect(serialized).not.toMatch(/Bearer\s+[A-Za-z0-9]/);
-    expect(serialized).not.toMatch(/sk-ant-[A-Za-z0-9]{4,}/);
-    expect(serialized).not.toMatch(/\boat01[A-Za-z0-9]{8,}/);
-    for (const secret of [bearer, apiKey, oauthToken, refreshToken, access]) {
-      expect(serialized).not.toContain(secret);
-    }
-    expect(bundle.accounts.items[0].email).toBe("a***@example.com");
-    expect(bundle.accounts.items[0]).not.toHaveProperty("access");
-    expect(bundle.accounts.items[0]).not.toHaveProperty("refreshToken");
-  });
-
-  it("degrades gracefully when accounts and artifact directories are absent", async () => {
-    const bundle = await buildDiagnosticBundle();
-
-    expect(bundle.accounts).toEqual({ count: 0, items: [] });
-    expect(bundle.artifacts.requestDumps).toEqual([]);
-    expect(bundle.artifacts.responseDumps).toEqual([]);
-    expect(bundle.artifacts.debugHeadersLog).toEqual({ exists: false, sizeBytes: 0 });
-  });
-
-  it("records a corrupted request dump and continues", async () => {
-    const corruptFile = "req-2026-04-10T12-00-00-000Z-correlation.json";
-    state.directoryExists = true;
-    state.entries = [corruptFile];
-    state.fileContents.set(corruptFile, "{not-json");
-
-    const bundle = await buildDiagnosticBundle();
-
-    expect(bundle.artifacts.requestDumps).toEqual([{ file: corruptFile, error: "unparseable" }]);
-    expect(bundle.artifacts.responseDumps).toEqual([]);
-  });
-});

package/lib/env.test.mjs

@@ -1,25 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { isFalsyEnv, isTruthyEnv } from "./env.mjs";
-
-describe("environment value parsers", () => {
-  describe("isTruthyEnv", () => {
-    it.each(["1", "true", "yes", " TRUE ", "Yes"])("accepts %j", (value) => {
-      expect(isTruthyEnv(value)).toBe(true);
-    });
-
-    it.each([undefined, "", "0", "false", "no", "on", "off", "anything"])("rejects %j", (value) => {
-      expect(isTruthyEnv(value)).toBe(false);
-    });
-  });
-
-  describe("isFalsyEnv", () => {
-    it.each(["0", "false", "no", " FALSE ", "No"])("accepts %j", (value) => {
-      expect(isFalsyEnv(value)).toBe(true);
-    });
-
-    it.each([undefined, "", "1", "true", "yes", "on", "off", "anything"])("rejects %j", (value) => {
-      expect(isFalsyEnv(value)).toBe(false);
-    });
-  });
-});

package/lib/haiku-call.test.mjs

@@ -1,72 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { callHaiku } from "./haiku-call.mjs";
-
-describe("callHaiku", () => {
-  it("returns text + tokens + cost on 200 response", async () => {
-    const fetchMock = vi.fn(async () => ({
-      ok: true,
-      status: 200,
-      json: async () => ({
-        content: [{ type: "text", text: "summary body here" }],
-        usage: { input_tokens: 100, output_tokens: 30 },
-      }),
-    }));
-    const getAccessToken = vi.fn(async () => "oauth-token-abc");
-
-    const result = await callHaiku({
-      prompt: "summarize this",
-      fetch: fetchMock,
-      getAccessToken,
-    });
-
-    expect(result.text).toBe("summary body here");
-    expect(result.tokens).toEqual({ input: 100, output: 30 });
-    // Haiku 4.5 pricing: $1/MTok input, $5/MTok output (2026-04-18)
-    // cost = 100/1e6 * 1 + 30/1e6 * 5 = 0.0001 + 0.00015 = 0.00025
-    expect(result.cost).toBeCloseTo(0.00025, 8);
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [url, opts] = fetchMock.mock.calls[0];
-    expect(url).toBe("https://api.anthropic.com/v1/messages");
-    expect(opts.method).toBe("POST");
-    expect(opts.headers.authorization).toBe("Bearer oauth-token-abc");
-    expect(opts.headers["anthropic-version"]).toBe("2023-06-01");
-    const body = JSON.parse(opts.body);
-    expect(body.model).toBe("claude-haiku-4-5-20251001");
-    expect(body.temperature).toBe(0);
-    expect(body.max_tokens).toBe(2048);
-    expect(body.messages).toEqual([{ role: "user", content: [{ type: "text", text: "summarize this" }] }]);
-  });
-
-  it("throws on non-2xx HTTP response", async () => {
-    const fetchMock = vi.fn(async () => ({
-      ok: false,
-      status: 429,
-      text: async () => "rate limited",
-    }));
-    const getAccessToken = vi.fn(async () => "oauth-token-abc");
-
-    await expect(callHaiku({ prompt: "x", fetch: fetchMock, getAccessToken })).rejects.toThrow(/HTTP 429/);
-  });
-
-  it("throws when response content is missing or not text", async () => {
-    const fetchMock = vi.fn(async () => ({
-      ok: true,
-      status: 200,
-      json: async () => ({ content: [], usage: { input_tokens: 0, output_tokens: 0 } }),
-    }));
-    const getAccessToken = vi.fn(async () => "oauth-token-abc");
-
-    await expect(callHaiku({ prompt: "x", fetch: fetchMock, getAccessToken })).rejects.toThrow(/no text content/i);
-  });
-
-  it("throws when getAccessToken rejects", async () => {
-    const fetchMock = vi.fn();
-    const getAccessToken = vi.fn(async () => {
-      throw new Error("oauth expired");
-    });
-
-    await expect(callHaiku({ prompt: "x", fetch: fetchMock, getAccessToken })).rejects.toThrow(/oauth expired/);
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-});

package/lib/message-transform.test.mjs

@@ -1,173 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { staleReadEviction, perToolClassPrune, STALE_READ_TOOLS, REPRODUCIBLE_TOOLS } from "./message-transform.mjs";
-
-/** Build a message with a single tool part. */
-function toolMsg(tool, output, { compacted = false, attachments } = {}) {
-  return {
-    info: { role: "assistant", id: `msg-${Math.random()}` },
-    parts: [
-      {
-        type: "tool",
-        callID: "c1",
-        tool,
-        state: {
-          status: "completed",
-          input: {},
-          output,
-          title: "t",
-          metadata: {},
-          time: { start: 0, end: 1, ...(compacted ? { compacted: 1 } : {}) },
-          ...(attachments ? { attachments } : {}),
-        },
-      },
-    ],
-  };
-}
-
-describe("staleReadEviction", () => {
-  it("is a no-op when messages <= threshold", () => {
-    const msgs = [toolMsg("read", "content")];
-    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
-    expect(evicted).toBe(0);
-    expect(msgs[0].parts[0].state.output).toBe("content");
-  });
-
-  it("replaces read output older than threshold with placeholder", () => {
-    const msgs = Array.from({ length: 15 }, (_, i) => toolMsg("read", `file ${i} content`));
-    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
-    expect(evicted).toBe(5);
-    expect(msgs[0].parts[0].state.output).toMatch(/re-read if you need/);
-    expect(msgs[4].parts[0].state.output).toMatch(/re-read if you need/);
-    expect(msgs[5].parts[0].state.output).toBe("file 5 content");
-    expect(msgs[14].parts[0].state.output).toBe("file 14 content");
-  });
-
-  it("leaves non-read tools untouched", () => {
-    const msgs = Array.from({ length: 15 }, (_, i) => toolMsg("bash", `cmd ${i} output`));
-    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
-    expect(evicted).toBe(0);
-    expect(msgs[0].parts[0].state.output).toBe("cmd 0 output");
-  });
-
-  it("skips already-compacted tool parts", () => {
-    const msgs = [
-      toolMsg("read", "stale but compacted", { compacted: true }),
-      ...Array.from({ length: 11 }, (_, i) => toolMsg("read", `x${i}`)),
-    ];
-    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
-    expect(evicted).toBe(1);
-    expect(msgs[0].parts[0].state.output).toBe("stale but compacted");
-    expect(msgs[1].parts[0].state.output).toMatch(/re-read if you need/);
-  });
-
-  it("strips attachments when evicting", () => {
-    const msgs = Array.from({ length: 15 }, (_, i) =>
-      toolMsg("read", `file ${i}`, {
-        attachments: [{ type: "file", mime: "image/png", url: "x" }],
-      }),
-    );
-    staleReadEviction({ messages: msgs, threshold: 10 });
-    expect(msgs[0].parts[0].state.attachments).toEqual([]);
-    expect(msgs[14].parts[0].state.attachments).toHaveLength(1);
-  });
-
-  it("accepts `view` as a read-class tool", () => {
-    expect(STALE_READ_TOOLS.has("view")).toBe(true);
-    const msgs = Array.from({ length: 15 }, (_, i) => toolMsg("view", `content ${i}`));
-    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
-    expect(evicted).toBe(5);
-  });
-
-  it("handles empty/missing messages gracefully", () => {
-    expect(staleReadEviction({ messages: [] }).evicted).toBe(0);
-    expect(staleReadEviction({ messages: null }).evicted).toBe(0);
-  });
-});
-
-describe("perToolClassPrune", () => {
-  it("prunes old reproducible outputs over the 10k threshold", () => {
-    const output = "x".repeat(30_000); // ~7_500 tokens (chars/4)
-    const msgs = Array.from({ length: 3 }, () => toolMsg("read", output));
-    const { pruned, tokensSaved } = perToolClassPrune({
-      messages: msgs,
-      reproducibleThreshold: 10_000,
-    });
-    // Walk backward: newest (7_500) fits under 10k, older 2 push total over → pruned.
-    expect(pruned).toBe(2);
-    expect(tokensSaved).toBeGreaterThan(10_000);
-    expect(msgs[2].parts[0].state.output).toBe(output); // newest kept
-    expect(msgs[0].parts[0].state.output).toBe("");
-    expect(msgs[1].parts[0].state.output).toBe("");
-  });
-
-  it("uses higher threshold for stateful tools (bash)", () => {
-    const mid = "x".repeat(50_000); // ~12_500 tokens
-    const msgs = Array.from({ length: 3 }, () => toolMsg("bash", mid));
-    const { pruned } = perToolClassPrune({
-      messages: msgs,
-      statefulThreshold: 40_000,
-    });
-    // 3 × 12_500 = 37_500 < 40_000 → nothing pruned
-    expect(pruned).toBe(0);
-  });
-
-  it("never prunes protected tools (skill)", () => {
-    const big = "x".repeat(500_000); // ~125_000 tokens — would bust any threshold
-    const msgs = Array.from({ length: 3 }, () => toolMsg("skill", big));
-    const { pruned } = perToolClassPrune({ messages: msgs });
-    expect(pruned).toBe(0);
-    expect(msgs[0].parts[0].state.output).toBe(big);
-  });
-
-  it("stops walking back when it hits a compacted part", () => {
-    const big = "x".repeat(50_000);
-    const msgs = [
-      toolMsg("read", "must-not-prune-old", { compacted: true }),
-      ...Array.from({ length: 3 }, () => toolMsg("read", big)),
-    ];
-    perToolClassPrune({ messages: msgs, reproducibleThreshold: 10_000 });
-    // Compacted sentinel preserved; walk terminates before reaching it.
-    expect(msgs[0].parts[0].state.output).toBe("must-not-prune-old");
-  });
-
-  it("tracks reproducible and stateful budgets independently", () => {
-    const output = "x".repeat(30_000); // ~7_500 tokens each
-    // interleave: read, bash, read, bash, read, bash (oldest to newest)
-    const msgs = [
-      toolMsg("read", output),
-      toolMsg("bash", output),
-      toolMsg("read", output),
-      toolMsg("bash", output),
-      toolMsg("read", output),
-      toolMsg("bash", output),
-    ];
-    const { pruned } = perToolClassPrune({
-      messages: msgs,
-      reproducibleThreshold: 10_000,
-      statefulThreshold: 40_000,
-    });
-    // reads: 7_500, 15_000 → over → prune; 22_500 → prune. 2 old reads pruned.
-    // bash:  7_500, 15_000, 22_500 → all under 40k → 0 pruned.
-    expect(pruned).toBe(2);
-    expect(msgs[4].parts[0].state.output).toBe(output); // newest read kept
-    expect(msgs[5].parts[0].state.output).toBe(output); // newest bash kept
-    expect(msgs[0].parts[0].state.output).toBe(""); // oldest read pruned
-    expect(msgs[2].parts[0].state.output).toBe(""); // middle read pruned
-  });
-
-  it("normalizes tool name case when classifying", () => {
-    expect(REPRODUCIBLE_TOOLS.has("read")).toBe(true);
-    const output = "x".repeat(30_000); // ~7_500 tokens
-    const msgs = Array.from({ length: 3 }, () => toolMsg("READ", output));
-    const { pruned } = perToolClassPrune({
-      messages: msgs,
-      reproducibleThreshold: 10_000,
-    });
-    expect(pruned).toBe(2);
-  });
-
-  it("handles empty/missing messages gracefully", () => {
-    expect(perToolClassPrune({ messages: [] }).pruned).toBe(0);
-    expect(perToolClassPrune({ messages: null }).pruned).toBe(0);
-  });
-});

package/lib/mimicry/cache.test.mjs

@@ -1,112 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { resolveCacheTtl, shouldPlaceToolBreakpoint, updateBoundaryStability } from "./cache.mjs";
-
-describe("resolveCacheTtl", () => {
-  const base = {
-    configuredTtl: "1h",
-    roleScopedTtl: true,
-    isMainForCache: true,
-    env: {},
-  };
-
-  it("returns the configured TTL for the main role", () => {
-    expect(resolveCacheTtl(base)).toBe("1h");
-  });
-
-  it("downgrades side-query and subagent roles when role scoping is enabled", () => {
-    expect(resolveCacheTtl({ ...base, isMainForCache: false })).toBe("5m");
-    expect(resolveCacheTtl({ ...base, isSubagent: true })).toBe("5m");
-  });
-
-  it("honors the 5m environment override first", () => {
-    expect(
-      resolveCacheTtl({
-        ...base,
-        env: { FORCE_PROMPT_CACHING_5M: "1", ENABLE_PROMPT_CACHING_1H: "1" },
-      }),
-    ).toBe("5m");
-  });
-
-  it("honors the 1h environment override before role scoping", () => {
-    expect(
-      resolveCacheTtl({
-        ...base,
-        isMainForCache: false,
-        env: { ENABLE_PROMPT_CACHING_1H: "true" },
-      }),
-    ).toBe("1h");
-  });
-
-  it("keeps the configured TTL when role scoping is disabled", () => {
-    expect(resolveCacheTtl({ ...base, configuredTtl: "5m", roleScopedTtl: false })).toBe("5m");
-  });
-});
-
-describe("shouldPlaceToolBreakpoint", () => {
-  it("places a breakpoint when stability data is unavailable", () => {
-    expect(shouldPlaceToolBreakpoint(undefined)).toBe(true);
-    expect(shouldPlaceToolBreakpoint(new Map())).toBe(true);
-  });
-
-  it("places a breakpoint below the stable-system boundary", () => {
-    expect(
-      shouldPlaceToolBreakpoint(
-        new Map([
-          ["system_prompt", 1],
-          ["tool:read", 0],
-        ]),
-      ),
-    ).toBe(true);
-  });
-
-  it("skips a volatile tool breakpoint once the system is stable", () => {
-    expect(
-      shouldPlaceToolBreakpoint(
-        new Map([
-          ["system_prompt", 2],
-          ["tool:read", 0],
-        ]),
-      ),
-    ).toBe(false);
-  });
-
-  it("places the breakpoint when both system and tools are stable", () => {
-    expect(
-      shouldPlaceToolBreakpoint(
-        new Map([
-          ["system_prompt", 2],
-          ["tool:read", 1],
-        ]),
-      ),
-    ).toBe(true);
-  });
-});
-
-describe("updateBoundaryStability", () => {
-  it("mutates only the passed stability map across boundary transitions", () => {
-    const previous = new Map([
-      ["system_prompt", "system-v1"],
-      ["tool:read", "read-v1"],
-      ["tool:gone", "gone-v1"],
-    ]);
-    const current = new Map([
-      ["system_prompt", "system-v1"],
-      ["tool:read", "read-v2"],
-      ["tool:new", "new-v1"],
-    ]);
-    const stability = new Map([
-      ["system_prompt", 1],
-      ["tool:read", 4],
-      ["tool:gone", 3],
-    ]);
-
-    expect(updateBoundaryStability(current, previous, stability)).toBeUndefined();
-
-    expect([...stability]).toEqual([
-      ["system_prompt", 2],
-      ["tool:read", 0],
-      ["tool:new", 0],
-    ]);
-  });
-});

package/lib/mimicry/headers.test.mjs

@@ -1,50 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { buildAnthropicBetaHeader, buildRequestHeaders, detectProvider, isHaikuModel } from "./headers.mjs";
-
-describe("mimicry headers", () => {
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  it("places the OAuth beta first when signature emulation is enabled", () => {
-    const header = buildAnthropicBetaHeader("", true, "claude-sonnet-4-6", "anthropic");
-
-    expect(header.split(",")[0]).toBe("oauth-2025-04-20");
-  });
-
-  it("detects Haiku model IDs", () => {
-    expect(isHaikuModel("claude-3-5-haiku-20241022")).toBe(true);
-    expect(isHaikuModel("claude-sonnet-4-6")).toBe(false);
-  });
-
-  it("detects the Anthropic provider from the API URL", () => {
-    vi.stubEnv("CLAUDE_CODE_USE_BEDROCK", "");
-    vi.stubEnv("CLAUDE_CODE_USE_FOUNDRY", "");
-    vi.stubEnv("CLAUDE_CODE_USE_ANTHROPIC_AWS", "");
-    vi.stubEnv("CLAUDE_CODE_USE_MANTLE", "");
-    vi.stubEnv("CLAUDE_CODE_USE_VERTEX", "");
-
-    expect(detectProvider(new URL("https://api.anthropic.com/v1/messages"))).toBe("anthropic");
-  });
-
-  it("builds foreground request headers with a user agent and beta header", () => {
-    vi.stubEnv("CLAUDE_CODE_BACKGROUND", "");
-    const body = JSON.stringify({
-      model: "claude-sonnet-4-6",
-      messages: [{ role: "user", content: "Hello" }],
-    });
-
-    const headers = buildRequestHeaders(
-      "https://api.anthropic.com/v1/messages",
-      { headers: {} },
-      "oauth-token",
-      body,
-      new URL("https://api.anthropic.com/v1/messages"),
-      { enabled: true, claudeCliVersion: "2.1.195" },
-    );
-
-    expect(headers.get("user-agent")).toBeTruthy();
-    expect(headers.get("anthropic-beta")).toContain("oauth-2025-04-20");
-    expect(headers.get("x-app")).toBe("cli");
-  });
-});