@jini-ai/agent-runtime 0.3.2 → 0.3.7

package/dist/anthropic-live-models.d.ts

@@ -0,0 +1,45 @@
+import type { RuntimeEnv, RuntimeModelOption } from './types.js';
+/** Test-only reset — this module-scope cache would otherwise leak a stubbed `fetch`'s result across
+ *  test cases. */
+export declare function resetAnthropicLiveModelCacheForTesting(): void;
+export type AnthropicCredential = {
+    apiKey: string;
+    baseUrl: string;
+};
+/**
+ * Reads an Anthropic API credential out of the environment handed to the def's `fetchModels`.
+ *
+ * Reads ONLY the passed `env`, never `process.env` directly: detection composes a per-agent
+ * environment (host env + def env + operator overrides) and that composed value is the one a spawn
+ * would actually see, so consulting the ambient process would let this disagree with the runtime.
+ *
+ * @param env - The composed environment for this agent.
+ * @returns The credential, or `null` when no usable key is present — the caller's signal to make no
+ * network call whatsoever.
+ * @complexity O(1).
+ */
+export declare function resolveAnthropicCredential(env: RuntimeEnv): AnthropicCredential | null;
+/**
+ * Appends live-discovered models to the static fallback list.
+ *
+ * UNION, never replace. `fallback` is always fully present, in its original order — nothing is ever
+ * removed from it, so the `default` sentinel and the bare CLI aliases survive by construction rather
+ * than by a guard that could be edited away. Live ids already present are skipped.
+ *
+ * @complexity O(f + l) — one `Set` over the fallback, one pass over the live list.
+ */
+export declare function mergeLiveModels(fallback: readonly RuntimeModelOption[], live: readonly RuntimeModelOption[]): RuntimeModelOption[];
+/**
+ * Returns the Claude model list with the account's live catalog merged in, or `null` when there is
+ * nothing to merge.
+ *
+ * @param env - The composed environment for the `claude` agent.
+ * @param fallbackModels - The def's static list; always fully present in a non-null result.
+ * @param now - Injectable clock for TTL tests.
+ * @returns The merged list, or `null` for every no-credential / failed-call outcome — which the
+ * caller treats as "keep the static list", never as an error.
+ * @complexity O(1) plus, at most, one cached outbound HTTPS call bounded by
+ * {@link LIVE_MODEL_TIMEOUT_MS}.
+ */
+export declare function loadAnthropicLiveModels(env: RuntimeEnv, fallbackModels: readonly RuntimeModelOption[], now?: () => number): Promise<RuntimeModelOption[] | null>;
+//# sourceMappingURL=anthropic-live-models.d.ts.map

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
@@ -64,5 +73,12 @@ export const aiderAgentDef = {
     streamFormat: 'plain',
     installUrl: 'https://aider.chat/docs/install.html',
     docsUrl: 'https://aider.chat',
+    // No `externalMcpInjection`: Aider has no native MCP client. Its published
+    // config reference (aider.chat/docs) documents no MCP options as of mid-2026,
+    // and the upstream MCP-support pull requests were closed unmerged — there is
+    // no `--mcp-config`-equivalent surface to write into. It proxies to whatever
+    // LiteLLM-routed model the user configures for chat completions only; there
+    // is nowhere for a bridged tool call to land. Revisit if upstream ships a
+    // client.
 };
 //# sourceMappingURL=aider.js.map

package/dist/defs/amp.js

@@ -58,5 +58,14 @@ export const ampAgentDef = {
     },
     promptViaStdin: true,
     streamFormat: 'claude-stream-json',
+    // No `externalMcpInjection` yet, though Amp does have real native MCP support:
+    // `.amp/settings.json`'s `amp.mcpServers` key (workspace- or global-scoped),
+    // plus an `amp mcp add [--workspace]` CLI mutator. It doesn't fit any of the
+    // four wired strategies — the file/schema differ from `.mcp.json`
+    // (`'claude-mcp-json'`), Amp isn't ACP, and it isn't an env-var-content format
+    // (`'opencode-env-content'`/`'mimo-env-content'`). Workspace MCP servers also
+    // "require explicit approval before they can run" with no confirmed
+    // non-interactive bypass, so a new strategy here would still need that
+    // verified against a live headless `amp -x` run before it's safe to wire.
 };
 //# sourceMappingURL=amp.js.map

package/dist/defs/amr.d.ts

