@agentex/agent 0.0.33 → 0.0.35

package/src/providers/claude/discovery.ts

@@ -0,0 +1,215 @@
+/**
+ * Claude Code model and effort discovery.
+ *
+ * Claude Code ships no catalog subcommand and its SDK init frame reports only
+ * the resolved model, so there is nothing to read the way `codex debug models`
+ * can be read. What the CLI *will* do is validate `--model` and `--effort`
+ * eagerly, before any API call, and say so on stderr when it does not
+ * recognize a value. That turns discovery into two different jobs:
+ *
+ *   Efforts are enumerable. `--help` prints the accepted values inline, so the
+ *   installed binary names them itself. Values it accepts but omits from help
+ *   (`ultracode` today) are recovered by probing the canonical list.
+ *
+ *   Models are not enumerable. Probing can only answer "do you know this one?"
+ *   for names we already ship, so `CLAUDE_MODEL_CANDIDATES` stays a curated
+ *   list. What probing buys is that a name the installed CLI does not know is
+ *   dropped instead of offered and silently ignored at run time.
+ *
+ * Probes run with `--bare` when the binary supports it. The reason is side
+ * effects, not speed: `--bare` skips hooks, LSP, plugin sync, auto-memory, and
+ * keychain reads, so asking "do you know this flag value" cannot fire a user's
+ * SessionStart hook four times. Argument validation still runs under it.
+ * Probes also pass `-p ""`, so the process exits on empty input long before it
+ * would reach the network. No probe costs a token.
+ *
+ * Budget: two serial spawns, then one concurrent batch. `--help` and the
+ * control probe below are each on the critical path; only the per-candidate
+ * probes run in parallel. Measured cold against 2.1.232 that is ~1.8-3s
+ * depending on machine load, against ~0.1s for Codex's single-command
+ * catalog.
+ * Worth caching for minutes rather than seconds: callers should pass
+ * `cacheTtlMs` and keep a static fallback for first paint rather than blocking
+ * a picker on this.
+ */
+import type { ListModelsOptions, ProviderModel } from "../../types.js";
+import { findBinary, type ResolvedBinary } from "../../utils/binary.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { runChildProcess } from "../../utils/process.js";
+import { withModelCache } from "../../utils/model-cache.js";
+import { CLAUDE_EFFORTS, claudeEffortFlagValue, claudeEffortFromFlagValue } from "./effort.js";
+
+/**
+ * Tier aliases rather than pinned versions, so each one keeps meaning "the
+ * newest model in this tier" and the list does not rot between releases. A
+ * genuinely new tier is one line here, gated by the probe so older CLIs that
+ * have never heard of it simply do not show it.
+ */
+export const CLAUDE_MODEL_CANDIDATES: ReadonlyArray<{ id: string; name: string; description: string }> = [
+  { id: "opus", name: "Opus", description: "Always resolves to the newest Opus release" },
+  { id: "sonnet", name: "Sonnet", description: "Always resolves to the newest Sonnet release" },
+  { id: "haiku", name: "Haiku", description: "Always resolves to the newest Haiku release" },
+  { id: "fable", name: "Fable", description: "Always resolves to the newest Fable release" },
+];
+
+/**
+ * The error a probe earns when the flag value was accepted: the CLI got far
+ * enough to care that the prompt was empty. Treated as the positive signal so
+ * an unexpected failure (missing binary, unknown flag, changed wording) reads
+ * as "unsupported" rather than "supported". Discovery that fails open would
+ * offer values the CLI then ignores, which is the exact failure this replaces.
+ */
+const ACCEPTED = /input must be provided/i;
+const UNKNOWN_EFFORTS = /unknown --effort value/i;
+const UNKNOWN_MODEL = /is not a model this version of claude code recognizes/i;
+
+/**
+ * Read the effort values `--help` advertises.
+ *
+ * The option's accepted list is rendered inline and commander wraps it onto a
+ * continuation line, so the scan joins whitespace and stops at the next flag
+ * to avoid swallowing a later option's parenthetical.
+ */
+export function claudeEffortsFromHelp(output: string): string[] {
+  const index = output.indexOf("--effort");
+  if (index === -1) return [];
+  const tail = output.slice(index + "--effort".length);
+  const stop = tail.search(/\n\s*(?:-[a-z]|--[a-z])/i);
+  const block = (stop === -1 ? tail : tail.slice(0, stop)).replace(/\s+/g, " ");
+  const list = block.match(/\(([^)]+)\)/);
+  if (!list?.[1]) return [];
+  const values = list[1]
+    .split(",")
+    .map((value) => value.trim().toLowerCase())
+    .filter((value) => /^[a-z][a-z0-9-]*$/.test(value));
+  return [...new Set(values.map(claudeEffortFromFlagValue))];
+}
+
+/** Order a discovered set by the canonical ladder, unknown values last. */
+function ordered(values: Iterable<string>): string[] {
+  const seen = [...new Set(values)];
+  const rank = (value: string) => {
+    const index = (CLAUDE_EFFORTS as readonly string[]).indexOf(value);
+    return index === -1 ? CLAUDE_EFFORTS.length : index;
+  };
+  return seen.sort((left, right) => rank(left) - rank(right));
+}
+
+interface ClaudeBinary {
+  resolved: ResolvedBinary;
+  env: Record<string, string>;
+  cwd: string;
+}
+
+interface ProbeRuntime extends ClaudeBinary {
+  /** Whether the binary is new enough for `--bare` (see the file header). */
+  bare: boolean;
+  /** `--help` output, already paid for while detecting `--bare`. */
+  help: string;
+}
+
+async function runClaude(runtime: ClaudeBinary, args: string[], timeoutSec = 30): Promise<string> {
+  const result = await runChildProcess({
+    runId: "claude-discovery",
+    command: runtime.resolved.bin,
+    args: [...runtime.resolved.prefixArgs, ...args],
+    cwd: runtime.cwd,
+    env: runtime.env,
+    timeoutSec,
+  });
+  return `${result.stdout}\n${result.stderr}`;
+}
+
+async function probeFlag(
+  runtime: ProbeRuntime,
+  flag: "--model" | "--effort",
+  value: string,
+): Promise<boolean> {
+  const output = await runClaude(
+    runtime,
+    [...(runtime.bare ? ["--bare"] : []), flag, value, "-p", ""],
+  );
+  if (!ACCEPTED.test(output)) return false;
+  return !(flag === "--effort" ? UNKNOWN_EFFORTS : UNKNOWN_MODEL).test(output);
+}
+
+/**
+ * Prove the probe mechanism itself still works, with no flag under test.
+ *
+ * Without this, an empty result is ambiguous: it means both "this CLI
+ * recognizes none of our candidates" and "the probe broke" — a renamed flag, a
+ * reworded error, a binary that will not start. Failing closed only helps if
+ * the caller can tell those apart, and it cannot: falling back to a static list
+ * on a broken probe offers exactly the unvalidated names that failing open
+ * would have. So a broken mechanism throws, and an empty list becomes a real
+ * answer rather than a shrug.
+ */
+async function probeMechanismWorks(runtime: ProbeRuntime): Promise<boolean> {
+  const output = await runClaude(runtime, [...(runtime.bare ? ["--bare"] : []), "-p", ""]);
+  return ACCEPTED.test(output);
+}
+
+/**
+ * Effort values the installed binary accepts, in canonical vocabulary.
+ *
+ * Exported separately because efforts are a property of the CLI rather than of
+ * any one model: Claude takes a single `--effort` flag and applies it to
+ * whatever model the turn runs on.
+ */
+export async function listClaudeEfforts(options: ListModelsOptions = {}): Promise<string[]> {
+  const runtime = await probeRuntime(options);
+  if (!await probeMechanismWorks(runtime)) {
+    throw new Error("Claude Code effort discovery failed: the CLI did not respond as expected to a probe");
+  }
+  return discoverEfforts(runtime);
+}
+
+async function probeRuntime(options: ListModelsOptions): Promise<ProbeRuntime> {
+  const resolved = await findBinary("claude", options.config?.command);
+  const env = buildEnv(options.env);
+  ensurePathInEnv(env);
+  const base: ClaudeBinary = { resolved, env, cwd: options.cwd ?? process.cwd() };
+  // One spawn answers two questions: which efforts the binary advertises, and
+  // whether it understands `--bare` well enough to probe without side effects.
+  const help = await runClaude(base, ["--help"], 15);
+  return { ...base, bare: /--bare\b/.test(help), help };
+}
+
+async function discoverEfforts(runtime: ProbeRuntime): Promise<string[]> {
+  const advertised = claudeEffortsFromHelp(runtime.help);
+  // Anything help omits still gets a probe, so a value the CLI accepts without
+  // documenting is not lost. When help parsing yields nothing this degrades to
+  // probing the whole ladder rather than to returning nothing.
+  const unlisted: string[] = CLAUDE_EFFORTS.filter((effort) => !advertised.includes(effort));
+  const confirmed = await Promise.all(
+    unlisted.map(async (effort) => (
+      await probeFlag(runtime, "--effort", claudeEffortFlagValue(effort)) ? effort : null
+    )),
+  );
+  return ordered([...advertised, ...confirmed.filter((effort): effort is string => effort !== null)]);
+}
+
+export async function listClaudeModels(options: ListModelsOptions = {}): Promise<ProviderModel[]> {
+  return withModelCache("claude", options, options.cacheTtlMs, async () => {
+    const runtime = await probeRuntime(options);
+    // Throwing rather than returning [] keeps "no models" meaningful. Callers
+    // already treat a discovery failure as "use your fallback catalog".
+    if (!await probeMechanismWorks(runtime)) {
+      throw new Error("Claude Code model discovery failed: the CLI did not respond as expected to a probe");
+    }
+    const [supportedEfforts, recognized] = await Promise.all([
+      discoverEfforts(runtime),
+      Promise.all(CLAUDE_MODEL_CANDIDATES.map(async (candidate) => (
+        await probeFlag(runtime, "--model", candidate.id) ? candidate : null
+      ))),
+    ]);
+    return recognized
+      .filter((candidate): candidate is (typeof CLAUDE_MODEL_CANDIDATES)[number] => candidate !== null)
+      .map((candidate) => ({
+        id: candidate.id,
+        name: candidate.name,
+        description: candidate.description,
+        ...(supportedEfforts.length > 0 ? { supportedEfforts } : {}),
+      }));
+  });
+}

