@jini-ai/agent-runtime 0.3.6 → 0.3.8

package/dist/claude-code-models.d.ts

@@ -0,0 +1,63 @@
+import type { RuntimeEnv, RuntimeModelOption } from './types.js';
+/** The single stdin line that asks the CLI for its initialize payload (which carries `models`). */
+export declare const CLAUDE_CODE_INITIALIZE_REQUEST = "{\"type\":\"control_request\",\"request_id\":\"jini-model-probe\",\"request\":{\"subtype\":\"initialize\"}}\n";
+/**
+ * argv for the initialize probe.
+ *
+ * `--no-session-persistence`: no transcript is written. `--strict-mcp-config` with no `--mcp-config`:
+ * none of the operator's MCP servers are started. `disableAllHooks`: the operator's SessionStart
+ * hooks do not fire for a metadata probe (verified: without it, two user hooks ran). User settings
+ * are otherwise kept, because they can change what the picker offers (e.g. `availableModels`).
+ */
+export declare const CLAUDE_CODE_INITIALIZE_ARGS: readonly string[];
+/** Strips the bracketed context-window variant marker (`claude-fable-5-1[1m]`) —
+ *  `models.ts#sanitizeCustomModel` rejects brackets, and `--model` accepts the bare name. */
+export declare function normalizeClaudePickerModelId(raw: string): string;
+/** Outcome of parsing `~/.claude.json`. The failure reasons are distinct so the freshness guard can
+ *  say WHY it skipped; the runtime treats every failure as "nothing to add". */
+export type ClaudeCodePickerCacheParse = {
+    readonly ok: true;
+    readonly ids: readonly string[];
+} | {
+    readonly ok: false;
+    readonly reason: 'invalid-json' | 'no-cache' | 'no-usable-values';
+};
+/**
+ * Parses the raw text of `~/.claude.json` down to the model ids in `additionalModelOptionsCache`.
+ *
+ * @returns Normalized ids (bracket suffix stripped), or a typed reason. Never throws.
+ * @complexity O(n) over the cache entries (plus the JSON parse of the whole file).
+ */
+export declare function parseClaudeCodePickerCache(raw: string): ClaudeCodePickerCacheParse;
+/**
+ * Parses the CLI's stream-json stdout for the initialize `control_response` and returns its model
+ * rows (aliases and concrete ids, bracket suffixes stripped, deduped, `default` excluded).
+ *
+ * @returns The rows, or `null` when no well-formed response with at least one usable model exists.
+ * @complexity O(s + n) over the stdout length and the n models listed.
+ */
+export declare function parseClaudeInitializeModels(stdout: string): RuntimeModelOption[] | null;
+/** Where Claude Code keeps `.claude.json` for this env: `$CLAUDE_CONFIG_DIR` when set, else HOME. */
+export declare function resolveClaudeConfigPath(env: RuntimeEnv): string;
+/** The two I/O edges, injectable so tests never spawn a real CLI or read the real home dir. */
+export interface ClaudeCodeModelIo {
+    /** Runs the initialize probe; resolves to whatever stdout was captured, or `null`. Never rejects. */
+    runInitialize(bin: string, env: RuntimeEnv): Promise<string | null>;
+    /** Reads a file as UTF-8, or `null` when missing/unreadable. Never rejects. */
+    readConfigFile(path: string): Promise<string | null>;
+}
+/** Test-only: install fake I/O (or `null` to restore the real one) and clear the process cache. */
+export declare function setClaudeCodeModelIoForTesting(io: ClaudeCodeModelIo | null): void;
+/**
+ * Returns the `claude` model list with the CLI's own picker catalog merged in, or `null` when there
+ * is nothing to merge. Needs no API key.
+ *
+ * @param bin - The resolved `claude` (or fork) binary detection found.
+ * @param env - The composed environment for the agent — what a spawn would actually see.
+ * @param fallbackModels - The def's static list; always fully present, in order, in a non-null result.
+ * @param now - Injectable clock for TTL tests.
+ * @complexity O(f + l) plus, at most once per {@link CLAUDE_CODE_MODEL_CACHE_TTL_MS} per cache key,
+ * one CLI spawn bounded by {@link CLAUDE_CODE_INIT_TIMEOUT_MS} and one file read.
+ */
+export declare function loadClaudeCodeModels(bin: string, env: RuntimeEnv, fallbackModels: readonly RuntimeModelOption[], now?: () => number): Promise<RuntimeModelOption[] | null>;
+//# sourceMappingURL=claude-code-models.d.ts.map

