Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

25.7 KB
Raw Blame
import { afterEach, beforeEach, expect, test } from "bun:test";
import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const children: ReturnType<typeof Bun.spawn>[] = [];
afterEach(() => {
  for (const child of children.splice(0)) {
    if (child.exitCode === null) child.kill();
  }
});
async function waitForChild(child: ReturnType<typeof Bun.spawn>) {
  let timer: ReturnType<typeof setTimeout> | undefined;
  try {
    return await Promise.race([
      child.exited,
      new Promise<number>((resolve) => {
        timer = setTimeout(() => {
          child.kill();
          resolve(124);
        }, 4000);
      }),
    ]);
  } finally {
    clearTimeout(timer);
  }
}

let home: string;
let savedEnv: Record<string, string | undefined>;
let savedFetch: typeof fetch;
let savedExit: typeof process.exit;
// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
class UnexpectedProcessExit extends Error {
  constructor(code?: string | number | null) {
    super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
    this.name = "UnexpectedProcessExit";
  }
}
beforeEach(() => {
  savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
  home = mkdtempSync(join(tmpdir(), "muse-run5-"));
  process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
  savedExit = process.exit;
  process.exit = (code?: string | number | null): never => {
    throw new UnexpectedProcessExit(code);
  };
  savedFetch = globalThis.fetch;
  globalThis.fetch = Object.assign(
    async () => {
      throw new Error("Unexpected network in Run 5 test");
    },
    { preconnect: () => {} }
  ) as typeof fetch;
});
function restoreHarness() {
  process.exit = savedExit;
  globalThis.fetch = savedFetch;
  for (const [key, value] of Object.entries(savedEnv)) {
    if (value === undefined) delete process.env[key];
    else process.env[key] = value;
  }
  rmSync(home, { recursive: true, force: true });
}

// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
// below is explicit and test-owned; omitted production defaults are forbidden.
function fakeCoreDeps(
  overrides: Partial<import("../meta-muse/muse-credentials.js").MuseCoreDeps> = {}
): import("../meta-muse/muse-credentials.js").MuseCoreDeps {
  return {
    dir: () => home,
    now: () => 1792088000000,
    readStore: () => null,
    writeBorrowedCopy: () => {
      throw new Error("Unexpected borrowed-copy write");
    },
    mint: async () => {
      throw new Error("Unexpected mint");
    },
    keychainLogin: async () => {
      throw new Error("Keychain forbidden");
    },
    ...overrides,
  };
}
function fakeMuseKeychainDeps(
  overrides: Partial<import("../meta-muse/muse-keychain.js").MuseKeychainDeps> = {}
): import("../meta-muse/muse-keychain.js").MuseKeychainDeps {
  return {
    dir: () => home,
    env: () => ({}),
    now: () => 1792088000000,
    sleep: async () => {
      throw new Error("Unexpected Keychain wait");
    },
    pid: () => 424242,
    isAlive: () => false,
    presence: async () => ({ kind: "absent" }),
    startRead: () => {
      throw new Error("Keychain forbidden");
    },
    ...overrides,
  };
}
let previousConfigPath: string | null;
const restoreRegistrations: (() => void)[] = [];
beforeEach(async () => {
  const keychain = await import("../keychain.js");
  const forbidden = () => {
    throw new Error("Real Keychain process forbidden");
  };
  keychain.setKeychainTestDeps({
    platform: () => "darwin",
    run: forbidden,
    runAsync: async () => forbidden(),
    spawnAsync: forbidden,
  });
  const core = await import("../meta-muse/muse-credentials.js");
  core.resetMuseCredentialState();
  core.setMuseCoreTestDeps(fakeCoreDeps());
  const museKeychain = await import("../meta-muse/muse-keychain.js");
  museKeychain.resetMuseKeychainState();
  museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
  (await import("../../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
  const config = await import("../../config-override.js");
  previousConfigPath = config.getConfigFileOverride();
  config.setConfigFileOverride(join(home, "config.json"));
});
afterEach(async () => {
  for (const restore of restoreRegistrations.splice(0).reverse()) restore();
  const core = await import("../meta-muse/muse-credentials.js");
  core.resetMuseCredentialState();
  core.setMuseCoreTestDeps(null);
  const museKeychain = await import("../meta-muse/muse-keychain.js");
  museKeychain.resetMuseKeychainState();
  museKeychain.setMuseKeychainTestDeps(null);
  const keychain = await import("../keychain.js");
  keychain.invalidateKeychainCache();
  keychain.setKeychainTestDeps(null);
  (await import("../../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
  (await import("../../auth/credentials/billing-probe.js")).clearSignedArm();
  (await import("../model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
  (await import("../all-models-cache.js"))._clearAllModelsCacheMemo();
  (await import("../catalog-client.js"))._resetCatalogClient();
  (await import("../../config-override.js")).setConfigFileOverride(previousConfigPath);
  restoreHarness();
});

test("T2: mint ignores hostile endpoint env and uses the fixed HTTPS Meta root", async () => {
  const names = ["META_BASE_URL", "MUSE_BASE_URL", "MUSE_CODE_BASE_URL"] as const;
  const saved = new Map(names.map((name) => [name, process.env[name]]));
  const requests: { url: string; authorization: string | null; body: unknown }[] = [];
  let hostileRequests = 0;
  const hostile = Bun.serve({
    hostname: "127.0.0.1",
    port: 0,
    fetch: () => {
      hostileRequests++;
      return new Response("must not receive a Muse credential", { status: 500 });
    },
  });
  try {
    for (const name of names) process.env[name] = hostile.url.origin;
    const { mintMuseApiKey } = await import("../meta-muse/muse-mint.js");
    const { MUSE_MODELS_URL } = await import("../meta-muse/muse-models.js");
    // §8 response structure with ASCII credential placeholders and a hostile base_url mutation.
    await mintMuseApiKey("dca:TESTTOKEN0001", {
      fetch: Object.assign(
        async (input: string | URL | Request, init?: RequestInit) => {
          const authorization = new Headers(init?.headers).get("authorization");
          expect(typeof init?.body).toBe("string");
          requests.push({
            url: input instanceof Request ? input.url : String(input),
            authorization,
            body: JSON.parse(String(init?.body)),
          });
          return Response.json({
            api_key: "LLM|TESTKEY0001",
            base_url: hostile.url.origin,
            has_payment_method: true,
            require_payment: false,
            is_subs_active: true,
            can_subscribe: false,
            show_subs_upsell: true,
            user_full_name: "TEST USER",
            user_email: "[email protected]",
            user_avatar_url: null,
            payment_method: "TEST PAYMENT METHOD",
            action_url: null,
            subs_tier_id: "<tier-id>",
            subs_tier_name: "Muse Code Power Usage",
            is_subs_upgrade_available: true,
            subs_usage: {
              window: { used_percent: 1, window_duration_mins: 300, resets_at: 1792136182 },
              weekly: { used_percent: 0, resets_at: 1792368000 },
              tier: "<tier-id>",
            },
          });
        },
        { preconnect: () => {} }
      ) as typeof fetch,
    });
    expect(requests).toEqual([
      {
        url: "https://api.meta.ai/muse-code/key",
        authorization: "Bearer dca:TESTTOKEN0001",
        body: { onboard: false },
      },
    ]);
    expect(MUSE_MODELS_URL).toBe("https://api.meta.ai/muse-code/models");
    expect(hostileRequests).toBe(0);
  } finally {
    for (const [name, value] of saved) {
      if (value === undefined) delete process.env[name];
      else process.env[name] = value;
    }
    await hostile.stop(true);
  }
});

// Install the real credential implementation through the declared authority seam.
async function withTransport(
  run: (
    t: import("./meta-muse-code.js").MuseCodeTransport,
    counts: { mints: number }
  ) => Promise<void>,
  baseUrl = "https://api.meta.ai/v1"
) {
  const core = await import("../meta-muse/muse-credentials.js");
  const d = await import("../model-discovery.js");
  await import("../model-discovery-builtins.js");
  const { credentials } = await import("../../auth/credentials/authority.js");
  const { MuseCodeCredentialProvider } = await import(
    "../../auth/credentials/muse-code-credential.js"
  );
  const { setCredentialPromptRole } = await import("../../auth/credentials/prompt-role.js");
  const { clearSignedArm } = await import("../../auth/credentials/billing-probe.js");
  const { MuseCodeTransport } = await import("./meta-muse-code.js");
  const prior = credentials.get("meta-muse-code");
  if (!prior) throw new Error("default Muse credential missing");
  const fetcher = d.getModelDiscoveryFetcher("muse-code-models");
  if (!fetcher) throw new Error("default discovery missing");
  restoreRegistrations.push(() => {
    credentials.register(prior);
    credentials.invalidate("meta-muse-code");
    d.registerModelDiscoveryFetcher("muse-code-models", fetcher);
  });
  const role = setCredentialPromptRole("never");
  const counts = { mints: 0 };
  core.resetMuseCredentialState();
  core.setMuseCoreTestDeps({
    ...fakeCoreDeps(),
    dir: () => home,
    readStore: (kind) => (kind === "borrowed-copy" ? { access_token: "dca:TESTTOKEN0001" } : null),
    keychainLogin: async () => {
      throw new Error("Keychain forbidden");
    },
    mint: async () => ({ apiKey: ++counts.mints === 1 ? "LLM|TESTKEY0001" : "LLM|TESTKEY0002" }),
  });
  credentials.register(new MuseCodeCredentialProvider());
  d.invalidateModelDiscovery("meta-muse-code");
  d.registerModelDiscoveryFetcher("muse-code-models", async () => ({
    kind: "models",
    models: [{ id: "muse-spark-1.3", contextWindow: 262144, reported: "chat" }],
  }));
  const transport = new MuseCodeTransport(
    {
      name: "meta-muse-code",
      baseUrl,
      apiPath: "/hostile",
      prefixes: ["muse@"],
      apiKeyEnvVar: "",
      streamFormatOverride: "openai-responses-sse",
    },
    "muse-spark-1.3",
    "constructor-key-must-not-sign"
  );
  try {
    await run(transport, counts);
  } finally {
    credentials.register(prior);
    credentials.invalidate("meta-muse-code");
    clearSignedArm();
    d.registerModelDiscoveryFetcher("muse-code-models", fetcher);
    d.invalidateModelDiscovery("meta-muse-code");
    core.resetMuseCredentialState();
    core.setMuseCoreTestDeps(null);
    setCredentialPromptRole(role);
  }
}

test("T1: Responses endpoint, minted bearer and stateless tool/reasoning payload", async () => {
  await withTransport(async (t, counts) => {
    await t.refreshAuth();
    expect(t.getEndpoint()).toBe("https://api.meta.ai/v1/responses");
    expect(t.overrideStreamFormat() ?? t.streamFormat).toBe("openai-responses-sse");
    expect(
      Object.entries(await t.getHeaders()).find(
        ([name]) => name.toLowerCase() === "authorization"
      )?.[1]
    ).toBe("Bearer LLM|TESTKEY0001");
    // Tool-round-trip item structures from §2.3 with ASCII placeholder values.
    const input = [
      {
        type: "reasoning",
        id: "rs_TEST0001:rs_TEST0002",
        encrypted_content: "Q-PaDgTESTENCRYPTED0001",
      },
      {
        type: "function_call",
        id: "fc_TEST0001",
        call_id: "call_TEST0001",
        name: "muse.read_file",
        arguments: '{"path":"note.txt"}',
      },
      {
        type: "function_call_output",
        call_id: "call_TEST0001",
        output: "Read text file `note.txt`.\n1|The secret word is MANGO-42.",
      },
    ];
    const payload = t.transformPayload({
      model: "muse-spark-1.3",
      input,
      store: true,
      reasoning: { effort: "high" },
    });
    expect(payload).toMatchObject({ store: false, reasoning: { summary: "auto", effort: "high" } });
    expect(payload.include).toContain("reasoning.encrypted_content");
    expect(payload.input).toEqual(input);
    expect(counts.mints).toBe(1);
  });
});

test("T1: subscription_usage after completed preserves text, tools, usage and one completion", async () => {
  const { Hono } = await import("hono");
  const { createResponsesStreamHandler } = await import(
    "../../handlers/shared/stream-parsers/openai-responses-sse.js"
  );
  // Capture-derived reconstruction: §2.4 event fields, §2.3 tool item.
  const call = {
    type: "function_call",
    id: "fc_TEST0001",
    call_id: "call_TEST0001",
    name: "muse.read_file",
    arguments: '{"path":"note.txt"}',
  };
  const reasoning = {
    type: "reasoning",
    id: "rs_TEST0001:rs_TEST0002",
    encrypted_content: "Q-PaDgTESTENCRYPTED0001",
  };
  const events = [
    { type: "response.created", response: { id: "resp_[redacted]" } },
    {
      type: "response.output_item.added",
      output_index: 0,
      item: { type: "message", id: "msg_[redacted]", role: "assistant", content: [] },
    },
    { type: "response.output_text.delta", output_index: 0, content_index: 0, delta: "PONG" },
    { type: "response.output_item.added", output_index: 2, item: reasoning },
    { type: "response.output_item.done", output_index: 2, item: reasoning },
    { type: "response.output_item.added", output_index: 1, item: { ...call, arguments: "" } },
    {
      type: "response.function_call_arguments.delta",
      output_index: 1,
      item_id: call.id,
      delta: call.arguments,
    },
    { type: "response.output_item.done", output_index: 1, item: call },
    {
      type: "response.completed",
      response: {
        id: "resp_[redacted]",
        usage: {
          input_tokens: 27,
          input_tokens_details: { cached_tokens: 0 },
          output_tokens: 9,
          output_tokens_details: { reasoning_tokens: 2 },
        },
      },
    },
    {
      type: "response.subscription_usage",
      subscription: {
        tier: "<tier-id>",
        weekly: { resets_at: 1792368000, used_percent: 0 },
        window: { resets_at: 1792088451, used_percent: 2, window_duration_mins: 300 },
      },
    },
  ];
  const wire =
    events
      .map(
        (e, sequence_number) =>
          `event: ${e.type}\ndata: ${JSON.stringify({ ...e, sequence_number })}\n\n`
      )
      .join("") + "data: [DONE]\n\n";
  const usage: number[][] = [];
  const app = new Hono();
  app.get("/", (c) =>
    createResponsesStreamHandler(
      c,
      new Response(wire, { headers: { "content-type": "text/event-stream" } }),
      {
        modelName: "muse-spark-1.3",
        onTokenUpdate: (i, o) => usage.push([i, o]),
      }
    )
  );
  const response = await app.request("http://localhost/");
  const body = await response.text();
  expect(response.status).toBe(200);
  expect(body).toContain("PONG");
  expect(body).toContain("muse.read_file");
  expect(body).toContain("note.txt");
  expect(body.match(/event: message_stop/g) ?? []).toHaveLength(1);
  // The parser's turn end is the one message_stop above: the onTurnEnd
  // callback is gone, and a turn end is observed at the hook seam.
  expect(usage.at(-1)).toEqual([27, 9]);
  // Replay the parsed reasoning cache through the Responses converter on the
  // next Anthropic tool-result turn; use the public adapter constructor/methods.
  const { CodexAPIFormat } = await import("../../adapters/codex-api-format.js");
  const adapter = new CodexAPIFormat("muse-spark-1.3", "openai-responses-sse", {
    codexExtras: false,
  });
  const emittedTool = body.split("\n\n").flatMap((frame) => {
    const data = frame.split("\n").find((line) => line.startsWith("data: "));
    if (!data || data.slice(6) === "[DONE]") return [];
    const event = JSON.parse(data.slice(6));
    return event.type === "content_block_start" && event.content_block?.type === "tool_use"
      ? [event.content_block]
      : [];
  });
  expect(emittedTool).toHaveLength(1);
  expect(typeof emittedTool[0].id).toBe("string");
  expect(emittedTool[0].id.length).toBeGreaterThan(0);
  const emittedToolId = emittedTool[0].id;
  const original = {
    model: "muse-spark-1.3",
    max_tokens: 64,
    stream: true,
    messages: [
      {
        role: "assistant",
        content: [
          { type: "tool_use", id: emittedToolId, name: call.name, input: { path: "note.txt" } },
        ],
      },
      {
        role: "user",
        content: [
          {
            type: "tool_result",
            tool_use_id: emittedToolId,
            content: "Read text file `note.txt`.\n1|The secret word is MANGO-42.",
          },
        ],
      },
    ],
  };
  const replay = adapter.buildPayload(original, adapter.convertMessages(original), []);
  expect(replay.input).toEqual(
    expect.arrayContaining([
      expect.objectContaining({
        type: "reasoning",
        encrypted_content: reasoning.encrypted_content,
      }),
      expect.objectContaining({
        type: "function_call",
        call_id: emittedToolId,
        name: call.name,
        arguments: call.arguments,
      }),
      expect.objectContaining({
        type: "function_call_output",
        call_id: emittedToolId,
        output: "Read text file `note.txt`.\n1|The secret word is MANGO-42.",
      }),
    ])
  );
});

test("T2: hostile provider/config/.env cannot redirect inference or models", async () => {
  const { getConfigFileOverride, setConfigFileOverride } = await import("../../config-override.js");
  const { getProviderByName, getEffectiveBaseUrl } = await import("../provider-definitions.js");
  const previous = getConfigFileOverride();
  const names = ["META_BASE_URL", "MUSE_BASE_URL", "MUSE_CODE_BASE_URL"];
  const saved = names.map((n) => [n, process.env[n]] as const);
  let hostileRequests = 0;
  const hostile = Bun.serve({
    hostname: "127.0.0.1",
    port: 0,
    fetch: () => {
      hostileRequests++;
      return new Response("forbidden");
    },
  });
  const urls: string[] = [];
  try {
    for (const n of names) process.env[n] = hostile.url.origin;
    writeFileSync(join(home, ".env"), names.map((n) => `${n}=${hostile.url.origin}`).join("\n"));
    const config = join(home, "config.json");
    writeFileSync(
      config,
      JSON.stringify({
        version: "1",
        defaultProfile: "default",
        profiles: {},
        endpoints: { "meta-muse-code": hostile.url.origin, muse: hostile.url.origin },
      })
    );
    setConfigFileOverride(config);
    const def = getProviderByName("meta-muse-code");
    if (!def) throw new Error("Muse definition missing");
    expect(new URL(getEffectiveBaseUrl(def)).hostname).toBe("api.meta.ai");
    await withTransport(async (t) => {
      await t.refreshAuth();
      globalThis.fetch = Object.assign(
        async (input: string | URL | Request) => {
          const url = input instanceof Request ? input.url : String(input);
          urls.push(url);
          if (url === "https://api.meta.ai/muse-code/models") return Response.json({ data: [] });
          if (url === "https://api.meta.ai/v1/responses")
            return new Response("data: [DONE]\n\n", {
              headers: { "content-type": "text/event-stream" },
            });
          throw new Error(`Unexpected URL ${url}`);
        },
        { preconnect: () => {} }
      ) as typeof fetch;
      const { fetchMuseCodeModelsCatalog } = await import("../meta-muse/muse-models.js");
      await fetchMuseCodeModelsCatalog();
      await fetch(t.getEndpoint(), {
        method: "POST",
        headers: await t.getHeaders(),
        body: JSON.stringify(t.transformPayload({ input: [] })),
      });
    }, hostile.url.origin);
    expect(urls).toEqual([
      "https://api.meta.ai/muse-code/models",
      "https://api.meta.ai/v1/responses",
    ]);
    expect(hostileRequests).toBe(0);
    // Bun's fresh process loads this test-owned .env before any module import.
    // Remove the parent overrides so that this assertion actually tests .env.
    const childEnv: Record<string, string | undefined> = {
      ...process.env,
      HOME: home,
      TMPDIR: home,
      CLAUDISH_DISABLE_KEYCHAIN: "1",
      CLAUDISH_DISABLE_CATALOG_WARM: "1",
    };
    for (const n of names) delete childEnv[n];
    const script = `
const realExit = process.exit.bind(process);
process.on("uncaughtException", error => { console.error(error); realExit(1); });
process.on("unhandledRejection", error => { console.error(error); realExit(1); });
      globalThis.fetch = async () => { throw new Error("network forbidden"); };
      const { setConfigFileOverride } = await import(${JSON.stringify(new URL("../../config-override.js", import.meta.url).href)});
      setConfigFileOverride(${JSON.stringify(config)});
      const core = await import(${JSON.stringify(new URL("../meta-muse/muse-credentials.js", import.meta.url).href)});
      core.setMuseCoreTestDeps({ dir: () => ${JSON.stringify(home)}, now: () => 1792088000000,
        readStore: () => null, writeBorrowedCopy: () => { throw new Error("write forbidden"); },
        keychainLogin: async () => { throw new Error("Keychain forbidden"); },
        mint: async () => { throw new Error("mint forbidden"); } });
      const { MuseCodeTransport } = await import(${JSON.stringify(new URL("./meta-muse-code.js", import.meta.url).href)});
      const { MUSE_MODELS_URL } = await import(${JSON.stringify(new URL("../meta-muse/muse-models.js", import.meta.url).href)});
      const t = new MuseCodeTransport({ name: "meta-muse-code", baseUrl: process.env.MUSE_CODE_BASE_URL,
        apiPath: "/hostile", apiKeyEnvVar: "", prefixes: ["muse@"] }, "muse-spark-1.3", "");
      console.log(JSON.stringify([process.env.MUSE_CODE_BASE_URL, t.getEndpoint(), MUSE_MODELS_URL]));
      realExit(0);
    `;
    const child = Bun.spawn([process.execPath, "--eval", script], {
      cwd: home,
      env: childEnv,
      stdout: "pipe",
      stderr: "pipe",
    });
    children.push(child);
    const [stdout, stderr, exit] = await Promise.all([
      new Response(child.stdout).text(),
      new Response(child.stderr).text(),
      waitForChild(child),
    ]);
    expect({ exit, stderr }).toEqual({ exit: 0, stderr: "" });
    expect(JSON.parse(stdout.trim())).toEqual([
      hostile.url.origin,
      "https://api.meta.ai/v1/responses",
      "https://api.meta.ai/muse-code/models",
    ]);
  } finally {
    setConfigFileOverride(previous);
    for (const [n, v] of saved) {
      if (v === undefined) delete process.env[n];
      else process.env[n] = v;
    }
    await hostile.stop(true);
  }
});

for (const freshRejected of [false, true]) {
  test(`T3: handler remints once after 401; fresh-key rejection=${freshRejected}`, async () => {
    await withTransport(async (t, counts) => {
      const { Hono } = await import("hono");
      const { ComposedHandler } = await import("../../handlers/composed-handler.js");
      const requests: { url: string; headers: unknown }[] = [];
      globalThis.fetch = Object.assign(
        async (input: string | URL | Request, init?: RequestInit) => {
          const url = input instanceof Request ? input.url : String(input);
          expect(url).toBe("https://api.meta.ai/v1/responses");
          requests.push({ url, headers: init?.headers });
          if (requests.length === 2 && !freshRejected) {
            // Capture-derived reconstruction from §2.4.
            const events = [
              { type: "response.created", response: { id: "resp_[redacted]" } },
              {
                type: "response.output_item.added",
                output_index: 0,
                item: { type: "message", id: "msg_[redacted]", role: "assistant", content: [] },
              },
              {
                type: "response.output_text.delta",
                output_index: 0,
                content_index: 0,
                delta: "PONG",
              },
              {
                type: "response.completed",
                response: { id: "resp_[redacted]", usage: { input_tokens: 27, output_tokens: 9 } },
              },
            ];
            return new Response(
              events.map((e) => `event: ${e.type}\ndata: ${JSON.stringify(e)}\n\n`).join("") +
                "data: [DONE]\n\n",
              { headers: { "content-type": "text/event-stream" } }
            );
          }
          // Captured §7 synthetic invalid-key body, repeated on rejected refresh.
          return Response.json(
            { error: { type: "invalid_api_key", message: "Unauthorized" } },
            { status: 401 }
          );
        },
        { preconnect: () => {} }
      ) as typeof fetch;
      const handler = new ComposedHandler(t, "[email protected]", "muse-spark-1.3", 0);
      const app = new Hono();
      app.post("/", (c) =>
        handler.handle(c, {
          model: "muse-spark-1.3",
          messages: [{ role: "user", content: "PONG" }],
          max_tokens: 16,
          stream: true,
        })
      );
      try {
        const response = await app.request("http://localhost/", { method: "POST" });
        expect(response.status).toBe(freshRejected ? 400 : 200);
        const body = await response.text();
        if (freshRejected) {
          expect(response.headers.get("x-claudish-auth-verdict")).toBe("terminal");
          expect(body).toContain("claudish login muse");
        } else expect(body).toContain("PONG");
        expect(counts.mints).toBe(2);
        expect(requests).toHaveLength(2);
        expect(JSON.stringify(requests[0].headers)).toContain("Bearer LLM|TESTKEY0001");
        expect(JSON.stringify(requests[1].headers)).toContain("Bearer LLM|TESTKEY0002");
        expect(JSON.stringify(requests)).not.toContain("constructor-key-must-not-sign");
      } finally {
        await handler.shutdown();
      }
    });
  });
}

// The parser and Responses converter share a process-wide reasoning cache.
beforeEach(async () => {
  (await import("../../adapters/reasoning-cache.js")).clearReasoningCache();
});
afterEach(async () => {
  (await import("../../adapters/reasoning-cache.js")).clearReasoningCache();
});