@@ -28,6 +28,7 @@ export declare const amrAgentDef: {
     fallbackModels: RuntimeModelOption[];
     buildArgs: () => string[];
     streamFormat: string;
+    externalMcpInjection: "acp-merge";
     resumesSessionViaAcpLoad: true;
     supportsCustomModel: false;
     imageDelivery: "native";

package/dist/defs/amr.js

@@ -280,6 +280,13 @@ export const amrAgentDef = {
     fallbackModels: [],
     buildArgs: () => ['agent', 'run', '--runtime', 'opencode'],
     streamFormat: 'acp-json-rpc',
+    // AMR is a genuine ACP-native def (same `acp-json-rpc` transport as devin/hermes/kilo/kimi/
+    // kiro/reasonix/trae-cli/vibe), so it gets the caller's external MCP servers the same way those
+    // 8 do: merged into the `session/new` `mcpServers` array. `buildMcpBridgeDelivery` dispatches on
+    // this declared strategy alone, never on `def.id`, so this one field is the whole fix — no
+    // `agent-executor.ts` change needed. Previously undeclared here only because this def was ported
+    // after the other 8 and the field was missed, not because vela lacks the transport.
+    externalMcpInjection: 'acp-merge',
     // vela resumes the upstream OpenCode session via ACP session/load across
     // turns (the OpenCode session store persists per conversation), so the daemon
     // captures the durable handle, skips the transcript resend on resume, and

package/dist/defs/claude.d.ts

@@ -16,7 +16,8 @@ export declare const claudeAgentDef: {
         '--append-system-prompt': string;
     };
     fallbackModels: import("../types.js").RuntimeModelOption[];
-    fetchModels: (_resolvedBin: string, env: import("../types.js").RuntimeEnv) => Promise<import("../types.js").RuntimeModelOption[] | null>;
+    fallbackModelsAssertedAt: string;
+    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,6 +30,8 @@
 import { agentCapabilities } from '../capabilities.js';
 import { buildClaudeMcpConfigArgs, DEFAULT_MODEL_OPTION } from './shared.js';
 import { loadMmdRouteModels } from '../mmd-routes.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
@@ -40,18 +42,44 @@ import { loadMmdRouteModels } from '../mmd-routes.js';
 const CLAUDE_EFFORT_LEVELS = new Set([
     'low', 'medium', 'high', 'xhigh', 'max',
 ]);
-// Current models first, then the still-active-but-superseded 4.5 opus/sonnet generation kept as
-// older options rather than dropped — an installed CLI may still be pinned to one via its own
-// config, and removing a working selection out from under a user is worse than listing it last.
-// `claude-haiku-4-5` is unchanged: Haiku 4.5 is still the current Haiku model, nothing superseded it.
+/**
+ * The list a picker renders when nothing live is available — no `~/.config/mms/model-routes.json`,
+ * 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
+ * selection out from under a user is worse than listing it last.
+ *
+ * Every id below is verified present in the installed Claude Code binary's own embedded model
+ * table (2.1.261), and `claude-fable-5-1` is additionally the value in `~/.claude.json`'s
+ * server-fetched `additionalModelOptionsCache`. `claude-fable-5-mythos-5` appears in the binary but
+ * NOT in that server-fetched picker list, so it is deliberately omitted: an id in the binary is not
+ * evidence it is a selectable model.
+ *
+ * The `[1m]` long-context suffix the server-fetched cache carries on `claude-fable-5-1` is dropped
+ * here on purpose — `models.ts#sanitizeCustomModel` rejects brackets, and `claude --help` documents
+ * the bare full name as the accepted `--model` form.
+ *
+ * **This list WILL go stale, and that is now a detectable event rather than a silent one** — see
+ * `fallbackModelsAssertedAt` on the def below and `scripts/check-model-fallback-freshness.ts`.
+ */
 const CLAUDE_FALLBACK_MODELS = [
     DEFAULT_MODEL_OPTION,
+    { id: 'fable', label: 'Fable (alias)' },
     { id: 'sonnet', label: 'Sonnet (alias)' },
     { id: 'opus', label: 'Opus (alias)' },
     { id: 'haiku', label: 'Haiku (alias)' },
+    { id: 'claude-fable-5-1', label: 'claude-fable-5-1' },
+    { id: 'claude-fable-5', label: 'claude-fable-5' },
     { id: 'claude-opus-5', label: 'claude-opus-5' },
     { id: 'claude-sonnet-5', label: 'claude-sonnet-5' },
     { id: 'claude-haiku-4-5', label: 'claude-haiku-4-5' },
+    { id: 'claude-opus-4-8', label: 'claude-opus-4-8' },
+    { id: 'claude-opus-4-7', label: 'claude-opus-4-7' },
+    { id: 'claude-opus-4-6', label: 'claude-opus-4-6' },
+    { id: 'claude-sonnet-4-6', label: 'claude-sonnet-4-6' },
     { id: 'claude-opus-4-5', label: 'claude-opus-4-5' },
     { id: 'claude-sonnet-4-5', label: 'claude-sonnet-4-5' },
 ];
@@ -81,11 +109,40 @@ export const claudeAgentDef = {
         '--effort': 'effort',
         '--append-system-prompt': 'appendSystemPrompt',
     },
-    // `claude` has no list-models subcommand. Prefer local mmd/MMS routes
-    // when present so proxy-backed Claude-compatible models appear in the
-    // picker, then keep the built-in aliases as fallback hints.
+    // `claude` has no list-models subcommand, so the model list is answered from the best source
+    // available, in this order:
+    //
+    //   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. 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.
     fallbackModels: CLAUDE_FALLBACK_MODELS,
-    fetchModels: async (_resolvedBin, env) => loadMmdRouteModels(env, CLAUDE_FALLBACK_MODELS),
+    // Asserted against the installed Claude Code 2.1.261 binary's embedded model table and
+    // `~/.claude.json`'s server-fetched `additionalModelOptionsCache`. See
+    // `RuntimeAgentDef.fallbackModelsAssertedAt` and `scripts/check-model-fallback-freshness.ts`.
+    fallbackModelsAssertedAt: '2026-09-05',
+    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
@@ -168,6 +225,19 @@ export const claudeAgentDef = {
         // implementation rather than a copy per def. A no-op (`[]`) whenever the caller staged no
         // file, so a host that never configured MCP injection sees no argv change.
         args.push(...buildClaudeMcpConfigArgs(runtimeContext));
+        // Finding 2 (SEC-assistant-env-isolation-2026-09-07): `RuntimeBuildOptions.disallowedTools`/
+        // `allowedTools` are a `@jini-ai/agent-runtime`-level *mechanism* only — no product policy is
+        // baked in here (see `types.ts`'s own doc on those fields). Verified against installed Claude
+        // Code 2.1.263's own `-p --help`: `--disallowedTools, --disallowed-tools <tools...>` /
+        // `--allowedTools, --allowed-tools <tools...>`. Placed last, after every other flag, so an
+        // omitted (default) value is a true no-op — every existing call site that never passes these
+        // options sees byte-identical argv to before this change.
+        if (options.disallowedTools && options.disallowedTools.length > 0) {
+            args.push('--disallowedTools', ...options.disallowedTools);
+        }
+        if (options.allowedTools && options.allowedTools.length > 0) {
+            args.push('--allowedTools', ...options.allowedTools);
+        }
         return args;
     },
     promptViaStdin: true,

package/dist/defs/codex.d.ts

@@ -1,5 +1,22 @@
-import type { RuntimeModelOption } from '../types.js';
+import type { RuntimeModelOption, RuntimeReasoningOption } from '../types.js';
 export declare function parseCodexDebugModels(stdout: string): RuntimeModelOption[] | 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 declare function unionModelReasoningOptions(models: readonly RuntimeModelOption[]): RuntimeReasoningOption[] | null;
 export declare function codexNeedsDangerFullAccessSandbox(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): boolean;
 export declare const codexAgentDef: {
     id: string;
@@ -16,10 +33,12 @@ export declare const codexAgentDef: {
         timeoutMs: number;
     };
     fallbackModels: RuntimeModelOption[];
+    fallbackModelsAssertedAt: string;
     reasoningOptions: {
         id: string;
         label: string;
     }[];
+    deriveReasoningOptions: typeof unionModelReasoningOptions;
     buildArgs: (_prompt: string, imagePaths: string[], extraAllowedDirs?: string[] | undefined, options?: import("../types.js").RuntimeBuildOptions | undefined, runtimeContext?: import("../types.js").RuntimeContext | undefined) => string[];
     promptViaStdin: true;
     resumesSessionViaCli: true;