Skip to content

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

9.8 KB
Raw Blame
import { afterEach, describe, expect, test } from "bun:test";
import { readFileSync } from "node:fs";
import type { CodexModelInfo } from "../providers/codex-models-discovery.js";
import { type ExecToolDefinition, renderExecTool } from "./exec-tool.js";
import { decideCodeMode } from "./policy.js";
import {
  CODE_MODE_NOTE,
  type CodeModePayloadContext,
  LITE_FALLBACK_TTL_MS,
  LITE_HEADER_NAME,
  applyCodeModeToPayload,
  isLiteFallbackActive,
  isLiteRejection,
  markLiteFallback,
  rebuildAsClassic,
  resetCodeModeRequestStateForTests,
  withoutLiteHeader,
} from "./request.js";

type CapturedPayload = {
  model: string;
  input: CodeModePayloadContext["input"];
  instructions?: string;
  tools?: ExecToolDefinition[];
  reasoning?: { effort?: string; context?: string; summary?: string };
  store?: boolean;
  include?: string[];
  prompt_cache_key?: string;
  parallel_tool_calls?: boolean;
  tool_choice?: string;
};
type Capture = { headers: Record<string, string>; body: CapturedPayload };
const readData = (name: string) =>
  JSON.parse(readFileSync(new URL(`../test-fixtures/code-mode/${name}`, import.meta.url), "utf8"));
const lite = readData("lite-request.json") as Capture;
const classic = readData("classic-request.json") as Capture;
const capturedBase = readData("claude-code-request-body.json") as Omit<CapturedPayload, "tools"> & {
  tools: Array<{ name: string; description: string; parameters: unknown }>;
};
const discovery = readData("codex-models-response.json") as {
  models: Array<{
    slug: string;
    tool_mode?: string;
    use_responses_lite?: boolean;
    default_reasoning_level?: string;
  }>;
};
const discovered = discovery.models.find((model) => model.slug === lite.body.model)!;
const modelInfo: CodexModelInfo = {
  slug: discovered.slug,
  toolMode: discovered.tool_mode,
  useResponsesLite: discovered.use_responses_lite,
  defaultReasoningLevel: discovered.default_reasoning_level,
};
const rendered = renderExecTool(
  capturedBase.tools.map((tool) => ({
    name: tool.name,
    description: tool.description,
    input_schema: tool.parameters,
  }))
);

const context = (shape: "lite" | "classic"): CodeModePayloadContext => ({
  shape,
  execTool: rendered.tool,
  input: structuredClone(classic.body.input),
  sessionKey: "session-account-test-key",
  modelInfo,
});
// Derived exclusively from the real classic request: its message/tool parts are not
// fabricated. The production builder appends CODE_MODE_NOTE and chooses a shape.
const payload = () => structuredClone(classic.body);

afterEach(() => resetCodeModeRequestStateForTests());

describe("code-mode payload shapes", () => {
  test("lite matches the captured structure and supplies the required header", () => {
    const ctx = context("lite");
    const request = applyCodeModeToPayload(payload(), ctx);
    const body = request.payload;
    expect(request.shape).toBe("lite");
    expect(body.tools).toBeUndefined();
    expect(body.instructions).toBeUndefined();
    expect(body.parallel_tool_calls).toBe(lite.body.parallel_tool_calls);
    expect(body.tool_choice).toBe(lite.body.tool_choice);
    expect(body.reasoning.context).toBe(lite.body.reasoning!.context);
    expect(body.reasoning.effort).toBe(classic.body.reasoning!.effort);
    const capturedTools = lite.body.input[0]!;
    const capturedDeveloper = lite.body.input[1]!;
    expect(body.input[0]).toMatchObject({
      type: capturedTools.type,
      role: capturedTools.role,
      tools: [rendered.tool],
    });
    expect(body.input[0].id).toMatch(/^at_[0-9a-f-]{36}$/);
    expect(body.input[1]).toEqual({
      type: capturedDeveloper.type,
      role: capturedDeveloper.role,
      content: [{ type: "input_text", text: `${classic.body.instructions}\n\n${CODE_MODE_NOTE}` }],
    });
    expect(body.input.slice(2)).toEqual(ctx.input);
    expect(request.headers).toContainEqual({
      name: LITE_HEADER_NAME,
      value: lite.headers[LITE_HEADER_NAME],
      merge: "append-comma",
    });
  });

  test("classic matches the captured top-level exec structure and never adds the lite header", () => {
    const ctx = context("classic");
    const request = applyCodeModeToPayload(payload(), ctx);
    expect(request.shape).toBe("classic");
    expect(request.payload.tools).toEqual([rendered.tool]);
    expect(request.payload.tools[0].type).toBe(classic.body.tools![0]!.type);
    expect(request.payload.input).toEqual(ctx.input);
    expect(request.payload.instructions).toBe(`${classic.body.instructions}\n\n${CODE_MODE_NOTE}`);
    expect(request.payload.parallel_tool_calls).toBe(false);
    expect(request.payload.tool_choice).toBe("auto");
    expect(request.headers.some((header) => header.name.toLowerCase() === LITE_HEADER_NAME)).toBe(
      false
    );
    expect(request.payload.reasoning).toEqual(classic.body.reasoning);
  });

  test("post-5c cache/store/include/reasoning fields survive either shape", () => {
    for (const shape of ["lite", "classic"] as const) {
      // Derived from the real B request, which carries the post-5c cache key.
      const original = structuredClone(capturedBase);
      const request = applyCodeModeToPayload(original, context(shape));
      expect(request.payload.prompt_cache_key).toBe(capturedBase.prompt_cache_key);
      expect(request.payload.store).toBe(capturedBase.store);
      expect(request.payload.include).toEqual(capturedBase.include);
      expect(request.payload.reasoning.effort).toBe(capturedBase.reasoning!.effort);
      expect(request.payload.reasoning.summary).toBe(capturedBase.reasoning!.summary);
    }
  });

  test("lite uses discovery's default effort only when none was supplied", () => {
    const noEffort = payload();
    delete noEffort.reasoning;
    const request = applyCodeModeToPayload(noEffort, context("lite"));
    expect(request.shape).toBe("lite");
    expect(request.payload.reasoning).toMatchObject({
      effort: modelInfo.defaultReasoningLevel,
      context: "all_turns",
      summary: "auto",
    });
  });

  test("lite without request effort or discovery default becomes classic with no header", () => {
    const noEffort = payload();
    delete noEffort.reasoning;
    const ctx = context("lite");
    ctx.modelInfo = { ...modelInfo, defaultReasoningLevel: undefined };
    const request = applyCodeModeToPayload(noEffort, ctx);
    expect(request.shape).toBe("classic");
    expect(request.payload.tools).toEqual([rendered.tool]);
    expect(request.payload.input).toEqual(ctx.input);
    expect(request.headers).toEqual([]);
  });

  test("identical session and tools produce stable additional_tools ids", () => {
    const first = applyCodeModeToPayload(payload(), context("lite"));
    const second = applyCodeModeToPayload(payload(), context("lite"));
    expect(first.payload.input[0].id).toBe(second.payload.input[0].id);
    const other = applyCodeModeToPayload(payload(), {
      ...context("lite"),
      sessionKey: "another-account-session",
    });
    expect(first.payload.input[0].id).not.toBe(other.payload.input[0].id);
  });
});

