@golba98/codexa 1.0.1 → 1.0.3

package/src/core/models/codexModelCapabilities.test.ts

@@ -1,246 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  clearCodexModelCapabilityCache,
-  createFallbackModelCapabilities,
-  findModelCapability,
-  formatModelCapabilitiesList,
-  getCodexModelCapabilities,
-  getPreferredModelFromCapabilities,
-  normalizeCodexModelListResponses,
-  normalizeReasoningForModelCapabilities,
-} from "./codexModelCapabilities.js";
-
-const SAMPLE_RESPONSE = {
-  data: [
-    {
-      id: "gpt-5.4",
-      model: "gpt-5.4",
-      displayName: "gpt-5.4",
-      description: "Frontier model",
-      hidden: false,
-      isDefault: true,
-      defaultReasoningEffort: "medium",
-      supportedReasoningEfforts: [
-        { reasoningEffort: "low", description: "Fast" },
-        { reasoningEffort: "medium", description: "Balanced" },
-        { reasoningEffort: "high", description: "Deep" },
-        { reasoningEffort: "xhigh", description: "Deepest" },
-      ],
-    },
-    {
-      id: "gpt-5.1-codex-mini",
-      model: "gpt-5.1-codex-mini",
-      displayName: "Codex Mini",
-      description: "Small model",
-      hidden: false,
-      isDefault: false,
-      defaultReasoningEffort: "medium",
-      supportedReasoningEfforts: [
-        { reasoningEffort: "medium", description: "Dynamic" },
-        { reasoningEffort: "high", description: "Deep" },
-      ],
-    },
-  ],
-  nextCursor: null,
-};
-
-test("normalizes model/list responses with per-model reasoning metadata", () => {
-  const capabilities = normalizeCodexModelListResponses([SAMPLE_RESPONSE], {
-    discoveredAt: 123,
-    executable: "codex.cmd",
-  });
-
-  assert.equal(capabilities.status, "ready");
-  assert.equal(capabilities.source, "runtime");
-  assert.equal(capabilities.executable, "codex.cmd");
-  assert.equal(capabilities.models.length, 2);
-  assert.equal(capabilities.models[0]?.model, "gpt-5.4");
-  assert.equal(capabilities.models[0]?.reasoningLevelCount, 4);
-  assert.deepEqual(capabilities.models[0]?.supportedReasoningLevels?.map((item) => item.id), [
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-  ]);
-  assert.equal(capabilities.models[1]?.label, "Codex Mini");
-  assert.equal(capabilities.models[1]?.reasoningLevelCount, 2);
-});
-
-test("normalization rejects empty or malformed discovery output", () => {
-  assert.throws(
-    () => normalizeCodexModelListResponses([{ data: [] }]),
-    /no usable models/i,
-  );
-  assert.throws(
-    () => normalizeCodexModelListResponses([{ data: [{ id: "", model: "" }] }]),
-    /no usable models/i,
-  );
-});
-
-test("fallback keeps models but does not invent reasoning support", () => {
-  const capabilities = createFallbackModelCapabilities(new Error("offline"), {
-    discoveredAt: 456,
-    executable: "codex.cmd",
-  });
-
-  assert.equal(capabilities.status, "fallback");
-  assert.equal(capabilities.error, "offline");
-  assert.ok(capabilities.models.length > 0);
-  assert.equal(capabilities.models[0]?.available, false);
-  assert.equal(capabilities.models[0]?.supportedReasoningLevels, null);
-  assert.equal(capabilities.models[0]?.reasoningLevelCount, null);
-});
-
-test("normalizes reasoning by keeping valid values and clamping invalid ones", () => {
-  const capabilities = normalizeCodexModelListResponses([SAMPLE_RESPONSE]);
-
-  assert.equal(
-    normalizeReasoningForModelCapabilities("gpt-5.4", "high", capabilities),
-    "high",
-  );
-  assert.equal(
-    normalizeReasoningForModelCapabilities("gpt-5.1-codex-mini", "xhigh", capabilities),
-    "medium",
-  );
-});
-
-test("handles unavailable selected model with runtime default", () => {
-  const capabilities = normalizeCodexModelListResponses([SAMPLE_RESPONSE]);
-
-  assert.equal(getPreferredModelFromCapabilities(capabilities, "missing-model"), "gpt-5.4");
-  assert.equal(findModelCapability(capabilities, "Codex Mini"), null);
-  assert.equal(findModelCapability(capabilities, "gpt-5.1-codex-mini")?.model, "gpt-5.1-codex-mini");
-});
-
-test("formats model list with dynamic reasoning counts", () => {
-  const capabilities = normalizeCodexModelListResponses([SAMPLE_RESPONSE]);
-  const message = formatModelCapabilitiesList(capabilities, "gpt-5.1-codex-mini");
-
-  assert.match(message, /Detected from Codex runtime/i);
-  assert.match(message, /gpt-5\.4.*4 reasoning levels/i);
-  assert.match(message, /gpt-5\.1-codex-mini.*2 reasoning levels.*\*/i);
-});
-
-test("caches successful discovery and refreshes when forced", async () => {
-  clearCodexModelCapabilityCache();
-  let calls = 0;
-
-  const discover = async () => {
-    calls += 1;
-    return normalizeCodexModelListResponses([
-      {
-        data: [
-          {
-            id: `model-${calls}`,
-            model: `model-${calls}`,
-            displayName: `Model ${calls}`,
-            hidden: false,
-            isDefault: true,
-            defaultReasoningEffort: "medium",
-            supportedReasoningEfforts: [{ reasoningEffort: "medium", description: "Default" }],
-          },
-        ],
-      },
-    ], { discoveredAt: calls, executable: "codex" });
-  };
-
-  const first = await getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    now: () => 100,
-    ttlMs: 1000,
-  });
-  const cached = await getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    now: () => 200,
-    ttlMs: 1000,
-  });
-  const refreshed = await getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    forceRefresh: true,
-    now: () => 300,
-    ttlMs: 1000,
-  });
-
-  assert.equal(calls, 2);
-  assert.equal(first.models[0]?.model, "model-1");
-  assert.equal(cached.models[0]?.model, "model-1");
-  assert.equal(refreshed.models[0]?.model, "model-2");
-  clearCodexModelCapabilityCache();
-});
-
-test("concurrent callers share a single in-flight discovery promise", async () => {
-  clearCodexModelCapabilityCache();
-  let calls = 0;
-  let resolveDiscover: (value: unknown) => void = () => {};
-  const gate = new Promise<unknown>((resolve) => {
-    resolveDiscover = resolve;
-  });
-
-  const discover = async () => {
-    calls += 1;
-    await gate;
-    return normalizeCodexModelListResponses([
-      {
-        data: [
-          {
-            id: "model-a",
-            model: "model-a",
-            displayName: "Model A",
-            hidden: false,
-            isDefault: true,
-            defaultReasoningEffort: "medium",
-            supportedReasoningEfforts: [{ reasoningEffort: "medium", description: "Default" }],
-          },
-        ],
-      },
-    ], { discoveredAt: 1, executable: "codex" });
-  };
-
-  const firstPromise = getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    now: () => 100,
-    ttlMs: 1000,
-  });
-  const secondPromise = getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    now: () => 100,
-    ttlMs: 1000,
-  });
-  const thirdPromise = getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    now: () => 100,
-    ttlMs: 1000,
-  });
-
-  resolveDiscover(undefined);
-  const [first, second, third] = await Promise.all([firstPromise, secondPromise, thirdPromise]);
-
-  assert.equal(calls, 1, "discovery should run exactly once when called concurrently");
-  assert.equal(first.models[0]?.model, "model-a");
-  assert.equal(second.models[0]?.model, "model-a");
-  assert.equal(third.models[0]?.model, "model-a");
-  clearCodexModelCapabilityCache();
-});
-
-test("falls back safely when discovery fails", async () => {
-  clearCodexModelCapabilityCache();
-  const capabilities = await getCodexModelCapabilities({
-    executable: "codex",
-    discover: async () => {
-      throw new Error("broken json");
-    },
-    now: () => 100,
-  });
-
-  assert.equal(capabilities.status, "fallback");
-  assert.match(capabilities.error ?? "", /broken json/);
-  assert.equal(capabilities.models[0]?.supportedReasoningLevels, null);
-  clearCodexModelCapabilityCache();
-});