package/src/providers/claude/effort.ts

@@ -0,0 +1,34 @@
+/**
+ * Reasoning-effort vocabulary for Claude Code.
+ *
+ * `ProviderConfig.effort` is one shared scale across providers, but the CLIs
+ * do not agree on what to call its top rung: Codex accepts `ultra`, Claude
+ * accepts `ultracode`. Translating at the flag boundary keeps that difference
+ * out of every caller.
+ *
+ * This is not cosmetic. `claude --effort ultra` does not fail — it prints a
+ * warning to stderr and runs the turn at the session default. An untranslated
+ * value is therefore a silent downgrade, indistinguishable at the API surface
+ * from having worked.
+ */
+
+/** Canonical effort ids, weakest to strongest, in the shared vocabulary. */
+export const CLAUDE_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"] as const;
+
+/** Canonical id -> the token `claude --effort` accepts. Identity when absent. */
+const WIRE_VALUES: Record<string, string> = {
+  ultra: "ultracode",
+};
+
+/** The token to pass to `--effort` for a canonical effort id. */
+export function claudeEffortFlagValue(effort: string): string {
+  return WIRE_VALUES[effort] ?? effort;
+}
+
+/** Inverse of `claudeEffortFlagValue`, for reading a CLI-advertised list. */
+export function claudeEffortFromFlagValue(value: string): string {
+  for (const [canonical, wire] of Object.entries(WIRE_VALUES)) {
+    if (wire === value) return canonical;
+  }
+  return value;
+}

