fix(codex): clamp catalog reasoning efforts to installed binary's ladder

Adopts the approach from PR #223 by @Bricol1982 with safe-fallback improvements:
when ALL efforts are unsupported, fall back to universal [low,medium,high] instead
of preserving the unsupported ladder. Prevents Codex 0.133.0 catalog parse failure.

Co-authored-by: Bricol <Bricol1982@users.noreply.github.com>

Author: lidge-jun

src/codex/catalog.ts

@@ -690,7 +690,7 @@ export function materializeBundledCodexCatalog(path: string, deps: BundledCatalo
 
 function loadCatalogForSync(path: string): RawCatalog | null {
   const bundled = isDefaultCatalogPath(path) ? loadBundledCodexCatalog() : null;
-  if (bundled) return bundled;
+  if (bundled) return JSON.parse(JSON.stringify(bundled)) as RawCatalog;
   const catalog = readCatalog(path);
   if (catalog && findNativeTemplate(catalog)) return catalog;
   return readCatalog(catalogBackupPathFor(path))
@@ -829,6 +829,66 @@ function ensureUltraReasoningLevel(entry: RawEntry): void {
   entry.supported_reasoning_levels = levels;
 }
 
+/** Reasoning-effort labels accepted by the installed Codex binary's bundled catalog. */
+export function codexSupportedReasoningEfforts(deps: BundledCatalogDeps = {}): Set<string> | null {
+  const bundled = loadBundledCodexCatalog(deps);
+  if (!bundled) return null;
+  const efforts = new Set<string>();
+  for (const model of bundled.models ?? []) {
+    if (typeof model.slug !== "string" || model.slug.includes("/")) continue;
+    const levels = Array.isArray(model.supported_reasoning_levels) ? model.supported_reasoning_levels : [];
+    for (const level of levels) {
+      const effort = (level as { effort?: unknown })?.effort;
+      if (typeof effort === "string") efforts.add(effort);
+    }
+    if (typeof model.default_reasoning_level === "string") efforts.add(model.default_reasoning_level);
+  }
+  return efforts.size > 0 ? efforts : null;
+}
+
+/** Highest surviving rung at or below the original default, with a conservative empty fallback. */
+export function clampedDefaultEffort(original: string, surviving: readonly string[]): string {
+  if (surviving.length === 0) return "medium";
+  const ranked = [...surviving]
+    .map(effort => ({ effort, rank: codexEffortRank(effort) }))
+    .sort((a, b) => a.rank - b.rank);
+  const originalRank = codexEffortRank(original);
+  const atOrBelow = ranked.filter(item => item.rank >= 0 && item.rank <= originalRank);
+  return (atOrBelow.at(-1) ?? ranked[0]!).effort;
+}
+
+/** Remove reasoning efforts the installed Codex binary cannot deserialize from one entry. */
+export function clampEntryToCodexSupportedEfforts(entry: RawEntry, supported: Set<string> | null): void {
+  if (!supported) return;
+  const levels = Array.isArray(entry.supported_reasoning_levels)
+    ? entry.supported_reasoning_levels as Array<{ effort?: string }>
+    : null;
+  if (levels && levels.length > 0) {
+    const kept = levels.filter(level => typeof level?.effort === "string" && supported.has(level.effort));
+    entry.supported_reasoning_levels = kept.length > 0
+      ? kept
+      : CODEX_REASONING_LEVELS
+        .filter(level => level.effort === "low" || level.effort === "medium" || level.effort === "high")
+        .map(level => ({ ...level }));
+  }
+  const currentDefault = entry.default_reasoning_level;
+  if (typeof currentDefault === "string" && !supported.has(currentDefault)) {
+    const surviving = (Array.isArray(entry.supported_reasoning_levels) ? entry.supported_reasoning_levels : [])
+      .flatMap(level => typeof (level as { effort?: string })?.effort === "string"
+        ? [(level as { effort: string }).effort]
+        : []);
+    entry.default_reasoning_level = clampedDefaultEffort(currentDefault, surviving);
+  }
+}
+
+/** Clamp every catalog entry to the reasoning ladder accepted by the installed Codex binary. */
+export function clampCatalogModelsToCodexSupport(models: RawEntry[], deps: BundledCatalogDeps = {}): RawEntry[] {
+  const supported = codexSupportedReasoningEfforts(deps);
+  if (!supported) return models;
+  for (const entry of models) clampEntryToCodexSupportedEfforts(entry, supported);
+  return models;
+}
+
 /**
  * Native entry from the pinned upstream snapshot, finished for emission. Keeps the entry's
  * OWN identity (display_name, description, priority, availability_nux — it is the model's own
@@ -1926,6 +1986,7 @@ export async function syncCatalogModels(config: OcxConfig): Promise<{ added: num
   // native template can never leak supports_websockets while the flag is off.
   const wsEnabled = websocketsEnabled(config);
   catalog.models = mergeCatalogEntriesForSync(catalog.models ?? [], goEntries, baseline, featured, wsEnabled, goIds, template, disabledNativeSlugs(config), gatheredProviderNames, multiAgentMode, exactComboSlugs, hasPhysicalComboProvider);
+  clampCatalogModelsToCodexSupport(catalog.models);
 
   atomicWriteFile(catalogPath, JSON.stringify(catalog, null, 2) + "\n");
   return { added: goEntries.length, path: catalogPath };

tests/codex-catalog.test.ts

@@ -2,7 +2,7 @@ import { afterEach, describe, expect, spyOn, test } from "bun:test";
 import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { augmentRoutedModelsWithJawcodeMetadata, augmentRoutedModelsWithRegistryOpenAiApiRows, buildCatalogEntries, deriveComboCatalogModel, exactComboCatalogSlugs, filterCatalogVisibleModels, filterSupportedNativeSlugs, gatherRoutedModels, isDatedVariantId, isMediaGenerationModelId, loadBundledCodexCatalog, materializeBundledCodexCatalog, mergeCatalogEntriesForSync, NATIVE_OPENAI_MODELS, normalizeRoutedCatalogEntry, resetCatalogRuntimeStateForTests, resetOpenAiApiCatalogWarningStateForTests } from "../src/codex/catalog";
+import { augmentRoutedModelsWithJawcodeMetadata, augmentRoutedModelsWithRegistryOpenAiApiRows, buildCatalogEntries, clampCatalogModelsToCodexSupport, clampEntryToCodexSupportedEfforts, clampedDefaultEffort, deriveComboCatalogModel, exactComboCatalogSlugs, filterCatalogVisibleModels, filterSupportedNativeSlugs, gatherRoutedModels, isDatedVariantId, isMediaGenerationModelId, loadBundledCodexCatalog, materializeBundledCodexCatalog, mergeCatalogEntriesForSync, NATIVE_OPENAI_MODELS, normalizeRoutedCatalogEntry, resetCatalogRuntimeStateForTests, resetOpenAiApiCatalogWarningStateForTests } from "../src/codex/catalog";
 import {
   CURSOR_STATIC_MODELS,
   filterCursorConfiguredModelsByLiveDiscovery,
@@ -1712,3 +1712,75 @@ describe("media-generation model filtering", () => {
     }
   });
 });
+
+describe("Codex reasoning-effort capability clamp", () => {
+  function bundledCatalogDeps(efforts: string[]) {
+    return {
+      commandCandidates: () => ["codex"],
+      execFileSync: () => JSON.stringify({
+        models: [{
+          slug: "gpt-5.5",
+          base_instructions: "test",
+          supported_reasoning_levels: efforts.map(effort => ({ effort, description: effort })),
+          default_reasoning_level: "medium",
+        }],
+      }),
+    };
+  }
+
+  function routedEntry() {
+    return {
+      slug: "openrouter/example",
+      supported_reasoning_levels: ["low", "medium", "high", "xhigh", "max", "ultra"]
+        .map(effort => ({ effort, description: effort })),
+      default_reasoning_level: "max",
+    };
+  }
+
+  test("strips max and ultra when the installed Codex ladder stops at xhigh", () => {
+    const models = [routedEntry()];
+
+    clampCatalogModelsToCodexSupport(models, bundledCatalogDeps(["low", "medium", "high", "xhigh"]));
+
+    expect(models[0]!.supported_reasoning_levels.map(level => level.effort))
+      .toEqual(["low", "medium", "high", "xhigh"]);
+  });
+
+  test("preserves max and ultra when the installed Codex ladder includes them", () => {
+    const models = [routedEntry()];
+
+    clampCatalogModelsToCodexSupport(models, bundledCatalogDeps(["low", "medium", "high", "xhigh", "max", "ultra"]));
+
+    expect(models[0]!.supported_reasoning_levels.map(level => level.effort))
+      .toEqual(["low", "medium", "high", "xhigh", "max", "ultra"]);
+  });
+
+  test("falls back to the conservative universal ladder when every advertised effort is unsupported", () => {
+    const entry = {
+      supported_reasoning_levels: [{ effort: "max" }, { effort: "ultra" }],
+      default_reasoning_level: "ultra",
+    };
+
+    clampEntryToCodexSupportedEfforts(entry, new Set(["low", "medium", "high", "xhigh"]));
+
+    expect(entry.supported_reasoning_levels.map(level => level.effort)).toEqual(["low", "medium", "high"]);
+    expect(clampedDefaultEffort("max", [])).toBe("medium");
+  });
+
+  test("repairs an unsupported max default to the highest surviving xhigh rung", () => {
+    const entry = routedEntry();
+
+    clampEntryToCodexSupportedEfforts(entry, new Set(["low", "medium", "high", "xhigh"]));
+
+    expect(entry.default_reasoning_level).toBe("xhigh");
+  });
+
+  test("is a no-op when the installed Codex binary cannot be probed", () => {
+    const models = [routedEntry()];
+    const before = structuredClone(models);
+
+    clampCatalogModelsToCodexSupport(models, { commandCandidates: () => [] });
+
+    expect(models).toEqual(before);
+  });
+});

tests/google-models-listing.test.ts

@@ -77,7 +77,7 @@ describe("google models listing via catalog", () => {
       expect(seen[0].url).toBe("https://generativelanguage.googleapis.com/v1beta/models?pageSize=1000");
       expect(seen[0].headers["x-goog-api-key"]).toBe("gk-123");
       const ids = models.filter(m => m.provider === "google").map(m => m.id);
-      expect(ids).toEqual(["gemini-3.1-pro-preview", "gemini-3.5-flash", "gemini-3.6-flash"]);
+      expect(ids).toEqual(["gemini-3.1-pro-preview", "gemini-3.5-flash", "gemini-3.5-flash-lite", "gemini-3.6-flash"]);
       expect(ids).not.toContain("gemini-3-pro");
       expect(ids).not.toContain("gemini-3-flash");
       expect(getStaleCached("google")).toBeNull();