describe("lite rejection state", () => {
  test("only raw HTTP 400 naming the lite header or reasoning.context qualifies", () => {
    for (const message of [LITE_HEADER_NAME, "REASONING.CONTEXT must be all_turns"]) {
      expect(isLiteRejection(400, message)).toBe(true);
      expect(isLiteRejection(401, message)).toBe(false);
      expect(isLiteRejection(500, message)).toBe(false);
    }
    expect(isLiteRejection(400, "unrelated invalid parameter")).toBe(false);
  });

  test("fallback rebuilds classic exec shape, marks the model, and the next decision is classic", () => {
    const pre = payload();
    const saved = structuredClone(pre);
    const ctx = context("lite");
    expect(isLiteFallbackActive(pre.model)).toBe(false);
    const rebuilt = rebuildAsClassic(pre, ctx, pre.model);
    expect(rebuilt.shape).toBe("classic");
    expect(rebuilt.payload.tools).toEqual([rendered.tool]);
    expect(rebuilt.payload.input).toEqual(ctx.input);
    expect(rebuilt.headers).toEqual([]);
    expect(pre).toEqual(saved);
    expect(isLiteFallbackActive(pre.model)).toBe(true);
    const decision = decideCodeMode({
      providerName: "openai-codex",
      arm: "oauth",
      accountKey: "account-a",
      api: "responses",
      hasTools: true,
      toolChoice: undefined,
      hasSessionId: true,
      setting: "auto",
      modelInfo,
      pinned: false,
      sandboxAvailable: true,
      liteFallbackActive: isLiteFallbackActive(pre.model),
    });
    expect(decision).toEqual({ on: true, shape: "classic", reason: "discovery" });
    if (!decision.on) throw new Error("code mode unexpectedly disabled");
    expect(applyCodeModeToPayload(payload(), context(decision.shape)).payload.tools).toEqual([
      rendered.tool,
    ]);
    resetCodeModeRequestStateForTests();
    expect(isLiteFallbackActive(pre.model)).toBe(false);
  });

  test("fallback TTL uses an injected clock and does not mark a different model", () => {
    const start = 1000;
    markLiteFallback(classic.body.model, start);
    expect(isLiteFallbackActive(classic.body.model, start)).toBe(true);
    expect(isLiteFallbackActive("unrelated-test-model", start)).toBe(false);
    expect(isLiteFallbackActive(classic.body.model, start + LITE_FALLBACK_TTL_MS - 1)).toBe(true);
    expect(isLiteFallbackActive(classic.body.model, start + LITE_FALLBACK_TTL_MS + 1)).toBe(false);
    markLiteFallback(classic.body.model, start);
    resetCodeModeRequestStateForTests();
    expect(isLiteFallbackActive(classic.body.model, start)).toBe(false);
  });

  test("removes every case spelling of the lite header while retaining other wire headers", () => {
    const other = { name: "other-header", value: "kept", merge: "append-comma" as const };
    expect(
      withoutLiteHeader([
        { name: LITE_HEADER_NAME, value: "true", merge: "append-comma" },
        other,
        { name: LITE_HEADER_NAME.toUpperCase(), value: "true", merge: "append-comma" },
      ])
    ).toEqual([other]);
  });
});