package/src/providers/claude/execute.ts

@@ -7,6 +7,7 @@ import { runChildProcess, deriveErrorCode } from "../../utils/process.js";
 import { detectAuth } from "../../utils/auth.js";
 import { buildSkillsDir, cleanupSkillsDir } from "../../utils/skills.js";
 import { claudeFeatureArgs, cleanupMcpConfig, stageMcpConfig } from "./mcp.js";
+import { claudeEffortFlagValue } from "./effort.js";
 import { createToolNameTracker } from "../../utils/tool-names.js";
 import { uuidv7 } from "../../utils/uuid.js";
 import { prepareWorkspace } from "../../utils/workspace.js";
@@ -109,7 +110,7 @@ export async function executeClaudeProvider(ctx: ExecutionContext): Promise<Exec
       args.push("--dangerously-skip-permissions");
     }
     if (model) args.push("--model", model);
-    if (config.effort) args.push("--effort", config.effort);
+    if (config.effort) args.push("--effort", claudeEffortFlagValue(config.effort));
     if (config.maxTurns && config.maxTurns > 0) args.push("--max-turns", String(config.maxTurns));
     if (config.instructionsFile) args.push("--append-system-prompt-file", config.instructionsFile);
     if (skillsDir) args.push("--add-dir", skillsDir);

