Skip to content

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

4.7 KB
Raw Blame
import { describe, expect, test } from "bun:test";
import { readFileSync } from "node:fs";
import type { CodexModelInfo } from "../providers/codex-models-discovery.js";
import { type CodeModeDecision, type CodeModeDecisionInput, decideCodeMode } from "./policy.js";

type OffReason = Extract<CodeModeDecision, { on: false }>["reason"];

const capture = JSON.parse(
  readFileSync(
    new URL("../test-fixtures/code-mode/codex-models-response.json", import.meta.url),
    "utf8"
  )
) as {
  models: Array<{
    slug: string;
    tool_mode?: string;
    use_responses_lite?: boolean;
    default_reasoning_level?: string;
  }>;
};
const discovered = capture.models.find(
  (model) => model.tool_mode === "code_mode_only" && model.use_responses_lite
)!;
const info: CodexModelInfo = {
  slug: discovered.slug,
  toolMode: discovered.tool_mode,
  useResponsesLite: discovered.use_responses_lite,
  defaultReasoningLevel: discovered.default_reasoning_level,
};
const baseline: CodeModeDecisionInput = {
  providerName: "openai-codex",
  arm: "oauth",
  accountKey: "account-a",
  api: "responses",
  hasTools: true,
  toolChoice: undefined,
  hasSessionId: true,
  setting: "auto",
  modelInfo: info,
  pinned: false,
  sandboxAvailable: true,
  liteFallbackActive: false,
};

describe("code-mode policy", () => {
  test.each([
    ["other claudish provider", { providerName: "openai" }, "not-openai-codex"],
    ["api-key arm [M]", { arm: "api-key" }, "metered-arm"],
    ["absent arm", { arm: undefined }, "metered-arm"],
    ["no account id", { accountKey: undefined }, "no-account-id"],
    ["non-Responses API", { api: "chat-completions" }, "not-responses"],
    ["unknown API", { api: undefined }, "not-responses"],
    ["no tools", { hasTools: false }, "no-tools"],
    ["named tool choice", { toolChoice: { type: "tool", name: "Read" } }, "forced-tool-choice"],
    ["any tool choice", { toolChoice: { type: "any" } }, "forced-tool-choice"],
    ["none tool choice", { toolChoice: { type: "none" } }, "forced-tool-choice"],
    ["no session id", { hasSessionId: false }, "no-session-id"],
    ["setting off", { setting: "off" }, "setting-off"],
    ["sandbox unavailable", { sandboxAvailable: false }, "sandbox-unavailable"],
    ["unknown discovery", { modelInfo: undefined }, "discovery-unknown"],
    [
      "other discovered tool mode",
      { modelInfo: { ...info, toolMode: "classic" } },
      "classic-by-discovery",
    ],
  ] as Array<[string, Partial<CodeModeDecisionInput>, OffReason]>)(
    "%s remains non-code-mode",
    (_name, patch, reason) => {
      expect(decideCodeMode({ ...baseline, ...patch })).toEqual({ on: false, reason });
    }
  );

  test("auto follows the live discovery fields and accepts explicit auto tool choice", () => {
    expect(discovered).toBeDefined();
    expect(decideCodeMode(baseline)).toEqual({ on: true, shape: "lite", reason: "discovery" });
    expect(decideCodeMode({ ...baseline, toolChoice: { type: "auto" } })).toEqual({
      on: true,
      shape: "lite",
      reason: "discovery",
    });
  });

  test("setting on forces code mode without discovery, but uses classic shape", () => {
    expect(decideCodeMode({ ...baseline, setting: "on", modelInfo: undefined })).toEqual({
      on: true,
      shape: "classic",
      reason: "forced",
    });
  });

  test("forced on never bypasses the api-key arm or session/account/sandbox guards [M]", () => {
    for (const [patch, reason] of [
      [{ arm: "api-key" }, "metered-arm"],
      [{ accountKey: undefined }, "no-account-id"],
      [{ hasSessionId: false }, "no-session-id"],
      [{ sandboxAvailable: false }, "sandbox-unavailable"],
    ] as Array<[Partial<CodeModeDecisionInput>, OffReason]>) {
      expect(decideCodeMode({ ...baseline, setting: "on", ...patch })).toEqual({
        on: false,
        reason,
      });
    }
  });

  test("pin preserves code mode when discovery is unknown, never when setting is off", () => {
    expect(decideCodeMode({ ...baseline, pinned: true, modelInfo: undefined })).toEqual({
      on: true,
      shape: "classic",
      reason: "pinned",
    });
    expect(decideCodeMode({ ...baseline, pinned: true, setting: "off" })).toEqual({
      on: false,
      reason: "setting-off",
    });
    expect(decideCodeMode({ ...baseline, pinned: true, arm: "api-key" })).toEqual({
      on: false,
      reason: "metered-arm",
    });
  });

  test("lite rejection or discovery without lite selects classic code-mode shape", () => {
    expect(decideCodeMode({ ...baseline, liteFallbackActive: true })).toEqual({
      on: true,
      shape: "classic",
      reason: "discovery",
    });
    expect(
      decideCodeMode({ ...baseline, modelInfo: { ...info, useResponsesLite: false } })
    ).toEqual({ on: true, shape: "classic", reason: "discovery" });
  });
});