@jini-ai/agent-runtime 0.3.2 → 0.3.7

package/dist/defs/codex.js

@@ -7,7 +7,88 @@
  * `source-map.md` for the exact original names.
  */
 import { DEFAULT_MODEL_OPTION, clampCodexReasoning } from './shared.js';
-export function parseCodexDebugModels(stdout) {
+/**
+ * The `visibility` values that mean "reachable by id, but do not render in a picker".
+ *
+ * A SET rather than one literal, because the vendor has demonstrably used more than one spelling of
+ * this single state: the shipped Codex catalog says `hide` (verified live against
+ * `codex debug models` 0.153.4 — `gpt-reserve` and `codex-auto-review` both carry it), while this
+ * adapter was originally written against `hidden`. Matching only one of them let every `hide` entry
+ * render in the Local-CLI model picker. Being permissive on input costs nothing here — no real
+ * catalog value is a cased or padded variant of a DIFFERENT visibility state — and it means a third
+ * spelling does not silently reopen the same hole.
+ */
+const HIDDEN_MODEL_VISIBILITIES = new Set(['hide', 'hidden']);
+function isHiddenVisibility(visibility) {
+    return typeof visibility === 'string' && HIDDEN_MODEL_VISIBILITIES.has(visibility.trim().toLowerCase());
+}
+/**
+ * Display labels for the effort levels, keyed by the catalog's own `effort` token.
+ *
+ * Spelled out rather than derived by capitalizing, because `xhigh` renders as `XHigh` — the exact
+ * casing the static `reasoningOptions` list below already used, so a live-derived list and a
+ * fallback list read identically in the picker. Unknown tokens (a level the vendor adds tomorrow)
+ * fall through to a capitalize, which is right often enough and is never worse than dropping the
+ * level entirely.
+ */
+const CODEX_EFFORT_LABELS = {
+    none: 'None', minimal: 'Minimal', low: 'Low', medium: 'Medium',
+    high: 'High', xhigh: 'XHigh', max: 'Max', ultra: 'Ultra',
+};
+function codexEffortLabel(effort) {
+    return CODEX_EFFORT_LABELS[effort] ?? `${effort.charAt(0).toUpperCase()}${effort.slice(1)}`;
+}
+/** Accepts both catalog spellings of a level: the `{ effort, description }` object the live 0.153.x
+ *  catalog emits, and a bare string (the shape an older/simpler catalog could use). */
+function codexEffortToken(raw) {
+    if (typeof raw === 'string')
+        return raw.trim();
+    if (raw && typeof raw === 'object') {
+        const effort = raw.effort;
+        if (typeof effort === 'string')
+            return effort.trim();
+    }
+    return '';
+}
+/**
+ * Reads one catalog entry's `supported_reasoning_levels` into picker options.
+ *
+ * @returns The levels in catalog order, de-duplicated; `undefined` when the entry declares none, so
+ * the model row simply omits the field rather than claiming "supports no effort levels".
+ * @complexity O(n) in the entry's declared level count.
+ */
+function parseCodexEntryReasoning(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const seen = new Set();
+    const out = [];
+    for (const level of raw) {
+        const effort = codexEffortToken(level);
+        if (!effort || seen.has(effort))
+            continue;
+        seen.add(effort);
+        out.push({ id: effort, label: codexEffortLabel(effort) });
+    }
+    return out.length > 0 ? out : undefined;
+}
+function codexEntryId(entry) {
+    if (typeof entry.slug === 'string')
+        return entry.slug.trim();
+    if (typeof entry.id === 'string')
+        return entry.id.trim();
+    return '';
+}
+function codexEntryLabel(entry, id) {
+    if (typeof entry.display_name === 'string' && entry.display_name.trim())
+        return entry.display_name.trim();
+    if (typeof entry.name === 'string' && entry.name.trim())
+        return entry.name.trim();
+    return id;
+}
+/** JSON-decodes `codex debug models` stdout down to its `models` array, or `null` for any shape
+ *  that isn't one. Split out of `parseCodexDebugModels` so that function stays a single readable
+ *  loop over already-validated input. */
+function readCodexCatalogEntries(stdout) {
     let parsed;
     try {
         parsed = JSON.parse(String(stdout || ''));
@@ -18,29 +99,76 @@ export function parseCodexDebugModels(stdout) {
     if (!parsed || typeof parsed !== 'object')
         return null;
     const models = parsed.models;
-    if (!Array.isArray(models))
+    return Array.isArray(models) ? models : null;
+}
+/**
+ * Parses `codex debug models` stdout into the Local-CLI picker's model rows.
+ *
+ * Each row carries the model's OWN supported effort levels when the catalog reports them — see
+ * `RuntimeModelOption.reasoning`. Hidden entries are dropped (see `isHiddenVisibility`).
+ *
+ * @returns The rows, `default` sentinel first; `null` when the output is unparseable or yielded no
+ * model at all, which is `detection.ts#fetchModels`'s signal to keep the static fallback list.
+ * @complexity O(n·m) — one pass over n catalog entries, each with m declared effort levels.
+ */
+/** One catalog entry as a picker row, or `null` when it is malformed, hidden, id-less, or a repeat
+ *  of an id already taken. Split from the loop below purely to keep both units small. */
+function codexCatalogRow(raw, takenIds) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const entry = raw;
+    if (isHiddenVisibility(entry.visibility))
+        return null;
+    const id = codexEntryId(entry);
+    if (!id || takenIds.has(id))
+        return null;
+    const reasoning = parseCodexEntryReasoning(entry.supported_reasoning_levels);
+    return { id, label: codexEntryLabel(entry, id), ...(reasoning ? { reasoning } : {}) };
+}
+export function parseCodexDebugModels(stdout) {
+    const models = readCodexCatalogEntries(stdout);
+    if (!models)
         return null;
     const out = [DEFAULT_MODEL_OPTION];
     const seen = new Set([DEFAULT_MODEL_OPTION.id]);
     for (const raw of models) {
-        if (!raw || typeof raw !== 'object')
-            continue;
-        const entry = raw;
-        if (entry.visibility === 'hidden')
+        const row = codexCatalogRow(raw, seen);
+        if (!row)
             continue;
-        const id = typeof entry.slug === 'string' ? entry.slug.trim() : typeof entry.id === 'string' ? entry.id.trim() : '';
-        if (!id || seen.has(id))
-            continue;
-        seen.add(id);
-        const label = typeof entry.display_name === 'string' && entry.display_name.trim()
-            ? entry.display_name.trim()
-            : typeof entry.name === 'string' && entry.name.trim()
-                ? entry.name.trim()
-                : id;
-        out.push({ id, label });
+        seen.add(row.id);
+        out.push(row);
     }
     return out.length > 1 ? out : null;
 }
+/**
+ * Collapses the per-model effort levels on a fetched model list into the single agent-level list a
+ * picker renders, in first-seen catalog order, behind the `default` sentinel.
+ *
+ * A UNION rather than an intersection: the alternative would offer only the levels EVERY model
+ * supports, which on the live 0.153.4 catalog is `low..xhigh` — precisely the truncated list this
+ * exists to replace, since `gpt-5.5` would veto `max`/`ultra` for `gpt-6-astra`. Over-offering is
+ * the same failure mode the previous hardcoded list already had (it listed `none`/`minimal`, which
+ * no catalog model supports), so this is strictly better; narrowing the offer per SELECTED model is
+ * a picker-side concern, and the data for it rides along on each row's `reasoning` field.
+ *
+ * @param models - A fetched model list; rows without `reasoning` contribute nothing.
+ * @returns The union, or `null` when no row carried levels — the caller's signal to keep its own
+ * static list rather than replace it with an empty one.
+ * @complexity O(n·m) over n models and their m levels.
+ */
+export function unionModelReasoningOptions(models) {
+    const seen = new Set();
+    const out = [];
+    for (const model of models) {
+        for (const level of model.reasoning ?? []) {
+            if (seen.has(level.id))
+                continue;
+            seen.add(level.id);
+            out.push(level);
+        }
+    }
+    return out.length > 0 ? [{ id: 'default', label: 'Default' }, ...out] : null;
+}
 export function codexNeedsDangerFullAccessSandbox(platform = process.platform, env = process.env) {
     // Operator override for deployments where Codex cannot create its
     // workspace-write sandbox, for example unprivileged Linux containers.
@@ -69,12 +197,24 @@ export const codexAgentDef = {
         args: ['login', 'status'],
         timeoutMs: 5000,
     },
+    // The OLD-CLI path: a Codex build new enough to answer `debug models` never renders this list.
+    // Kept current anyway — a stale fallback is invisible until the day the catalog probe fails, and
+    // that is the worst moment to discover it. Current entries first, superseded ones kept below
+    // rather than dropped.
     fallbackModels: [
         DEFAULT_MODEL_OPTION,
+        { id: 'gpt-6-astra', label: 'gpt-6-astra' },
+        { id: 'gpt-5.6-sol', label: 'gpt-5.6-sol' },
+        { id: 'gpt-5.6-terra', label: 'gpt-5.6-terra' },
+        { id: 'gpt-5.6-luna', label: 'gpt-5.6-luna' },
         { id: 'gpt-5.5', label: 'gpt-5.5' },
         { id: 'gpt-5.4', label: 'gpt-5.4' },
         { id: 'gpt-5.4-mini', label: 'gpt-5.4-mini' },
         { id: 'gpt-5.3-codex', label: 'gpt-5.3-codex' },
+        // Found by the freshness guard (R13/MF3) against an older Codex install's BUNDLED catalog:
+        // codex-cli 0.140.0 lists gpt-5.2 as visible when it cannot reach the backend, which is
+        // exactly the population this fallback list serves.
+        { id: 'gpt-5.2', label: 'gpt-5.2' },
         { id: 'gpt-5.1', label: 'gpt-5.1' },
         { id: 'gpt-5.1-codex-mini', label: 'gpt-5.1-codex-mini' },
         { id: 'gpt-5-codex', label: 'gpt-5-codex' },
@@ -82,6 +222,15 @@ export const codexAgentDef = {
         { id: 'o3', label: 'o3' },
         { id: 'o4-mini', label: 'o4-mini' },
     ],
+    // Asserted against a live `codex debug models` run (codex-cli 0.153.4). See
+    // `RuntimeAgentDef.fallbackModelsAssertedAt` and `scripts/check-model-fallback-freshness.ts`.
+    fallbackModelsAssertedAt: '2026-09-05',
+    // The OLD-CLI path only. A Codex build new enough to answer `debug models` gets its effort list
+    // derived from that catalog instead (see `deriveReasoningOptions` below), which is what makes
+    // `max` and `ultra` reachable. This list is deliberately NOT widened to match: it is what a build
+    // too old to have a catalog gets, and `none`/`minimal` — which no model in the current catalog
+    // supports — are exactly the levels such a build did accept. `clampCodexReasoning` still maps
+    // `minimal` to `low` for the late GPT-5 families.
     reasoningOptions: [
         { id: 'default', label: 'Default' },
         { id: 'none', label: 'None' },
@@ -91,6 +240,10 @@ export const codexAgentDef = {
         { id: 'high', label: 'High' },
         { id: 'xhigh', label: 'XHigh' },
     ],
+    // Replaces the list above whenever the live catalog actually reported per-model levels. See
+    // `RuntimeAgentDef.deriveReasoningOptions` for the contract and `unionModelReasoningOptions` for
+    // why a union and not an intersection.
+    deriveReasoningOptions: unionModelReasoningOptions,
     // Prompt is delivered via stdin pipe (gated by `promptViaStdin: true`
     // below) to avoid Windows `spawn ENAMETOOLONG` while keeping Codex on
     // its structured JSON stream. Recent Codex CLI versions reject a bare
@@ -179,7 +332,7 @@ export const codexAgentDef = {
         // not create-only and needs no `resumeSessionId` guard. Pushed for
         // every claimed attachment path the caller hands in here, not only
         // ones actually of kind "image": the caller
-        // (`agent-daemon-server.ts#resolveAttachmentRunFields`, Tovu) already
+        // (`agent-daemon-server.ts#resolveAttachmentRunFields`, in the consuming product) already
         // stopped filtering by kind for the same reason `qoderAgentDef`'s
         // `--attachment` above does not filter either — a same-shaped
         // repeated-flag mechanism, see `imageDelivery`'s doc below.

package/dist/defs/copilot.js

@@ -87,5 +87,19 @@ export const copilotAgentDef = {
     // operator to override this via its own env var if it wants it
     // tighter.
     inactivityTimeoutMs: 30 * 60 * 1000,
+    // No `externalMcpInjection` yet. Copilot CLI has an explicit, run-scoped
+    // flag for this: `--additional-mcp-config <json|@path>`, documented as
+    // session-only and the highest-priority MCP source (it wins over both
+    // `~/.copilot/mcp-config.json` and the auto-discovered project
+    // `.github/mcp.json`/`.mcp.json`) — so, unlike the global-file or
+    // auto-discovery routes this comment previously (incorrectly) treated as
+    // the only options, this one needs neither `COPILOT_HOME` redirection nor
+    // `GITHUB_COPILOT_PROMPT_MODE_WORKSPACE_MCP` trust gating. What's still
+    // unconfirmed is the exact JSON shape the flag expects at its top level
+    // (official docs describe the flag's purpose but not its schema
+    // verbatim) — needs a local `copilot --help`/`copilot mcp --help` check
+    // before wiring, not a guess. Closest candidate for a new strategy: pass
+    // `@<run-scoped-file>` the same way `'claude-mcp-json'` passes a path,
+    // once the schema is confirmed.
 };
 //# sourceMappingURL=copilot.js.map

package/dist/defs/cursor-agent.js

@@ -100,5 +100,16 @@ export const cursorAgentDef = {
     // it here is what makes detection surface an "auth required" badge for
     // Cursor Agent (the generalized probe only runs for adapters that opt in).
     authProbe: { args: ['status'], timeoutMs: 5000 },
+    // No `externalMcpInjection`: Cursor CLI does support native MCP — it
+    // auto-discovers `.cursor/mcp.json` (project) / `~/.cursor/mcp.json`
+    // (global) with project→global→nested precedence, and reportedly has an
+    // `--approve-mcps` flag to skip the interactive trust prompt — but there
+    // is no confirmed explicit `--mcp-config <path>` flag, so wiring it would
+    // mean merging into the project's real `.cursor/mcp.json` (never a
+    // run-scoped file) and needs `--approve-mcps` verified live against this
+    // package's headless spawn shape first. Needs a new
+    // merge-into-existing-file strategy, not a reuse of `'claude-mcp-json'`
+    // (which relies on an explicit per-run path, never auto-discovery — see
+    // `buildClaudeMcpConfigArgs`'s doc for why).
 };
 //# sourceMappingURL=cursor-agent.js.map

package/dist/defs/deepseek.js

@@ -49,5 +49,17 @@ export const deepseekAgentDef = {
     // --auto --model <id>` and any internal quoting.
     maxPromptArgBytes: 30_000,
     streamFormat: 'plain',
+    // No `externalMcpInjection`: CodeWhale (this dispatcher's underlying TUI)
+    // does support native MCP via `DEEPSEEK_MCP_CONFIG=<path>` — an explicit
+    // per-run env override naming an `mcp.json`-shaped file, falling back to
+    // `~/.codewhale/mcp.json` / `~/.deepseek/mcp.json` when unset. That is the
+    // closest of any unwired def here to this package's existing shape
+    // (explicit, run-scoped, no reliance on auto-discovery's interactive
+    // trust prompt), but it is a path-in-an-env-var mechanism — neither
+    // `'claude-mcp-json'` (file path passed as a CLI flag) nor
+    // `'opencode-env-content'`/`'mimo-env-content'` (env var carries the
+    // config *content*, not a path) match it. Cheapest real follow-up
+    // candidate among the 12; needs a 5th strategy, not a stretch of an
+    // existing one.
 };
 //# sourceMappingURL=deepseek.js.map

package/dist/defs/grok-build.js

@@ -101,5 +101,15 @@ export const grokBuildAgentDef = {
     streamFormat: 'plain',
     installUrl: 'https://x.ai/cli',
     docsUrl: 'https://x.ai/cli',
+    // No `externalMcpInjection`: Grok Build does ship native MCP support and
+    // reads `.mcp.json`/Claude/Cursor configs directly ("zero configuration
+    // needed" per xAI's docs) plus `grok mcp enable/disable <name>` CLI
+    // control, but that is auto-discovery of a fixed path, not an explicit
+    // `--mcp-config <path>` flag. `buildArgs` above already had to route around
+    // several non-standard CLI quirks for this def (`--prompt-file` instead of
+    // stdin/argv); auto-discovery risks the same interactive-trust-prompt stall
+    // `'claude-mcp-json'` was built to avoid for Claude Code (see
+    // `buildClaudeMcpConfigArgs`'s doc), unverified here. Needs live
+    // verification before any strategy — new or reused — is safe to assign.
 };
 //# sourceMappingURL=grok-build.js.map

package/dist/defs/opencode.d.ts

@@ -16,6 +16,7 @@ export declare const opencodeAgentDef: {
         timeoutMs: number;
     };
     fallbackModels: import("../types.js").RuntimeModelOption[];
+    fallbackModelsAssertedAt: string;
     buildArgs: (_prompt: string, _imagePaths: string[], _extra: string[] | undefined, options?: import("../types.js").RuntimeBuildOptions | undefined, runtimeContext?: import("../types.js").RuntimeContext | undefined) => string[];
     promptViaStdin: true;
     resumesSessionViaCli: true;

package/dist/defs/opencode.js

@@ -26,12 +26,17 @@ export const opencodeAgentDef = {
     fallbackModels: [
         DEFAULT_MODEL_OPTION,
         {
-            id: 'anthropic/claude-sonnet-4-5',
-            label: 'anthropic/claude-sonnet-4-5',
+            id: 'anthropic/claude-sonnet-5',
+            label: 'anthropic/claude-sonnet-5',
         },
         { id: 'openai/gpt-5', label: 'openai/gpt-5' },
         { id: 'google/gemini-2.5-pro', label: 'google/gemini-2.5-pro' },
     ],
+    // Checked against `packages/ui/src/features/execution/constants.ts`'s current OpenAI preset —
+    // `gpt-5` is a distinct, still-current generation from the newer gpt-5.6 sol/terra/luna tier
+    // names, so it is not stale. See `RuntimeAgentDef.fallbackModelsAssertedAt` and
+    // `scripts/check-model-fallback-freshness.ts`.
+    fallbackModelsAssertedAt: '2026-09-16',
     // OpenCode's CLI help currently exposes model selection and session
     // controls, but not an explicit per-run reasoning / effort flag. Keep
     // `reasoningOptions` undefined and do not synthesize argv for

package/dist/defs/pi.d.ts

@@ -6,6 +6,7 @@ export declare const piAgentDef: {
     versionProbeTimeoutMs: number;
     fetchModels: (resolvedBin: string, env: import("../types.js").RuntimeEnv) => Promise<import("../types.js").RuntimeModelOption[] | null>;
     fallbackModels: import("../types.js").RuntimeModelOption[];
+    fallbackModelsAssertedAt: string;
     reasoningOptions: {
         id: string;
         label: string;

package/dist/defs/pi.js

@@ -34,15 +34,23 @@ export const piAgentDef = {
     fallbackModels: [
         DEFAULT_MODEL_OPTION,
         {
-            id: 'anthropic/claude-sonnet-4-5',
-            label: 'Claude Sonnet 4.5 (anthropic)',
+            id: 'anthropic/claude-sonnet-5',
+            label: 'Claude Sonnet 5 (anthropic)',
         },
-        { id: 'anthropic/claude-opus-4-5', label: 'Claude Opus 4.5 (anthropic)' },
+        { id: 'anthropic/claude-opus-5', label: 'Claude Opus 5 (anthropic)' },
         { id: 'openai/gpt-5', label: 'GPT-5 (openai)' },
-        { id: 'openai/o4-mini', label: 'o4-mini (openai)' },
+        // `o4-mini` is stale — OpenAI's GPT-5.6 family replaced the old flagship/mini/nano naming
+        // with named tiers (sol/terra/luna); `terra` is the mid tier `o4-mini` mapped to. See
+        // `packages/ui/src/features/execution/constants.ts`'s OpenAI preset and
+        // `scripts/check-model-fallback-freshness.ts`.
+        { id: 'openai/gpt-5.6-terra', label: 'GPT-5.6 Terra (openai)' },
         { id: 'google/gemini-2.5-pro', label: 'Gemini 2.5 Pro (google)' },
         { id: 'google/gemini-2.5-flash', label: 'Gemini 2.5 Flash (google)' },
     ],
+    // Asserted against `packages/ui/src/features/execution/constants.ts`'s current OpenAI preset
+    // (gpt-5.6-sol/terra/luna). See `RuntimeAgentDef.fallbackModelsAssertedAt` and
+    // `scripts/check-model-fallback-freshness.ts`.
+    fallbackModelsAssertedAt: '2026-09-16',
     // Thinking level presets mapped to pi's --thinking flag.
     reasoningOptions: [
         { id: 'default', label: 'Default' },

package/dist/defs/qoder.js

@@ -54,5 +54,16 @@ export const qoderAgentDef = {
     // native CLI mechanism, not a workaround. See
     // `types.ts#RuntimeAgentDef.imageDelivery`'s doc.
     imageDelivery: 'native',
+    // No `externalMcpInjection`: Qoder CLI does support native MCP — `qoder
+    // mcp add -s project` writes to `${project}/.mcp.json`, the same filename
+    // Claude Code reads — but only via that CLI-mutation subcommand; no
+    // explicit `--mcp-config <path>` flag or env-content surface was found,
+    // so `buildArgs` above has nothing to point at a run-scoped file with.
+    // Wiring this as `'claude-mcp-json'` would be wrong: that strategy relies
+    // on an explicit per-spawn flag (see `buildClaudeMcpConfigArgs`'s doc),
+    // and Qoder's only path writes into the *project's real* `.mcp.json` via
+    // a stateful CLI call, not this run's isolated one. Promising follow-up
+    // once auto-discovery's headless trust-prompt behavior is verified live
+    // for this CLI specifically.
 };
 //# sourceMappingURL=qoder.js.map

package/dist/defs/qwen.js

@@ -29,5 +29,14 @@ export const qwenAgentDef = {
     },
     promptViaStdin: true,
     streamFormat: 'plain',
+    // No `externalMcpInjection`: Qwen Code (a Gemini CLI fork) does support
+    // native MCP via `mcpServers` in `.qwen/settings.json` (project) /
+    // `~/.qwen/settings.json` (user) — one key alongside unrelated settings,
+    // not a dedicated file — with no confirmed CLI flag to point elsewhere or
+    // force-trust project servers in headless mode. Structurally closest to
+    // the `'opencode-env-content'`/`'mimo-env-content'` merge-into-an-
+    // existing-document pattern, but delivered via a settings *file* at a
+    // fixed relative path rather than an env var, so it doesn't literally fit
+    // either. Needs a new settings.json-merge strategy.
 };
 //# sourceMappingURL=qwen.js.map

package/dist/detection.d.ts

@@ -1,6 +1,25 @@
 import { type AmrProfileResolver } from './amr-profile-resolver.js';
 import type { AgentDiagnostic, DetectedAgent, RuntimeAgentDef, RuntimeModelSource, RuntimeModelOption } from './types.js';
-export declare function detectAgents(configuredEnvByAgent?: Record<string, Record<string, string>>, amrProfileResolver?: AmrProfileResolver): Promise<(Omit<RuntimeAgentDef, "buildArgs" | "listModels" | "fetchModels" | "fallbackModels" | "helpArgs" | "capabilityFlags" | "fallbackBins" | "versionProbeTimeoutMs" | "maxPromptArgBytes" | "env" | "inactivityTimeoutMs" | "authProbe" | "needsAgentLogFile" | "stdoutPolicy" | "runtimeLock"> & {
+type FetchedRuntimeModels = {
+    models: RuntimeModelOption[];
+    source: RuntimeModelSource;
+};
+/** Result of {@link probeAgentModels}: the models to surface and where they came from. */
+export type ProbedAgentModels = FetchedRuntimeModels;
+/**
+ * The model half of {@link detectAgents} for ONE def, without the `--version`/`--help`/auth probes:
+ * resolves the launch path, builds the same probe env, runs the def's `fetchModels`/`listModels`,
+ * and refreshes the live-model validation cache exactly like `detectAgents` does.
+ *
+ * For hosts that do their own cheaper availability check but still want the live model catalog —
+ * without this, such a host can only ever show `fallbackModels`.
+ *
+ * @returns `source: 'live'` when the CLI supplied a list; otherwise the def's `fallbackModels` with
+ * `source: 'fallback'` (including when the binary is not found). Never rejects.
+ * @complexity At most one model-listing spawn, bounded by the def's own timeout.
+ */
+export declare function probeAgentModels(def: RuntimeAgentDef, configuredEnv?: Record<string, string>, amrProfileResolver?: AmrProfileResolver): Promise<ProbedAgentModels>;
+export declare function detectAgents(configuredEnvByAgent?: Record<string, Record<string, string>>, amrProfileResolver?: AmrProfileResolver): Promise<(Omit<RuntimeAgentDef, "buildArgs" | "listModels" | "fetchModels" | "deriveReasoningOptions" | "fallbackModels" | "fallbackModelsAssertedAt" | "helpArgs" | "capabilityFlags" | "fallbackBins" | "versionProbeTimeoutMs" | "maxPromptArgBytes" | "env" | "inactivityTimeoutMs" | "authProbe" | "needsAgentLogFile" | "stdoutPolicy" | "runtimeLock"> & {
     models: RuntimeModelOption[];
     modelsSource: RuntimeModelSource;
     available: boolean;
@@ -11,4 +30,5 @@ export declare function detectAgents(configuredEnvByAgent?: Record<string, Recor
     diagnostics?: AgentDiagnostic[];
 })[]>;
 export declare function detectAgentsStream(configuredEnvByAgent?: Record<string, Record<string, string>>, amrProfileResolver?: AmrProfileResolver): AsyncGenerator<DetectedAgent>;
+export {};
 //# sourceMappingURL=detection.d.ts.map

package/dist/detection.js

@@ -153,6 +153,53 @@ async function probeCapabilities(def, launchPath, env) {
         return {};
     }
 }
+/**
+ * The effort-level override a live model catalog earns, if any.
+ *
+ * `stripFns` already carries the def's static `reasoningOptions` through, so this returns a spread
+ * fragment that REPLACES it only when the def declares `deriveReasoningOptions` AND that hook found
+ * real per-model levels in the fetched list. Every other case — no hook, an older CLI whose catalog
+ * carries no levels, a fallback list — returns `{}` and leaves the static declaration untouched, so
+ * this can only add accuracy and never empties a picker's effort choices.
+ *
+ * @param models - The models `fetchModels` actually surfaced (live or fallback).
+ * @complexity O(1) here; the hook's own cost is documented on `deriveReasoningOptions`.
+ */
+function derivedReasoningOverride(def, models) {
+    const derived = def.deriveReasoningOptions?.(models);
+    return derived && derived.length > 0 ? { reasoningOptions: derived } : {};
+}
+/** The env every probe of one def spawns with — the same env a real run would see. */
+function probeEnvForLaunch(def, configuredEnv, launch) {
+    return applyAgentLaunchEnv(spawnEnvForAgent(def.id, { ...process.env, ...(def.env || {}) }, configuredEnv, undefined, {}), launch);
+}
+/**
+ * The model half of {@link detectAgents} for ONE def, without the `--version`/`--help`/auth probes:
+ * resolves the launch path, builds the same probe env, runs the def's `fetchModels`/`listModels`,
+ * and refreshes the live-model validation cache exactly like `detectAgents` does.
+ *
+ * For hosts that do their own cheaper availability check but still want the live model catalog —
+ * without this, such a host can only ever show `fallbackModels`.
+ *
+ * @returns `source: 'live'` when the CLI supplied a list; otherwise the def's `fallbackModels` with
+ * `source: 'fallback'` (including when the binary is not found). Never rejects.
+ * @complexity At most one model-listing spawn, bounded by the def's own timeout.
+ */
+export async function probeAgentModels(def, configuredEnv = {}, amrProfileResolver = noopAmrProfileResolver) {
+    try {
+        const launch = resolveAgentLaunch(def, configuredEnv);
+        if (!launch.launchPath)
+            return { models: def.fallbackModels, source: 'fallback' };
+        const probeEnv = probeEnvForLaunch(def, configuredEnv, launch);
+        const fetched = await fetchModels(def, launch.launchPath, probeEnv);
+        const result = withRememberedAmrModels(def, probeEnv, fetched, amrProfileResolver);
+        rememberDetectedModelList(def, configuredEnv, result.models, amrProfileResolver);
+        return result;
+    }
+    catch {
+        return { models: def.fallbackModels, source: 'fallback' };
+    }
+}
 async function probe(def, configuredEnv = {}, amrProfileResolver) {
     // Detection must probe the exact path the runtime will spawn, not just
     // the PATH-visible shim. This is load-bearing under nvm/fnm/mise: the
@@ -166,7 +213,7 @@ async function probe(def, configuredEnv = {}, amrProfileResolver) {
     if (!launch.selectedPath || !launch.launchPath) {
         return unavailableAgent(def, [buildExecutableDiagnostic(def, configuredEnv)]);
     }
-    const probeEnv = applyAgentLaunchEnv(spawnEnvForAgent(def.id, { ...process.env, ...(def.env || {}) }, configuredEnv, undefined, {}), launch);
+    const probeEnv = probeEnvForLaunch(def, configuredEnv, launch);
     const outcome = await probeVersionAtPath(def, launch.launchPath, probeEnv);
     if (outcome.kind === 'not-invocable') {
         return unavailableAgent(def, [buildNotInvocableDiagnostic(def, launch, outcome.cause)]);
@@ -188,6 +235,7 @@ async function probe(def, configuredEnv = {}, amrProfileResolver) {
     const authDiagnostic = auth ? buildAuthDiagnostic(def, auth) : null;
     return {
         ...stripFns(def),
+        ...derivedReasoningOverride(def, surfacedModelResult.models),
         models: surfacedModelResult.models,
         modelsSource: surfacedModelResult.source,
         available: true,
@@ -199,6 +247,10 @@ async function probe(def, configuredEnv = {}, amrProfileResolver) {
     };
 }
 function stripFns(def) {
+    // `deriveReasoningOptions` is dropped with the other closures, and for the same reason
+    // `buildArgs` is: a registry consumer has no model list to feed it and `JSON.stringify`
+    // would publish nothing where the function was. Its RESULT already shipped — `probe`
+    // applies it to `reasoningOptions` before this projection runs.
     // Drop the buildArgs / listModels closures but keep declarative metadata
     // (reasoningOptions, streamFormat, name, bin, etc.). `models` is
     // populated separately by `fetchModels`, so we strip the static
@@ -213,7 +265,7 @@ function stripFns(def) {
     // matter extra because they carry closures — `JSON.stringify` would drop
     // the functions but keep their enclosing objects, publishing a misleading
     // `{"buffering":"until-close"}` / `{}` instead of omitting them.
-    const { buildArgs: _buildArgs, listModels: _listModels, fetchModels: _fetchModels, fallbackModels: _fallbackModels, helpArgs: _helpArgs, capabilityFlags: _capabilityFlags, fallbackBins: _fallbackBins, versionProbeTimeoutMs: _versionProbeTimeoutMs, maxPromptArgBytes: _maxPromptArgBytes, env: _env, inactivityTimeoutMs: _inactivityTimeoutMs, authProbe: _authProbe, needsAgentLogFile: _needsAgentLogFile, stdoutPolicy: _stdoutPolicy, runtimeLock: _runtimeLock, ...rest } = def;
+    const { buildArgs: _buildArgs, listModels: _listModels, fetchModels: _fetchModels, deriveReasoningOptions: _deriveReasoningOptions, fallbackModels: _fallbackModels, fallbackModelsAssertedAt: _fallbackModelsAssertedAt, helpArgs: _helpArgs, capabilityFlags: _capabilityFlags, fallbackBins: _fallbackBins, versionProbeTimeoutMs: _versionProbeTimeoutMs, maxPromptArgBytes: _maxPromptArgBytes, env: _env, inactivityTimeoutMs: _inactivityTimeoutMs, authProbe: _authProbe, needsAgentLogFile: _needsAgentLogFile, stdoutPolicy: _stdoutPolicy, runtimeLock: _runtimeLock, ...rest } = def;
     return rest;
 }
 async function safeProbe(def, configuredEnv = {}, amrProfileResolver) {
@@ -229,12 +281,15 @@ async function safeProbe(def, configuredEnv = {}, amrProfileResolver) {
     }
 }
 function rememberDetectedLiveModels(def, configuredEnv, agent, amrProfileResolver) {
-    if (def.id === 'amr' && agent.models.length === 0)
+    rememberDetectedModelList(def, configuredEnv, agent.models, amrProfileResolver);
+}
+function rememberDetectedModelList(def, configuredEnv, models, amrProfileResolver) {
+    if (def.id === 'amr' && models.length === 0)
         return;
     const scope = def.id === 'amr'
         ? amrModelScopeFromEnv({ ...process.env, ...(def.env || {}), ...configuredEnv }, amrProfileResolver)
         : null;
-    rememberLiveModels(agent.id, agent.models, scope);
+    rememberLiveModels(def.id, models, scope);
 }
 export async function detectAgents(configuredEnvByAgent = {}, amrProfileResolver = noopAmrProfileResolver) {
     const results = await Promise.all(AGENT_DEFS.map((def) => safeProbe(def, configuredEnvByAgent?.[def.id] ?? {}, amrProfileResolver)));

package/dist/registry.d.ts

@@ -3,7 +3,8 @@ export declare const BASE_AGENT_DEFS: RuntimeAgentDef[];
 export declare const AGENT_DEFS: RuntimeAgentDef[];
 export declare function getAgentDef(id: string): RuntimeAgentDef | null;
 /**
- * Whether a caller can inject external MCP servers (Tovu/Jini tools) into a session run by this
+ * Whether a caller can inject external MCP servers (the host application's or this engine's own
+ * tools) into a session run by this
  * def, per its own `externalMcpInjection` declaration (`types.ts`'s own doc names the six wired
  * strategies and the defs that leave the field `undefined` because the CLI has no mechanism to
  * receive one — `aider`, `amp`, `copilot`, `cursor-agent`, `deepseek`, `grok-build`, `pi`,

package/dist/registry.js

@@ -56,7 +56,8 @@ export function getAgentDef(id) {
     return AGENT_DEFS.find((a) => a.id === id) || null;
 }
 /**
- * Whether a caller can inject external MCP servers (Tovu/Jini tools) into a session run by this
+ * Whether a caller can inject external MCP servers (the host application's or this engine's own
+ * tools) into a session run by this
  * def, per its own `externalMcpInjection` declaration (`types.ts`'s own doc names the six wired
  * strategies and the defs that leave the field `undefined` because the CLI has no mechanism to
  * receive one — `aider`, `amp`, `copilot`, `cursor-agent`, `deepseek`, `grok-build`, `pi`,