package/src/core/models/modelSpecs.test.ts

@@ -1,283 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { mkdtempSync, readFileSync, rmSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import {
-  areModelSpecsEqual,
-  createLoadingModelSpec,
-  createModelSpecService,
-  createUnknownModelSpec,
-  extractModelSpecFromDocText,
-  KNOWN_MODEL_SPECS,
-  loadModelSpecCache,
-  MODEL_SPEC_DOC_URLS,
-  parseTokenCount,
-  resolveModelSpec,
-  saveModelSpecCache,
-  stripHtmlToText,
-  type ModelSpec,
-  type VerifiedModelSpec,
-} from "./modelSpecs.js";
-
-test("parses token counts with commas and suffixes", () => {
-  assert.equal(parseTokenCount("1,050,000"), 1_050_000);
-  assert.equal(parseTokenCount("128,000"), 128_000);
-  assert.equal(parseTokenCount("1.05M"), 1_050_000);
-  assert.equal(parseTokenCount("400k"), 400_000);
-  assert.equal(parseTokenCount("nope"), null);
-});
-
-test("extracts verified model specs from official-doc-like text", () => {
-  const spec = extractModelSpecFromDocText(
-    "gpt-5.4",
-    "GPT-5.4 1,050,000 context window 128,000 max output tokens",
-    123,
-  );
-
-  assert.deepEqual(spec, {
-    status: "verified",
-    contextWindow: 1_050_000,
-    maxOutputTokens: 128_000,
-    sourceUrl: MODEL_SPEC_DOC_URLS["gpt-5.4"],
-    verifiedAt: 123,
-  });
-});
-
-test("returns null for ambiguous or incomplete model spec text", () => {
-  assert.equal(
-    extractModelSpecFromDocText("gpt-5.4-mini", "GPT-5.4 mini supports coding and agents.", 123),
-    null,
-  );
-  assert.equal(
-    extractModelSpecFromDocText("gpt-5.4-mini", "400,000 context window but no output limit", 123),
-    null,
-  );
-});
-
-test("strips HTML before parsing model specs", () => {
-  const html = `
-    <html>
-      <body>
-        <h1>GPT-5.3-Codex</h1>
-        <div>400,000 <strong>context window</strong></div>
-        <div>128,000 <em>max output tokens</em></div>
-      </body>
-    </html>
-  `;
-  const text = stripHtmlToText(html);
-  assert.match(text, /400,000 context window/i);
-  assert.match(text, /128,000 max output tokens/i);
-});
-
-test("cache round-trip preserves verified values", () => {
-  const dir = mkdtempSync(join(tmpdir(), "codexa-model-specs-"));
-  const cacheFile = join(dir, "model-specs.json");
-
-  try {
-    const cache = {
-      "gpt-5.2": {
-        status: "verified" as const,
-        contextWindow: 400_000,
-        maxOutputTokens: 128_000,
-        sourceUrl: MODEL_SPEC_DOC_URLS["gpt-5.2"],
-        verifiedAt: 456,
-      },
-    };
-    saveModelSpecCache(cache, cacheFile);
-
-    const loaded = loadModelSpecCache(cacheFile);
-    assert.deepEqual(loaded, cache);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("background refresh updates specs and dedupes concurrent requests", async () => {
-  const dir = mkdtempSync(join(tmpdir(), "codexa-model-specs-"));
-  const cacheFile = join(dir, "model-specs.json");
-  let fetchCalls = 0;
-  const service = createModelSpecService({
-    cacheFile,
-    now: () => 789,
-    fetchImpl: async () => {
-      fetchCalls += 1;
-      return new Response("400,000 context window 128,000 max output tokens", { status: 200 });
-    },
-  });
-
-  try {
-    const [left, right] = await Promise.all([
-      service.refreshSpec("gpt-5.2"),
-      service.refreshSpec("gpt-5.2"),
-    ]);
-
-    assert.equal(fetchCalls, 1);
-    assert.equal(left.status, "verified");
-    assert.equal(right.status, "verified");
-    assert.equal(left.contextWindow, 400_000);
-    assert.equal(left.maxOutputTokens, 128_000);
-
-    const persisted = JSON.parse(readFileSync(cacheFile, "utf-8")) as Record<string, ModelSpec>;
-    assert.equal(persisted["gpt-5.2"]?.verifiedAt, 789);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("refresh returns unknown when a fetch fails even if cache exists", async () => {
-  const dir = mkdtempSync(join(tmpdir(), "codexa-model-specs-"));
-  const cacheFile = join(dir, "model-specs.json");
-  saveModelSpecCache({
-    "gpt-5.3-codex": {
-      status: "verified",
-      contextWindow: 400_000,
-      maxOutputTokens: 128_000,
-      sourceUrl: MODEL_SPEC_DOC_URLS["gpt-5.3-codex"],
-      verifiedAt: 123,
-    },
-  }, cacheFile);
-
-  const service = createModelSpecService({
-    cacheFile,
-    fetchImpl: async () => new Response("broken page", { status: 200 }),
-  });
-
-  try {
-    const spec = await service.refreshSpec("gpt-5.3-codex");
-    assert.equal(spec.status, "unknown");
-    assert.equal(spec.contextWindow, null);
-    assert.equal(spec.maxOutputTokens, null);
-    assert.equal(spec.error, "Unable to parse model spec for gpt-5.3-codex");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("refresh returns unknown when there is no cache and verification fails", async () => {
-  const dir = mkdtempSync(join(tmpdir(), "codexa-model-specs-"));
-  const cacheFile = join(dir, "model-specs.json");
-  const service = createModelSpecService({
-    cacheFile,
-    fetchImpl: async () => new Response("no token limits here", { status: 200 }),
-  });
-
-  try {
-    const spec = await service.refreshSpec("gpt-5.2");
-    assert.deepEqual(spec, createUnknownModelSpec("gpt-5.2", "Unable to parse model spec for gpt-5.2"));
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("resolveModelSpec prefers runtime discovery metadata", () => {
-  const spec = resolveModelSpec("gpt-5.4", {
-    runtimeContextWindow: 2_000_000,
-    runtimeMaxOutputTokens: 256_000,
-    cache: {
-      "gpt-5.4": {
-        status: "verified",
-        contextWindow: 1_050_000,
-        maxOutputTokens: 128_000,
-        sourceUrl: MODEL_SPEC_DOC_URLS["gpt-5.4"]!,
-        verifiedAt: 1,
-      },
-    },
-    now: () => 999,
-  });
-
-  assert.equal(spec.status, "verified");
-  assert.equal(spec.contextWindow, 2_000_000);
-  assert.equal(spec.maxOutputTokens, 256_000);
-});
-
-test("resolveModelSpec falls back to persisted cache when runtime lacks context metadata", () => {
-  const spec = resolveModelSpec("gpt-5.4", {
-    cache: {
-      "gpt-5.4": {
-        status: "verified",
-        contextWindow: 1_050_000,
-        maxOutputTokens: 128_000,
-        sourceUrl: MODEL_SPEC_DOC_URLS["gpt-5.4"]!,
-        verifiedAt: 42,
-      },
-    },
-  });
-
-  assert.equal(spec.status, "verified");
-  assert.equal(spec.contextWindow, 1_050_000);
-  assert.equal(spec.verifiedAt, 42);
-});
-
-test("resolveModelSpec does not use static registry values when cache is empty", () => {
-  const spec = resolveModelSpec("gpt-5.4-mini", { now: () => 11 });
-  assert.equal(spec.status, "unknown");
-  assert.equal(spec.contextWindow, null);
-  assert.deepEqual(KNOWN_MODEL_SPECS, {});
-});
-
-test("resolveModelSpec returns loading while refresh is in-flight for unmapped models", () => {
-  const spec = resolveModelSpec("gpt-future-9", { refreshInFlight: true });
-  assert.equal(spec.status, "loading");
-  assert.equal(spec.contextWindow, null);
-});
-
-test("resolveModelSpec returns unknown only when no source can supply context metadata", () => {
-  const spec = resolveModelSpec("gpt-future-9");
-  assert.equal(spec.status, "unknown");
-  assert.equal(spec.contextWindow, null);
-});
-
-test("resolveModelSpec does not infer registry entries when switching between model names", () => {
-  const specFour = resolveModelSpec("gpt-5.4");
-  const specTwo = resolveModelSpec("gpt-5.2");
-  assert.equal(specFour.contextWindow, null);
-  assert.equal(specTwo.contextWindow, null);
-});
-
-test("reports equality across verified and unknown specs", () => {
-  assert.equal(
-    areModelSpecsEqual(
-      createLoadingModelSpec("gpt-5.4"),
-      createLoadingModelSpec("gpt-5.4"),
-    ),
-    true,
-  );
-  assert.equal(
-    areModelSpecsEqual(
-      createUnknownModelSpec("gpt-5.4", "a"),
-      createUnknownModelSpec("gpt-5.4", "b"),
-    ),
-    false,
-  );
-});
-
-test("resolveModelSpec returns unknown for claude-sonnet-4-6 without runtime/config context", () => {
-  const spec = resolveModelSpec("claude-sonnet-4-6");
-  assert.equal(spec.status, "unknown");
-  assert.equal(spec.contextWindow, null);
-});
-
-test("resolveModelSpec returns unknown for anthropic short alias 'haiku'", () => {
-  const spec = resolveModelSpec("haiku");
-  assert.equal(spec.status, "unknown");
-  assert.equal(spec.contextWindow, null);
-});
-
-test("resolveModelSpec returns unknown for gemini-2.5-flash without provider context metadata", () => {
-  const spec = resolveModelSpec("gemini-2.5-flash");
-  assert.equal(spec.status, "unknown");
-  assert.equal(spec.contextWindow, null);
-});
-
-test("resolveModelSpec returns null contextWindow (not 0) for an unrecognized model", () => {
-  const spec = resolveModelSpec("totally-unknown-model");
-  assert.equal(spec.status, "unknown");
-  assert.equal(spec.contextWindow, null);
-});
-
-test("resolveModelSpec does not estimate gemini-3-flash-preview", () => {
-  const spec = resolveModelSpec("gemini-3-flash-preview");
-  assert.equal(spec.status, "unknown");
-  assert.equal(spec.contextWindow, null);
-});