package/dist/claude-code-models.js

@@ -0,0 +1,252 @@
+/**
+ * @module claude-code-models
+ *
+ * Credential-free live model discovery for the `claude` runtime def — the `claude` analogue of
+ * `codex debug models`.
+ *
+ * **Why this exists.** `claude` has no list-models subcommand, so without an `ANTHROPIC_API_KEY` the
+ * picker used to render `defs/claude.ts`'s hand-written `CLAUDE_FALLBACK_MODELS` and nothing else. A
+ * subscription-only install therefore never saw a new model (e.g. `claude-opus-5-5`) until someone
+ * edited that array and republished.
+ *
+ * **The two sources, both needing no API key** (verified live against Claude Code 2.1.280):
+ *
+ *   1. The CLI's own `/model` picker list, via the stream-json control protocol. Writing ONE
+ *      `{"type":"control_request","request":{"subtype":"initialize"}}` line to
+ *      `claude -p --input-format stream-json --output-format stream-json --verbose` and closing stdin
+ *      makes the CLI answer with a `control_response` whose `response.models` is exactly the rows its
+ *      interactive `/model` picker renders — the binary's built-in models PLUS the server-fetched
+ *      "additional" options — then exit 0. No user message is ever sent, so no model call is made
+ *      and nothing is billed; it authenticates with whatever the CLI itself uses (subscription OAuth
+ *      included). This is the same `initialize` handshake the Claude Agent SDK's `supportedModels()`
+ *      rides on.
+ *   2. `~/.claude.json`'s `additionalModelOptionsCache` — the server-fetched "additional" picker rows
+ *      Claude Code persists on every session start's bootstrap fetch (headless `-p` runs included;
+ *      it only rewrites the file when the payload changed). Only the server's extras, NOT the
+ *      built-in rows, so it is strictly weaker than (1); it is read only when (1) yields nothing — an
+ *      older CLI without the control protocol, a fork bin (`openclaude`), a timeout.
+ *
+ * **Enrichment, never a gate.** Every failure resolves to `null` ("nothing to add"), and a non-null
+ * result is always `mergeLiveModels(fallback, live)` — the static list is fully present, in order.
+ *
+ * The cache-file parser ({@link parseClaudeCodePickerCache}) is shared with
+ * `scripts/check-model-fallback-freshness.ts` so the freshness guard and the runtime can never
+ * disagree about what that cache says.
+ */
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import { join } from 'node:path';
+import { createCommandInvocation } from '@jini-ai/platform';
+import { mergeLiveModels } from './anthropic-live-models.js';
+import { sanitizeCustomModel } from './models.js';
+/** A spawn costs ~2.5s and the picker list only moves when Claude Code updates or the server's
+ *  "additional" options change, so one answer is trusted for this long per process. Failures are
+ *  cached for the same window so a broken CLI is not re-spawned on every detection pass. */
+const CLAUDE_CODE_MODEL_CACHE_TTL_MS = 30 * 60_000;
+/** Measured ~2.5s on a warm machine (the CLI performs its bootstrap fetch before answering). */
+const CLAUDE_CODE_INIT_TIMEOUT_MS = 8_000;
+/** The single stdin line that asks the CLI for its initialize payload (which carries `models`). */
+export const CLAUDE_CODE_INITIALIZE_REQUEST = '{"type":"control_request","request_id":"jini-model-probe","request":{"subtype":"initialize"}}\n';
+/**
+ * argv for the initialize probe.
+ *
+ * `--no-session-persistence`: no transcript is written. `--strict-mcp-config` with no `--mcp-config`:
+ * none of the operator's MCP servers are started. `disableAllHooks`: the operator's SessionStart
+ * hooks do not fire for a metadata probe (verified: without it, two user hooks ran). User settings
+ * are otherwise kept, because they can change what the picker offers (e.g. `availableModels`).
+ */
+export const CLAUDE_CODE_INITIALIZE_ARGS = [
+    '-p',
+    '--input-format', 'stream-json',
+    '--output-format', 'stream-json',
+    '--verbose',
+    '--no-session-persistence',
+    '--strict-mcp-config',
+    '--settings', '{"disableAllHooks":true}',
+];
+/** Strips the bracketed context-window variant marker (`claude-fable-5-1[1m]`) —
+ *  `models.ts#sanitizeCustomModel` rejects brackets, and `--model` accepts the bare name. */
+export function normalizeClaudePickerModelId(raw) {
+    return raw.replace(/\[[^\]]*\]$/, '').trim();
+}
+/**
+ * Parses the raw text of `~/.claude.json` down to the model ids in `additionalModelOptionsCache`.
+ *
+ * @returns Normalized ids (bracket suffix stripped), or a typed reason. Never throws.
+ * @complexity O(n) over the cache entries (plus the JSON parse of the whole file).
+ */
+export function parseClaudeCodePickerCache(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { ok: false, reason: 'invalid-json' };
+    }
+    const cached = parsed && typeof parsed === 'object'
+        ? parsed.additionalModelOptionsCache
+        : undefined;
+    if (!Array.isArray(cached) || cached.length === 0)
+        return { ok: false, reason: 'no-cache' };
+    const ids = cached
+        .map((entry) => (entry && typeof entry === 'object' ? entry.value : null))
+        .filter((value) => typeof value === 'string')
+        .map(normalizeClaudePickerModelId)
+        .filter((id) => id.length > 0);
+    return ids.length > 0 ? { ok: true, ids } : { ok: false, reason: 'no-usable-values' };
+}
+/** Pulls `response.response.models` out of the one `control_response` line, or `null`. */
+function findInitializeModels(stdout) {
+    for (const line of stdout.split('\n')) {
+        if (!line.includes('control_response'))
+            continue;
+        try {
+            const msg = JSON.parse(line);
+            if (msg.type !== 'control_response' || msg.response?.subtype !== 'success')
+                continue;
+            const models = msg.response.response?.models;
+            if (Array.isArray(models))
+                return models;
+        }
+        catch {
+            // Not a JSON line (or a truncated one on timeout) — keep scanning.
+        }
+    }
+    return null;
+}
+/** The picker rows one initialize entry contributes: its selection value (an alias like `sonnet`,
+ *  or a full id) and the concrete model it resolves to. `default` is the sentinel the fallback list
+ *  already carries; anything `sanitizeCustomModel` would refuse is dropped rather than rendered. */
+function initializeEntryRows(entry) {
+    const rows = [];
+    const displayName = typeof entry.displayName === 'string' ? entry.displayName : '';
+    for (const raw of [entry.value, entry.resolvedModel]) {
+        if (typeof raw !== 'string')
+            continue;
+        const id = normalizeClaudePickerModelId(raw);
+        if (id === 'default' || sanitizeCustomModel(id) !== id)
+            continue;
+        const isAlias = !id.startsWith('claude-');
+        rows.push({ id, label: isAlias && displayName ? `${displayName} (alias)` : id });
+    }
+    return rows;
+}
+/**
+ * Parses the CLI's stream-json stdout for the initialize `control_response` and returns its model
+ * rows (aliases and concrete ids, bracket suffixes stripped, deduped, `default` excluded).
+ *
+ * @returns The rows, or `null` when no well-formed response with at least one usable model exists.
+ * @complexity O(s + n) over the stdout length and the n models listed.
+ */
+export function parseClaudeInitializeModels(stdout) {
+    const models = findInitializeModels(String(stdout || ''));
+    if (!models)
+        return null;
+    const seen = new Set();
+    const out = [];
+    for (const raw of models) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        for (const row of initializeEntryRows(raw)) {
+            if (seen.has(row.id))
+                continue;
+            seen.add(row.id);
+            out.push(row);
+        }
+    }
+    return out.length > 0 ? out : null;
+}
+/** Where Claude Code keeps `.claude.json` for this env: `$CLAUDE_CONFIG_DIR` when set, else HOME. */
+export function resolveClaudeConfigPath(env) {
+    const configDir = typeof env.CLAUDE_CONFIG_DIR === 'string' ? env.CLAUDE_CONFIG_DIR.trim() : '';
+    if (configDir)
+        return join(configDir, '.claude.json');
+    const home = typeof env.HOME === 'string' && env.HOME.trim() ? env.HOME.trim() : os.homedir();
+    return join(home, '.claude.json');
+}
+function runInitializeProbe(bin, env) {
+    return new Promise((resolve) => {
+        try {
+            const invocation = createCommandInvocation({ command: bin, args: [...CLAUDE_CODE_INITIALIZE_ARGS], env });
+            const child = execFile(invocation.command, invocation.args, {
+                env: env,
+                // Neutral cwd, same reason as `invocation.ts#execAgentFile`: a metadata probe must never
+                // pick up (or write into) a project directory.
+                cwd: os.tmpdir(),
+                timeout: CLAUDE_CODE_INIT_TIMEOUT_MS,
+                maxBuffer: 8 * 1024 * 1024,
+                windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+            }, 
+            // A timeout or non-zero exit still hands back what was captured; the parser decides.
+            (_err, stdout) => resolve(typeof stdout === 'string' ? stdout : String(stdout ?? '')));
+            child.stdin?.on('error', () => { });
+            child.stdin?.end(CLAUDE_CODE_INITIALIZE_REQUEST);
+        }
+        catch {
+            resolve(null);
+        }
+    });
+}
+const defaultIo = {
+    runInitialize: runInitializeProbe,
+    readConfigFile: (path) => readFile(path, 'utf8').catch(() => null),
+};
+let activeIo = defaultIo;
+const cache = new Map();
+/** Test-only: install fake I/O (or `null` to restore the real one) and clear the process cache. */
+export function setClaudeCodeModelIoForTesting(io) {
+    activeIo = io ?? defaultIo;
+    cache.clear();
+}
+/** One cache slot per binary + config location + auth-affecting env, fingerprinted so no secret is
+ *  retained as a `Map` key. Two accounts on one host must not share a picker list. */
+function cacheKeyFor(bin, env) {
+    const auth = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'CLAUDE_CODE_OAUTH_TOKEN']
+        .map((name) => (typeof env[name] === 'string' ? env[name] : ''))
+        .join('\u0000');
+    const fingerprint = createHash('sha256').update(auth).digest('hex').slice(0, 16);
+    return `${bin}\u0000${resolveClaudeConfigPath(env)}\u0000${fingerprint}`;
+}
+/** Source (1), then source (2). Never rejects. */
+async function discoverClaudeCodeModels(bin, env) {
+    try {
+        const stdout = await activeIo.runInitialize(bin, env);
+        const fromCli = stdout ? parseClaudeInitializeModels(stdout) : null;
+        if (fromCli)
+            return fromCli;
+        const raw = await activeIo.readConfigFile(resolveClaudeConfigPath(env));
+        const cached = raw === null ? null : parseClaudeCodePickerCache(raw);
+        if (!cached?.ok)
+            return null;
+        return cached.ids
+            .filter((id) => sanitizeCustomModel(id) === id)
+            .map((id) => ({ id, label: id }));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Returns the `claude` model list with the CLI's own picker catalog merged in, or `null` when there
+ * is nothing to merge. Needs no API key.
+ *
+ * @param bin - The resolved `claude` (or fork) binary detection found.
+ * @param env - The composed environment for the agent — what a spawn would actually see.
+ * @param fallbackModels - The def's static list; always fully present, in order, in a non-null result.
+ * @param now - Injectable clock for TTL tests.
+ * @complexity O(f + l) plus, at most once per {@link CLAUDE_CODE_MODEL_CACHE_TTL_MS} per cache key,
+ * one CLI spawn bounded by {@link CLAUDE_CODE_INIT_TIMEOUT_MS} and one file read.
+ */
+export async function loadClaudeCodeModels(bin, env, fallbackModels, now = Date.now) {
+    const key = cacheKeyFor(bin, env);
+    const cached = cache.get(key);
+    const pending = cached && cached.expiresAt > now() ? cached.value : null;
+    const value = pending ?? discoverClaudeCodeModels(bin, env);
+    if (!pending)
+        cache.set(key, { expiresAt: now() + CLAUDE_CODE_MODEL_CACHE_TTL_MS, value });
+    const live = await value;
+    return live && live.length > 0 ? mergeLiveModels(fallbackModels, live) : null;
+}
+//# sourceMappingURL=claude-code-models.js.map

package/dist/defs/aider.d.ts

@@ -4,6 +4,7 @@ export declare const aiderAgentDef: {
     bin: string;
     versionArgs: string[];
     fallbackModels: import("../types.js").RuntimeModelOption[];
+    fallbackModelsAssertedAt: string;
     buildArgs: (prompt: string, _imagePaths: string[], _extra: string[] | undefined, options?: import("../types.js").RuntimeBuildOptions | undefined) => string[];
     maxPromptArgBytes: number;
     streamFormat: string;

package/dist/defs/aider.js

@@ -14,10 +14,19 @@ export const aiderAgentDef = {
     fallbackModels: [
         DEFAULT_MODEL_OPTION,
         { id: 'sonnet', label: 'sonnet' },
-        { id: 'gpt-4o', label: 'gpt-4o' },
+        // `gpt-4o` is stale — OpenAI's GPT-5.6 family replaced the old flagship/mini/nano naming
+        // with named tiers (sol/terra/luna); `sol` is the flagship `gpt-4o` mapped to, bare (no
+        // `openai/` prefix) to match this list's existing LiteLLM-provider-default spelling. See
+        // `packages/ui/src/features/execution/constants.ts`'s OpenAI preset and
+        // `scripts/check-model-fallback-freshness.ts`.
+        { id: 'gpt-5.6-sol', label: 'gpt-5.6-sol' },
         { id: 'deepseek/deepseek-chat', label: 'deepseek/deepseek-chat' },
         { id: 'gemini/gemini-2.0-flash', label: 'gemini/gemini-2.0-flash' },
     ],
+    // 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',
     // Aider's one-shot mode requires the prompt as `--message <text>` on
     // argv; neither `--message` nor `--message-file` accept `-` as a stdin
     // sentinel (it is treated as a literal filename), so we cannot pipe

package/dist/defs/claude.d.ts

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

package/dist/defs/claude.js

@@ -30,7 +30,8 @@
 import { agentCapabilities } from '../capabilities.js';
 import { buildClaudeMcpConfigArgs, DEFAULT_MODEL_OPTION } from './shared.js';
 import { loadMmdRouteModels } from '../mmd-routes.js';
-import { loadAnthropicLiveModels } from '../anthropic-live-models.js';
+import { loadAnthropicLiveModels, mergeLiveModels } from '../anthropic-live-models.js';
+import { loadClaudeCodeModels } from '../claude-code-models.js';
 /**
  * The levels `claude --effort` accepts, as the CLI itself reports them when
  * given an unknown one. Anything outside this set is dropped rather than
@@ -43,8 +44,9 @@ const CLAUDE_EFFORT_LEVELS = new Set([
 ]);
 /**
  * The list a picker renders when nothing live is available — no `~/.config/mms/model-routes.json`,
- * no `ANTHROPIC_API_KEY` in the agent's environment, or a failed live call. Not the primary source:
- * see `fetchModels` below.
+ * the CLI's own picker catalog unreadable (see `claude-code-models.ts`), and no `ANTHROPIC_API_KEY`
+ * in the agent's environment or a failed live call. Not the primary source: see `fetchModels` below.
+ * Every live source is unioned ON TOP of this list, so it is also the floor that never shrinks.
  *
  * Ordered current-first, then the still-active-but-superseded generations, which are KEPT rather
  * than dropped — an installed CLI may be pinned to one via its own config, and removing a working
@@ -113,11 +115,14 @@ export const claudeAgentDef = {
     //   1. Local mmd/MMS routes, when `~/.config/mms/model-routes.json` exists — an explicit local
     //      routing config is the operator's own authoritative statement of what this CLI can reach,
     //      including proxy-backed Claude-compatible models the vendor API knows nothing about.
-    //   2. The account's live Anthropic catalog, when `ANTHROPIC_API_KEY` is in this agent's
-    //      environment. Merged ON TOP of the static list, never in place of it.
-    //   3. The static list, for the ordinary Local-CLI case: subscription-authenticated `claude`,
-    //      no API key anywhere. This is the common path and it must stay zero-latency, which is why
-    //      step 2 makes no network call at all when no key is resolvable.
+    //   2. Otherwise, the UNION of two live sources, run in parallel:
+    //      a. The CLI's own `/model` picker catalog — NO credential needed (subscription auth
+    //         works). See `claude-code-models.ts`: the stream-json `initialize` control request,
+    //         falling back to `~/.claude.json`'s `additionalModelOptionsCache`. Cached per process.
+    //      b. The account's live Anthropic catalog, when `ANTHROPIC_API_KEY` is in this agent's
+    //         environment (makes no network call at all without a key).
+    //      Both are merged ON TOP of the static list, never in place of it; neither shadows the other.
+    //   3. The static list, when neither live source answers.
     //
     // Returning `null` from any step is "nothing to add", and `detection.ts#fetchModels` renders
     // `fallbackModels` for it — so a live-discovery failure can never empty or shrink the picker.
@@ -126,8 +131,18 @@ export const claudeAgentDef = {
     // `~/.claude.json`'s server-fetched `additionalModelOptionsCache`. See
     // `RuntimeAgentDef.fallbackModelsAssertedAt` and `scripts/check-model-fallback-freshness.ts`.
     fallbackModelsAssertedAt: '2026-09-05',
-    fetchModels: async (_resolvedBin, env) => (await loadMmdRouteModels(env, CLAUDE_FALLBACK_MODELS))
-        ?? (await loadAnthropicLiveModels(env, CLAUDE_FALLBACK_MODELS)),
+    fetchModels: async (resolvedBin, env) => {
+        const routed = await loadMmdRouteModels(env, CLAUDE_FALLBACK_MODELS);
+        if (routed)
+            return routed;
+        const [fromCli, fromApi] = await Promise.all([
+            loadClaudeCodeModels(resolvedBin, env, CLAUDE_FALLBACK_MODELS),
+            loadAnthropicLiveModels(env, CLAUDE_FALLBACK_MODELS),
+        ]);
+        if (!fromCli)
+            return fromApi;
+        return fromApi ? mergeLiveModels(fromCli, fromApi) : fromCli;
+    },
     // `claude --effort <level>`. The set differs from codex's on both ends — it
     // has `max` and has no `none`/`minimal` — so it is spelled out rather than
     // shared, and `CLAUDE_EFFORT_LEVELS` below is what `buildArgs` validates

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/detection.d.ts

@@ -1,5 +1,24 @@
 import { type AmrProfileResolver } from './amr-profile-resolver.js';
 import type { AgentDiagnostic, DetectedAgent, RuntimeAgentDef, RuntimeModelSource, RuntimeModelOption } from './types.js';
+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;
@@ -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

@@ -169,6 +169,37 @@ 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
@@ -182,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)]);
@@ -250,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/providers/connection-test.js

@@ -287,7 +287,7 @@ export async function testProviderConnection(input) {
             kind: 'auth_failed',
             latencyMs: Date.now() - start,
             model,
-            detail: 'No API key — connection test needs the key from this browser.',
+            detail: 'No API key saved. Save one to test the connection.',
         };
     }
     const validated = await validateBaseUrlResolved(input.baseUrl, input.dnsLookup ?? defaultDnsLookup);

package/dist/providers/model-catalog.js

@@ -32,7 +32,7 @@ function missingApiKeyResponse(startedAt) {
         ok: false,
         kind: 'auth_failed',
         latencyMs: Date.now() - startedAt,
-        detail: 'No API key — model discovery needs the key from this browser.',
+        detail: 'No API key saved. Save one to load models.',
     };
 }
 const BEDROCK_MODEL_OPTIONS = [

package/dist/types.d.ts

@@ -81,7 +81,7 @@ export type RuntimeBuildOptions = {
      * expresses a deny-list — today, `claude`'s own `--disallowedTools` (verified against installed
      * Claude Code 2.1.263: `--disallowedTools, --disallowed-tools <tools...>`, "Comma or
      * space-separated list of tool names to deny"). This is a `@jini-ai/agent-runtime`-level
-     * *mechanism* only: no product's tool policy is baked in here (not Tovu's Bash-forbid opinion,
+     * *mechanism* only: no product's tool policy is baked in here (not one host's Bash-forbid opinion,
      * not anyone else's) — the caller decides which names to pass. A def whose CLI has no equivalent
      * flag simply ignores this field, same as `systemPromptOverlay` on a def with no overlay
      * delivery. `undefined`/empty means no restriction — byte-identical to today's behavior (every