package/src/providers/claude/index.ts

@@ -20,7 +20,7 @@ export const claudeProvider: ProviderModule = {
   type: "claude",
   capabilities: {
     sessions: true,
-    modelDiscovery: false,
+    modelDiscovery: true,
     quotaProbing: true,
     mcp: true,
     skills: true,
@@ -56,6 +56,7 @@ export const claudeProvider: ProviderModule = {
   createSession: async (ctx: SessionContext): Promise<AgentSession> =>
     (await import("./session.js")).createClaudeSession(ctx),
   resolveAuth: (ctx) => resolveAuthForProvider("claude", ctx),
+  listModels: (options) => import("./discovery.js").then((m) => m.listClaudeModels(options)),
   sessionCodec: claudeSessionCodec,
   checkQuota,
   transcript: claudeTranscriptOps,

package/src/providers/claude/parse.ts

@@ -802,9 +802,19 @@ function normalizedClaudeTaskType(task: ClaudeTaskDetails): "subagent" | "proces
   return "unknown";
 }
 
+/**
+ * Map a reported Claude status onto the neutral vocabulary.
+ *
+ * Returns null when the provider reported nothing, or reported a value this
+ * version does not model. Both mean "we do not know", and saying so is the
+ * point: a `task_updated` patch that only renames a task used to assert
+ * `running` over a real `paused`, and an unmodeled future status used to be
+ * asserted as running rather than left uncertain — which quietly undid the
+ * forward-compat that `claudeTaskDetailsFromRaw` establishes upstream.
+ */
 function normalizedClaudeTaskStatus(
   status: ClaudeTaskStatus | null,
-): "pending" | "running" | "paused" | "completed" | "failed" | "stopped" {
+): "pending" | "running" | "paused" | "completed" | "failed" | "stopped" | null {
   switch (status) {
     case "pending": return "pending";
     case "paused": return "paused";
@@ -812,8 +822,8 @@ function normalizedClaudeTaskStatus(
     case "failed": return "failed";
     case "killed":
     case "stopped": return "stopped";
-    case "running":
-    default: return "running";
+    case "running": return "running";
+    default: return null;
   }
 }
 
@@ -824,15 +834,27 @@ function backgroundTaskEventFromClaude(
   const task = claudeTaskDetailsFromRaw(raw);
   if (!task || !task.taskId) return null;
 
+  // A bare notification is Claude's "this task is done" signal. One that
+  // carries a status is reporting that status, and must be believed.
+  // Inference is allowed only where the event type itself carries the fact: a
+  // bare notification is Claude's "done" signal, and started/progress events
+  // are emitted BY a running task. `task_updated` is a patch — it can carry
+  // nothing but a rename, so it says nothing about liveness and must not
+  // assert `running` over a real `paused`.
+  const implied = task.phase === "started" || task.phase === "progress" ? "running" : null;
   const status = task.phase === "notification" && task.status === null
     ? "completed"
-    : normalizedClaudeTaskStatus(task.status);
+    : normalizedClaudeTaskStatus(task.status) ?? implied;
   const terminal = status === "completed" || status === "failed" || status === "stopped";
   return {
     type: "background_task",
     taskId: task.taskId,
     taskType: normalizedClaudeTaskType(task),
-    phase: terminal || task.phase === "notification"
+    // Terminality is decided by the status alone. Treating every notification
+    // as terminal emitted `phase: "completed"` alongside `status: "running"`,
+    // and hosts are told to drop a task on `phase === "completed"` — so a
+    // mid-flight notification evicted a task the same event said was running.
+    phase: terminal
       ? "completed"
       : task.phase === "started" ? "started" : "progress",
     status,

package/src/providers/claude/session.ts

@@ -26,6 +26,7 @@ import { claudeTranscriptOps } from "./transcript.js";
 import { findBinary } from "../../utils/binary.js";
 import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
 import { translateEndpoint } from "../../utils/endpoint.js";
+import { claudeEffortFlagValue } from "./effort.js";
 import { buildSkillsDir, cleanupSkillsDir } from "../../utils/skills.js";
 import { claudeFeatureArgs, cleanupMcpConfig, stageMcpConfig } from "./mcp.js";
 import { createToolNameTracker } from "../../utils/tool-names.js";
@@ -193,7 +194,7 @@ export async function createClaudeSession(ctx: SessionContext): Promise<AgentSes
     args.push("--permission-prompt-tool", "stdio");
   }
   if (config.model) args.push("--model", config.model);
-  if (config.effort) args.push("--effort", config.effort);
+  if (config.effort) args.push("--effort", claudeEffortFlagValue(config.effort));
   if (config.maxTurns && config.maxTurns > 0) args.push("--max-turns", String(config.maxTurns));
   if (config.instructionsFile) args.push("--append-system-prompt-file", config.instructionsFile);
   if (skillsDir) args.push("--add-dir", skillsDir);

package/src/providers/codex/discovery.ts

@@ -0,0 +1,91 @@
+/**
+ * Codex model discovery.
+ *
+ * `codex debug models` prints the CLI's own catalog as JSON, including the
+ * reasoning levels each model accepts and which one it defaults to. That makes
+ * Codex the one provider here whose efforts are genuinely per-model: 5.6 Sol
+ * advertises `ultra`, 5.5 stops at `xhigh`, and hardcoding either answer would
+ * be wrong for the other.
+ */
+import type { ListModelsOptions, ProviderModel } from "../../types.js";
+import { findBinary } from "../../utils/binary.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { runChildProcess } from "../../utils/process.js";
+import { withModelCache } from "../../utils/model-cache.js";
+
+interface CatalogEntry {
+  slug?: unknown;
+  display_name?: unknown;
+  description?: unknown;
+  visibility?: unknown;
+  supported_reasoning_levels?: unknown;
+  default_reasoning_level?: unknown;
+}
+
+function effortList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set<string>();
+  for (const item of value) {
+    // Entries are objects ({ effort, description }), not bare strings.
+    if (!item || typeof item !== "object") continue;
+    const effort = (item as { effort?: unknown }).effort;
+    if (typeof effort === "string" && effort) seen.add(effort);
+  }
+  return [...seen];
+}
+
+/**
+ * Parse `codex debug models` output.
+ *
+ * Only `visibility: "list"` entries are returned. The CLI also ships hidden
+ * and deprecated slugs that it will accept but does not offer, and surfacing
+ * those as pickable models would be a worse catalog than no catalog.
+ */
+export function parseCodexModelCatalog(raw: string): ProviderModel[] {
+  const parsed = JSON.parse(raw) as { models?: unknown };
+  if (!Array.isArray(parsed.models)) throw new Error("Codex model catalog has no models array");
+
+  const seen = new Set<string>();
+  const models: ProviderModel[] = [];
+  for (const entry of parsed.models as CatalogEntry[]) {
+    if (entry.visibility !== "list") continue;
+    if (typeof entry.slug !== "string" || typeof entry.display_name !== "string") continue;
+    if (seen.has(entry.slug)) continue;
+    seen.add(entry.slug);
+    const supportedEfforts = effortList(entry.supported_reasoning_levels);
+    models.push({
+      id: entry.slug,
+      name: entry.display_name,
+      ...(typeof entry.description === "string" && entry.description
+        ? { description: entry.description.replace(/\.$/, "") }
+        : {}),
+      ...(supportedEfforts.length > 0 ? { supportedEfforts } : {}),
+      ...(typeof entry.default_reasoning_level === "string" && entry.default_reasoning_level
+        ? { defaultEffort: entry.default_reasoning_level }
+        : {}),
+    });
+  }
+
+  if (models.length === 0) throw new Error("Codex model catalog has no visible models");
+  return models;
+}
+
+export async function listCodexModels(options: ListModelsOptions = {}): Promise<ProviderModel[]> {
+  return withModelCache("codex", options, options.cacheTtlMs, async () => {
+    const resolved = await findBinary("codex", options.config?.command);
+    const env = buildEnv(options.env);
+    ensurePathInEnv(env);
+    const result = await runChildProcess({
+      runId: "codex-model-discovery",
+      command: resolved.bin,
+      args: [...resolved.prefixArgs, "debug", "models"],
+      cwd: options.cwd ?? process.cwd(),
+      env,
+      timeoutSec: 15,
+    });
+    if (result.exitCode !== 0) {
+      throw new Error("The installed Codex CLI does not expose `codex debug models`");
+    }
+    return parseCodexModelCatalog(result.stdout || result.stderr);
+  });
+}

package/src/providers/codex/execute.ts

@@ -15,7 +15,7 @@ import type { PreparedWorkspace } from "../../utils/workspace.js";
 import { uuidv7 } from "../../utils/uuid.js";
 import {
   parseCodexJsonl,
-  parseCodexStreamLine,
+  parseCodexStreamLines,
   stripCodexRolloutNoise,
   isCodexAuthRequired,
   isCodexUnknownSessionError,
@@ -165,6 +165,11 @@ export async function executeCodexProvider(ctx: ExecutionContext): Promise<Execu
     // Correlates tool_call → tool_result so emitted tool_result events carry
     // toolName. One tracker per attempt (a retry restarts the stream).
     const trackToolName = createToolNameTracker();
+    // Children still running when the one-shot process ends. `execute()` has no
+    // session to reconcile against, so without a terminal edge here a host that
+    // trusts `capabilities.backgroundTaskEvents` shows those children as
+    // running forever. The session path does the same on shutdown.
+    const openTasks = new Map<string, { description: string | null; parentTaskId: string | null }>();
 
     const handleLine = async (trimmed: string) => {
       if (!trimmed) return;
@@ -177,8 +182,14 @@ export async function executeCodexProvider(ctx: ExecutionContext): Promise<Execu
         } catch { /* ignore */ }
       }
       if (!ctx.onEvent) return;
-      const event = parseCodexStreamLine(trimmed, streamThreadId);
-      if (event) {
+      for (const event of parseCodexStreamLines(trimmed, streamThreadId)) {
+        if (event.type === "background_task") {
+          if (event.phase === "completed") openTasks.delete(event.taskId);
+          else openTasks.set(event.taskId, {
+            description: event.description,
+            parentTaskId: event.parentTaskId,
+          });
+        }
         try { await ctx.onEvent(trackToolName(event)); } catch { /* swallow */ }
       }
     };
@@ -225,6 +236,34 @@ export async function executeCodexProvider(ctx: ExecutionContext): Promise<Execu
       await handleLine(lineBuffer.trim());
     }
 
+    for (const [taskId, task] of openTasks) {
+      if (!ctx.onEvent) break;
+      try {
+        await ctx.onEvent({
+          type: "background_task",
+          taskId,
+          taskType: "subagent",
+          phase: "completed",
+          // "stopped", not "completed": the run ended while this child was
+          // still going. Claiming success for work we never saw finish would
+          // be worse than reporting that it was cut short.
+          status: "stopped",
+          description: task.description,
+          summary: null,
+          parentTaskId: task.parentTaskId,
+          timestamp: new Date().toISOString(),
+          providerType: "codex",
+          sessionId: streamThreadId,
+          messageId: null,
+          eventId: streamThreadId ? `codex:${streamThreadId}:background-task:${taskId}:exit` : null,
+          turnId: null,
+          parentToolCallId: null,
+          raw: { reason: "process_exit" },
+        });
+      } catch { /* swallow */ }
+    }
+    openTasks.clear();
+
     return proc;
   };
 

package/src/providers/codex/index.ts

@@ -8,7 +8,7 @@ export const codexProvider: ProviderModule = {
   type: "codex",
   capabilities: {
     sessions: true,
-    modelDiscovery: false,
+    modelDiscovery: true,
     quotaProbing: false,
     mcp: false,
     skills: true,
@@ -45,6 +45,7 @@ export const codexProvider: ProviderModule = {
   resolveAuth: (ctx) => resolveAuthForProvider("codex", ctx),
   sessionCodec: codexSessionCodec,
   transcript: codexTranscriptOps,
+  listModels: (options) => import("./discovery.js").then((m) => m.listCodexModels(options)),
   listModes: async (opts) => (await import("./modes.js")).listCodexModes(opts),
   attachSession: async (record, opts) =>
     (await import("./attach.js")).attachCodexSession(record, opts),