@jini-ai/agent-runtime 0.4.4 → 0.4.6

package/dist/model-discovery-adapters.js

@@ -1,15 +1,18 @@
+import { defaultRuntimeState } from './runtime-state.js';
+import { VENDOR_API_BASE_URLS } from '@jini-ai/integrations/media-providers/catalog';
 import { execFile } from 'node:child_process';
 import { readFile, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
-import { createCommandInvocation } from '@jini-ai/platform';
+import { createCommandInvocation } from '@jini-ai/platform/command';
 import { detectAcpModelMetadata } from './agent-protocol/acp/models.js';
 import { CLAUDE_CODE_INITIALIZE_ARGS, CLAUDE_CODE_INITIALIZE_REQUEST } from './claude-code-models.js';
 import { listProviderModels } from './providers/model-catalog.js';
 import { execAgentFile } from './invocation.js';
+import { scheduleProbeProcess } from './probe-scheduler.js';
 import { probeCopilotSdk, probeDroidSdk } from './model-discovery-sdk.js';
 import { parseSettingsJson, readModelConfiguration } from './model-discovery-config.js';
-import { ModelProbeError, modelIdentityKind, withModelProbeTimeout } from './model-discovery.js';
+import { ModelProbeError, modelIdentityKind, withModelProbeTimeout } from './model-discovery-shared.js';
 const ACP_ARGS = {
     amr: ['agent', 'run', '--runtime', 'opencode'],
     auggie: ['--acp'], cline: ['--acp'], devin: ['--permission-mode', 'dangerous', '--respect-workspace-trust', 'false', 'acp'],
@@ -252,49 +255,53 @@ function runProcess(input) {
                 cwd: input.context.cwd, env: input.context.env, signal: input.signal,
                 timeout: input.timeoutMs, killSignal: 'SIGKILL', maxBuffer: 8 * 1024 * 1024,
             } }).then(({ stdout, stderr }) => ({ stdout: String(stdout), stderr: String(stderr) }));
-    return new Promise((resolve, reject) => {
-        let completed = false;
-        let captured = '';
-        const invocation = createCommandInvocation({ command: input.context.executable, args: [...input.args], env: input.context.env });
-        const tree = input.terminateProcessTree && process.platform !== 'win32';
-        let treeTimer;
-        const killTree = () => { if (tree && child.pid) {
-            try {
-                process.kill(-child.pid, 'SIGKILL');
-            }
-            catch { }
-        } };
-        // execFile forwards `detached` to spawn at runtime, but its typings omit it; a typed
-        // variable (not a literal) keeps the process-group option without a cast.
-        const options = { cwd: input.context.cwd, env: input.context.env,
-            timeout: input.timeoutMs, killSignal: 'SIGKILL', signal: input.signal, maxBuffer: 8 * 1024 * 1024,
-            detached: Boolean(tree),
-            windowsVerbatimArguments: invocation.windowsVerbatimArguments, };
-        const child = execFile(invocation.command, invocation.args, options, (error, stdout, stderr) => {
-            if (treeTimer)
-                clearTimeout(treeTimer);
-            input.signal.removeEventListener('abort', killTree);
-            if (error)
-                killTree();
-            error && !completed ? reject(error) : resolve({ stdout: String(stdout), stderr: String(stderr) });
-        });
-        if (tree) {
-            input.signal.addEventListener('abort', killTree, { once: true });
-            treeTimer = setTimeout(killTree, input.timeoutMs);
-            if (input.signal.aborted)
-                killTree();
-        }
-        if (input.complete)
-            child.stdout?.on('data', (chunk) => {
-                captured += String(chunk);
-                if (input.complete?.(captured)) {
-                    completed = true;
-                    child.kill('SIGKILL');
+    return scheduleProbeProcess({ work: () => new Promise((resolve, reject) => {
+            let completed = false;
+            let captured = '';
+            const invocation = createCommandInvocation({ command: input.context.executable, args: [...input.args], env: input.context.env });
+            const tree = input.terminateProcessTree && process.platform !== 'win32';
+            let treeTimer;
+            const killTree = () => { if (tree && child.pid) {
+                try {
+                    process.kill(-child.pid, 'SIGKILL');
                 }
+                catch { }
+            } };
+            // execFile forwards `detached` to spawn at runtime, but its typings omit it; a typed
+            // variable (not a literal) keeps the process-group option without a cast.
+            const options = { cwd: input.context.cwd, env: input.context.env,
+                timeout: input.timeoutMs, killSignal: 'SIGKILL', signal: input.signal, maxBuffer: 8 * 1024 * 1024,
+                detached: Boolean(tree),
+                windowsVerbatimArguments: invocation.windowsVerbatimArguments, };
+            const child = execFile(invocation.command, invocation.args, options, (error, stdout, stderr) => {
+                if (treeTimer)
+                    clearTimeout(treeTimer);
+                input.signal.removeEventListener('abort', killTree);
+                if (error)
+                    killTree();
+                const settle = () => { error && !completed ? reject(error) : resolve({ stdout: String(stdout), stderr: String(stderr) }); };
+                if (child.pid && child.exitCode === null && child.signalCode === null)
+                    child.once('close', settle);
+                else
+                    settle();
             });
-        child.stdin?.on('error', () => { });
-        child.stdin?.end(input.stdin);
-    });
+            if (tree) {
+                input.signal.addEventListener('abort', killTree, { once: true });
+                treeTimer = setTimeout(killTree, input.timeoutMs);
+                if (input.signal.aborted)
+                    killTree();
+            }
+            if (input.complete)
+                child.stdout?.on('data', (chunk) => {
+                    captured += String(chunk);
+                    if (input.complete?.(captured)) {
+                        completed = true;
+                        child.kill('SIGKILL');
+                    }
+                });
+            child.stdin?.on('error', () => { });
+            child.stdin?.end(input.stdin);
+        }) }, { signal: input.signal });
 }
 export const defaultModelDiscoveryDeps = {
     process: { run: runProcess },
@@ -319,29 +326,29 @@ export const defaultModelDiscoveryDeps = {
             // handles. BYOK env is usable only when it identifies this CLI's effective provider.
             const env = context.env;
             if (agentId === 'claude' && env.ANTHROPIC_API_KEY)
-                return { protocol: 'anthropic', baseUrl: env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com', apiKey: env.ANTHROPIC_API_KEY };
+                return { protocol: 'anthropic', baseUrl: env.ANTHROPIC_BASE_URL || VENDOR_API_BASE_URLS.anthropic, apiKey: env.ANTHROPIC_API_KEY };
             const selected = context.model || (agentId === 'aider' ? env.AIDER_MODEL : agentId === 'qwen' ? env.QWEN_MODEL || env.OPENAI_MODEL : undefined);
             if (!selected)
                 return null;
             if (/^(anthropic\/|claude-)/.test(selected) && env.ANTHROPIC_API_KEY)
-                return { protocol: 'anthropic', baseUrl: env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com', apiKey: env.ANTHROPIC_API_KEY };
+                return { protocol: 'anthropic', baseUrl: env.ANTHROPIC_BASE_URL || VENDOR_API_BASE_URLS.anthropic, apiKey: env.ANTHROPIC_API_KEY };
             if (/^(gemini\/|google\/|gemini-)/.test(selected) && env.GEMINI_API_KEY)
-                return { protocol: 'google', baseUrl: 'https://generativelanguage.googleapis.com', apiKey: env.GEMINI_API_KEY };
+                return { protocol: 'google', baseUrl: VENDOR_API_BASE_URLS.google, apiKey: env.GEMINI_API_KEY };
             if (/^openrouter\//.test(selected) && env.OPENROUTER_API_KEY)
-                return { protocol: 'openai', baseUrl: env.OPENROUTER_API_BASE || 'https://openrouter.ai/api/v1', apiKey: env.OPENROUTER_API_KEY };
+                return { protocol: 'openai', baseUrl: env.OPENROUTER_API_BASE || VENDOR_API_BASE_URLS.openrouter, apiKey: env.OPENROUTER_API_KEY };
             if ((/^(openai\/|gpt-|o\d)/.test(selected) || agentId === 'qwen' && (env.OPENAI_MODEL || env.OPENAI_BASE_URL)) && env.OPENAI_API_KEY)
-                return { protocol: 'openai', baseUrl: env.OPENAI_BASE_URL || env.OPENAI_API_BASE || 'https://api.openai.com/v1', apiKey: env.OPENAI_API_KEY };
+                return { protocol: 'openai', baseUrl: env.OPENAI_BASE_URL || env.OPENAI_API_BASE || VENDOR_API_BASE_URLS.openai, apiKey: env.OPENAI_API_KEY };
             return null;
         } },
     acp: { async probe({ context, args, signal }) {
             const invocation = createCommandInvocation({ command: context.executable, args: [...args], env: context.env });
-            const result = await detectAcpModelMetadata({ bin: invocation.command, args: invocation.args }, { cwd: context.cwd, env: context.env, timeoutMs: 15_000, signal });
+            const result = await scheduleProbeProcess({ work: () => detectAcpModelMetadata({ bin: invocation.command, args: invocation.args }, { cwd: context.cwd, env: context.env, timeoutMs: 15_000, signal }) }, { signal });
             return { models: result.models, source: 'rpc', coverage: 'account', ...(result.currentModelId ? { defaultSelectionId: result.currentModelId } : {}) };
         } },
     rpc: { async probe({ agentId, context, signal }) {
             // UNVERIFIED locally: use official prompt-free SDK interfaces, not invented CLI flags.
             if (agentId === 'copilot')
-                return probeCopilotSdk(context, signal);
+                return scheduleProbeProcess({ work: () => probeCopilotSdk(context, signal) }, { signal });
             if (agentId === 'droid')
                 return probeDroidSdk(context, defaultModelDiscoveryDeps, signal);
             if (agentId !== 'pi')
@@ -358,7 +365,7 @@ export const defaultModelDiscoveryDeps = {
                 } });
             return parsePiRpcMetadata(stdout);
         } },
-    clock: { now: Date.now }, cache: new Map(),
+    clock: { now: Date.now }, cache: defaultRuntimeState.modelCatalog,
 };
 /** Pi's native RPC supplies catalog AND current provider/id without making an inference call. */
 export function parsePiRpcMetadata(stdout) {
@@ -388,4 +395,10 @@ export function parsePiRpcMetadata(stdout) {
         throw new ModelProbeError('malformed-response');
     return { models, source: 'rpc', coverage: 'account', ...(defaultSelectionId ? { defaultSelectionId } : {}) };
 }
+/** Stable dependency identity preserves the existing per-host single-probe budget as well as its cache. */
+export function getRuntimeModelDiscoveryDeps({ state }, _optional = {}) {
+    if (state === defaultRuntimeState)
+        return defaultModelDiscoveryDeps;
+    return state.discoveryDeps ??= { ...defaultModelDiscoveryDeps, cache: state.modelCatalog };
+}
 //# sourceMappingURL=model-discovery-adapters.js.map

package/dist/model-discovery-native.d.ts

@@ -0,0 +1,14 @@
+/** Native composition and legacy public signatures. Injected hosts import model-discovery instead. */
+import { resolveModelForLaunch as resolvePolicyModelForLaunch, type ModelDiscoveryDefinition } from './model-discovery.js';
+import type { AgentDiscoveryConfiguration, AgentModelDiscoveryPort, ModelDiscoveryContext, ModelDiscoveryDeps } from './model-discovery-types.js';
+export * from './model-discovery.js';
+export declare function createAgentModelDiscovery(agentId: string, configuration: AgentDiscoveryConfiguration): AgentModelDiscoveryPort;
+export declare function modelDiscoveryForDef(def: ModelDiscoveryDefinition): AgentModelDiscoveryPort;
+export declare function resolveModelForLaunch(required: {
+    def: ModelDiscoveryDefinition;
+    context: ModelDiscoveryContext;
+}, { deps, ...optional }?: {
+    deps?: ModelDiscoveryDeps;
+    signal?: AbortSignal;
+}): ReturnType<typeof resolvePolicyModelForLaunch>;
+//# sourceMappingURL=model-discovery-native.d.ts.map

package/dist/model-discovery-native.js

@@ -0,0 +1,22 @@
+/** Native composition and legacy public signatures. Injected hosts import model-discovery instead. */
+import { createAgentModelDiscovery as createPolicyDiscovery, modelDiscoveryForDef as policyDiscoveryForDef, resolveModelForLaunch as resolvePolicyModelForLaunch, } from './model-discovery.js';
+import { defaultModelDiscoveryDeps, modelProbeTimeoutMs, probeAgentCatalog, probeCliCache } from './model-discovery-adapters.js';
+export * from './model-discovery.js';
+/** Reuse the existing probe owners, including their credential, cancellation and cache guards. */
+const nativeModelDiscoveryProbes = {
+    catalog: ({ agentId, context, configuration, deps, signal }, _optional = {}) => probeAgentCatalog(agentId, context, configuration, deps, signal),
+    cliCache: ({ agentId, context, deps, signal }, _optional = {}) => probeCliCache(agentId, context, deps, signal),
+    timeoutMs: ({ agentId }, _optional = {}) => modelProbeTimeoutMs(agentId),
+};
+// These forwarding signatures deliberately retain the published API. New policy APIs use
+// required/optional objects; changing these compatibility wrappers would break existing hosts.
+export function createAgentModelDiscovery(agentId, configuration) {
+    return createPolicyDiscovery({ agentId, configuration, deps: defaultModelDiscoveryDeps, probes: nativeModelDiscoveryProbes });
+}
+export function modelDiscoveryForDef(def) {
+    return policyDiscoveryForDef({ def, deps: defaultModelDiscoveryDeps });
+}
+export function resolveModelForLaunch(required, { deps = defaultModelDiscoveryDeps, ...optional } = {}) {
+    return resolvePolicyModelForLaunch({ ...required, deps }, optional);
+}
+//# sourceMappingURL=model-discovery-native.js.map

package/dist/model-discovery-sdk.js

@@ -1,4 +1,4 @@
-import { ModelProbeError, modelIdentityKind } from './model-discovery.js';
+import { ModelProbeError, modelIdentityKind } from './model-discovery-shared.js';
 export async function probeCopilotSdk(context, signal, optional = {}) {
     const client = await (optional.createClient ?? createCopilotMetadataClient)(context);
     if (signal.aborted) {

package/dist/model-discovery-shared.d.ts

@@ -0,0 +1,14 @@
+/** Shared discovery normalization and timeout/error contracts; no native adapters. */
+import type { RuntimeModelOption } from './types.js';
+import type { DiscoveredModel, ModelCatalogSnapshot } from './model-discovery-types.js';
+export declare function modelIdentityKind(id: string): DiscoveredModel['identityKind'];
+export declare function normalizeDiscoveredModels(models: readonly RuntimeModelOption[]): DiscoveredModel[];
+export declare class ProbeTimeout extends Error {
+}
+/** Cancellation always reaches the effect port. A broken port cannot hold callers indefinitely. */
+export declare function withModelProbeTimeout<T>(work: (signal: AbortSignal) => Promise<T>, timeoutMs: number, parent?: AbortSignal): Promise<T>;
+export declare class ModelProbeError extends Error {
+    readonly code: ModelCatalogSnapshot['diagnostics'][number]['code'];
+    constructor(code: ModelCatalogSnapshot['diagnostics'][number]['code']);
+}
+//# sourceMappingURL=model-discovery-shared.d.ts.map

package/dist/model-discovery-shared.js

@@ -0,0 +1,53 @@
+export function modelIdentityKind(id) {
+    const token = id.slice(id.lastIndexOf('/') + 1);
+    if (/^(default|auto|adaptive|smart|deep|rush|ultimate|premium|balanced|fast|vercel-ai-gateway|grok-build)$/i.test(token) || /(?:^|[-/])gateway$/i.test(id))
+        return 'routing-mode';
+    if (/^(opus|sonnet|haiku|fable|best|latest|claude|gemini|gpt|codex|swe)(?:\[.*\])?$/i.test(token) || /(?:^|[-/])latest$/i.test(id))
+        return 'alias';
+    return 'concrete';
+}
+export function normalizeDiscoveredModels(models) {
+    const seen = new Set();
+    return models.flatMap((row) => {
+        if (!row.id || row.id === 'default' || seen.has(row.id))
+            return [];
+        seen.add(row.id);
+        const model = row;
+        return [{ ...row, identityKind: model.identityKind ?? modelIdentityKind(row.id), ...(model.resolvedId ? { resolvedId: model.resolvedId } : {}) }];
+    });
+}
+export class ProbeTimeout extends Error {
+}
+/** Cancellation always reaches the effect port. A broken port cannot hold callers indefinitely. */
+export async function withModelProbeTimeout(work, timeoutMs, parent) {
+    if (parent?.aborted)
+        throw new ProbeTimeout('Probe cancelled');
+    const controller = new AbortController();
+    let timer;
+    let abortListener;
+    const stopped = new Promise((_resolve, reject) => {
+        abortListener = () => { controller.abort(); reject(new ProbeTimeout('Probe cancelled')); };
+        if (parent?.aborted)
+            abortListener();
+        else
+            parent?.addEventListener('abort', abortListener, { once: true });
+        timer = setTimeout(() => { controller.abort(); reject(new ProbeTimeout('Probe timed out')); }, timeoutMs);
+    });
+    try {
+        return await Promise.race([work(controller.signal), stopped]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (abortListener)
+            parent?.removeEventListener('abort', abortListener);
+    }
+}
+export class ModelProbeError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+//# sourceMappingURL=model-discovery-shared.js.map

package/dist/model-discovery-types.d.ts

@@ -136,4 +136,30 @@ export interface ModelDiscoveryDeps {
     };
     cache: Map<string, ModelCacheEntry>;
 }
+export interface AgentDiscoveryConfiguration {
+    fallbackModels: () => readonly RuntimeModelOption[];
+    parse?: (input: {
+        stdout: string;
+    }) => RuntimeModelOption[] | null;
+    args?: readonly string[];
+}
+/** Host composition selects native probes or substitutes another discovery mechanism. */
+export interface ModelDiscoveryProbes {
+    catalog(required: {
+        agentId: string;
+        context: ModelDiscoveryContext;
+        configuration: AgentDiscoveryConfiguration;
+        deps: ModelDiscoveryDeps;
+        signal: AbortSignal;
+    }, optional?: Record<string, never>): Promise<ModelProbeResult>;
+    cliCache(required: {
+        agentId: string;
+        context: ModelDiscoveryContext;
+        deps: ModelDiscoveryDeps;
+        signal: AbortSignal;
+    }, optional?: Record<string, never>): Promise<ModelProbeResult>;
+    timeoutMs(required: {
+        agentId: string;
+    }, optional?: Record<string, never>): number;
+}
 //# sourceMappingURL=model-discovery-types.d.ts.map

package/dist/model-discovery.d.ts

@@ -1,42 +1,37 @@
 import type { RuntimeModelOption } from './types.js';
-import type { AgentModelDiscoveryPort, DefaultModelResolution, DiscoveredModel, ModelCatalogSnapshot, ModelDiscoveryContext, ModelDiscoveryDeps } from './model-discovery-types.js';
-export * from './model-discovery-types.js';
+import type { AgentModelDiscoveryPort, AgentDiscoveryConfiguration, DefaultModelResolution, ModelCatalogSnapshot, ModelDiscoveryContext, ModelDiscoveryDeps, ModelDiscoveryProbes } from './model-discovery-types.js';
+export { ModelProbeError, modelIdentityKind, normalizeDiscoveredModels, withModelProbeTimeout } from './model-discovery-shared.js';
+export type * from './model-discovery-types.js';
 export declare const MODEL_CATALOG_TTL_MS: number;
 export declare const MODEL_NEGATIVE_TTL_MS = 30000;
-export declare function modelIdentityKind(id: string): DiscoveredModel['identityKind'];
-export declare function normalizeDiscoveredModels(models: readonly RuntimeModelOption[]): DiscoveredModel[];
 /** Hash all launch-affecting state, including env credentials; none of the raw material escapes. */
 export declare function modelLaunchFingerprint(context: ModelDiscoveryContext, configMaterial?: string): string;
-/** Cancellation always reaches the effect port. A broken port cannot hold callers indefinitely. */
-export declare function withModelProbeTimeout<T>(work: (signal: AbortSignal) => Promise<T>, timeoutMs: number, parent?: AbortSignal): Promise<T>;
-export declare class ModelProbeError extends Error {
-    readonly code: ModelCatalogSnapshot['diagnostics'][number]['code'];
-    constructor(code: ModelCatalogSnapshot['diagnostics'][number]['code']);
-}
-export interface AgentDiscoveryConfiguration {
-    fallbackModels: () => readonly RuntimeModelOption[];
-    parse?: (input: {
-        stdout: string;
-    }) => RuntimeModelOption[] | null;
-    args?: readonly string[];
-}
-export declare function createAgentModelDiscovery(agentId: string, configuration: AgentDiscoveryConfiguration): AgentModelDiscoveryPort;
+/** Bind supplied effect ports and probes without loading their native implementations. */
+export declare function createAgentModelDiscovery({ agentId, configuration, deps: suppliedDeps, probes }: {
+    agentId: string;
+    configuration: AgentDiscoveryConfiguration;
+    deps: ModelDiscoveryDeps;
+    probes: ModelDiscoveryProbes;
+}, _optional?: Record<string, never>): AgentModelDiscoveryPort;
 export declare function offlineSnapshot(fingerprint: string, now: number, fallback: readonly RuntimeModelOption[], issue?: ModelCatalogSnapshot['diagnostics'][number]): ModelCatalogSnapshot;
 /** Hosts may supply either discovery port independently; static definitions need no probes. */
-type ModelDiscoveryDefinition = Partial<AgentModelDiscoveryPort> & {
+export type ModelDiscoveryDefinition = Partial<AgentModelDiscoveryPort> & {
     id?: string;
     fallbackModels?: readonly RuntimeModelOption[];
     defaultModelEnvVar?: string;
     supportsCustomModel?: boolean;
     supportsConcreteModelSelection?: boolean;
 };
-export declare function modelDiscoveryForDef(def: ModelDiscoveryDefinition): AgentModelDiscoveryPort;
+export declare function modelDiscoveryForDef({ def, deps: suppliedDeps }: {
+    def: ModelDiscoveryDefinition;
+    deps: ModelDiscoveryDeps;
+}, _optional?: Record<string, never>): AgentModelDiscoveryPort;
 /** Resolve against the actual launch scope, pinning the same ID shown by the picker. */
-export declare function resolveModelForLaunch({ def, context }: {
+export declare function resolveModelForLaunch({ def, context, deps }: {
     def: ModelDiscoveryDefinition;
     context: ModelDiscoveryContext;
+    deps: ModelDiscoveryDeps;
 }, optional?: {
-    deps?: ModelDiscoveryDeps;
     signal?: AbortSignal;
 }): Promise<{
     model: string;

package/dist/model-discovery.js

@@ -1,40 +1,20 @@
 import { createHash } from 'node:crypto';
 import { readModelConfiguration } from './model-discovery-config.js';
-import { defaultModelDiscoveryDeps, probeAgentCatalog, probeCliCache, modelProbeTimeoutMs } from './model-discovery-adapters.js';
-export * from './model-discovery-types.js';
+import { ModelProbeError, ProbeTimeout, modelIdentityKind, normalizeDiscoveredModels, withModelProbeTimeout } from './model-discovery-shared.js';
+export { ModelProbeError, modelIdentityKind, normalizeDiscoveredModels, withModelProbeTimeout } from './model-discovery-shared.js';
 export const MODEL_CATALOG_TTL_MS = 15 * 60_000;
 export const MODEL_NEGATIVE_TTL_MS = 30_000;
 const MAX_CATALOG_SCOPES = 128;
-export function modelIdentityKind(id) {
-    const token = id.slice(id.lastIndexOf('/') + 1);
-    if (/^(default|auto|adaptive|smart|deep|rush|ultimate|premium|balanced|fast|vercel-ai-gateway|grok-build)$/i.test(token) || /(?:^|[-/])gateway$/i.test(id))
-        return 'routing-mode';
-    if (/^(opus|sonnet|haiku|fable|best|latest|claude|gemini|gpt|codex|swe)(?:\[.*\])?$/i.test(token) || /(?:^|[-/])latest$/i.test(id))
-        return 'alias';
-    return 'concrete';
-}
-export function normalizeDiscoveredModels(models) {
-    const seen = new Set();
-    return models.flatMap((row) => {
-        if (!row.id || row.id === 'default' || seen.has(row.id))
-            return [];
-        seen.add(row.id);
-        const model = row;
-        return [{ ...row, identityKind: model.identityKind ?? modelIdentityKind(row.id), ...(model.resolvedId ? { resolvedId: model.resolvedId } : {}) }];
-    });
-}
 /** Hash all launch-affecting state, including env credentials; none of the raw material escapes. */
 export function modelLaunchFingerprint(context, configMaterial = '') {
     return createHash('sha256').update(JSON.stringify({ ...context, env: Object.entries(context.env).sort(([a], [b]) => a.localeCompare(b)), configMaterial })).digest('hex');
 }
-class ProbeTimeout extends Error {
-}
 const probePools = new WeakMap();
-/** Four simultaneous cold probes per host; queued callers keep cancellation responsive. */
+/** One cold catalog probe per host; queued callers keep cancellation responsive. */
 async function boundedProbe(deps, work, signal) {
     const pool = probePools.get(deps) || { active: 0, queue: [] };
     probePools.set(deps, pool);
-    if (pool.active >= 4) {
+    if (pool.active >= 1) {
         await new Promise((resolve, reject) => {
             const ready = () => { signal?.removeEventListener('abort', abort); resolve(); };
             const abort = () => { const index = pool.queue.indexOf(ready); if (index >= 0)
@@ -61,50 +41,19 @@ async function boundedProbe(deps, work, signal) {
             pool.active -= 1;
     }
 }
-/** Cancellation always reaches the effect port. A broken port cannot hold callers indefinitely. */
-export async function withModelProbeTimeout(work, timeoutMs, parent) {
-    if (parent?.aborted)
-        throw new ProbeTimeout('Probe cancelled');
-    const controller = new AbortController();
-    let timer;
-    let abortListener;
-    const stopped = new Promise((_resolve, reject) => {
-        abortListener = () => { controller.abort(); reject(new ProbeTimeout('Probe cancelled')); };
-        if (parent?.aborted)
-            abortListener();
-        else
-            parent?.addEventListener('abort', abortListener, { once: true });
-        timer = setTimeout(() => { controller.abort(); reject(new ProbeTimeout('Probe timed out')); }, timeoutMs);
-    });
-    try {
-        return await Promise.race([work(controller.signal), stopped]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-        if (abortListener)
-            parent?.removeEventListener('abort', abortListener);
-    }
-}
 function diagnostic(error) {
     // Never stringify vendor errors: stderr/HTTP bodies may include credentials or OAuth URLs.
     const code = error instanceof ProbeTimeout ? 'timeout' : error instanceof ModelProbeError ? error.code : 'offline';
     return { code, message: ({ timeout: 'Model discovery timed out or was cancelled.', 'auth-missing': 'CLI credentials are unavailable.', 'unsupported-version': 'Native metadata discovery is unavailable for this version.', 'malformed-response': 'Native metadata contained no usable catalog.', offline: 'Model discovery could not reach its source.' })[code] };
 }
-export class ModelProbeError extends Error {
-    code;
-    constructor(code) {
-        super(code);
-        this.code = code;
-    }
-}
-export function createAgentModelDiscovery(agentId, configuration) {
+/** Bind supplied effect ports and probes without loading their native implementations. */
+export function createAgentModelDiscovery({ agentId, configuration, deps: suppliedDeps, probes }, _optional = {}) {
     async function scoped(context, deps, signal) {
         const config = await withModelProbeTimeout((active) => readModelConfiguration(agentId, context, deps, active), 1000, signal);
         return { config, key: `${agentId}:${modelLaunchFingerprint(context, config.fingerprintMaterial)}` };
     }
     const port = {
-        async discoverModels({ context }, { signal, force = false, staleWhileRevalidate = false, deps = defaultModelDiscoveryDeps } = {}) {
+        async discoverModels({ context }, { signal, force = false, staleWhileRevalidate = false, deps = suppliedDeps } = {}) {
             let state;
             try {
                 state = await scoped(context, deps, signal);
@@ -129,7 +78,7 @@ export function createAgentModelDiscovery(agentId, configuration) {
             // immediately; keep stale provenance and refresh without holding the first user prompt.
             if (staleWhileRevalidate && !cached.good && ['codex', 'opencode', 'claude', 'codebuddy'].includes(agentId)) {
                 try {
-                    const disk = await withModelProbeTimeout(active => probeCliCache(agentId, context, deps, active), 1000, signal);
+                    const disk = await withModelProbeTimeout(active => probes.cliCache({ agentId, context, deps, signal: active }), 1000, signal);
                     const models = normalizeDiscoveredModels(disk.models);
                     if (models.length)
                         cached.good = { models, source: 'cli-cache', coverage: disk.coverage,
@@ -145,7 +94,7 @@ export function createAgentModelDiscovery(agentId, configuration) {
             }
             const pending = (async () => {
                 try {
-                    const result = await boundedProbe(deps, () => withModelProbeTimeout((active) => probeAgentCatalog(agentId, context, configuration, deps, active), modelProbeTimeoutMs(agentId), signal), signal);
+                    const result = await boundedProbe(deps, () => withModelProbeTimeout((active) => probes.catalog({ agentId, context, configuration, deps, signal: active }), probes.timeoutMs({ agentId }), signal), signal);
                     const models = normalizeDiscoveredModels(result.models);
                     if (models.length === 0)
                         throw new ModelProbeError('malformed-response');
@@ -184,7 +133,7 @@ export function createAgentModelDiscovery(agentId, configuration) {
             // catalog while this coalesced, timeout-bounded refresh updates the cache in the background.
             return staleWhileRevalidate && lastGood() || pending;
         },
-        async resolveDefaultModel({ context, catalog }, { signal, deps = defaultModelDiscoveryDeps } = {}) {
+        async resolveDefaultModel({ context, catalog }, { signal, deps = suppliedDeps } = {}) {
             let state;
             try {
                 state = await scoped(context, deps, signal);
@@ -214,9 +163,9 @@ export function createAgentModelDiscovery(agentId, configuration) {
 export function offlineSnapshot(fingerprint, now, fallback, issue) {
     return { models: normalizeDiscoveredModels(fallback), source: 'offline-fallback', freshness: 'offline-fallback', fetchedAt: new Date(now).toISOString(), expiresAt: new Date(now + MODEL_NEGATIVE_TTL_MS).toISOString(), coverage: 'configured', launchFingerprint: fingerprint, diagnostics: issue ? [issue] : [] };
 }
-export function modelDiscoveryForDef(def) {
+export function modelDiscoveryForDef({ def, deps: suppliedDeps }, _optional = {}) {
     return {
-        discoverModels: def.discoverModels?.bind(def) || (async ({ context }, { deps = defaultModelDiscoveryDeps } = {}) => {
+        discoverModels: def.discoverModels?.bind(def) || (async ({ context }, { deps = suppliedDeps } = {}) => {
             const catalog = offlineSnapshot(modelLaunchFingerprint(context), deps.clock.now(), def.fallbackModels || []);
             const configured = def.defaultModelEnvVar && context.env[def.defaultModelEnvVar]?.trim();
             // Static hosts used their first concrete fallback before discovery existed. Preserve
@@ -224,7 +173,7 @@ export function modelDiscoveryForDef(def) {
             const selection = context.model || context.resumedModelId || configured || catalog.models.find(row => row.identityKind === 'concrete')?.id;
             return { ...catalog, ...(selection ? { defaultSelectionId: selection } : {}) };
         }),
-        resolveDefaultModel: def.resolveDefaultModel?.bind(def) || (async ({ context, catalog }, { deps = defaultModelDiscoveryDeps } = {}) => {
+        resolveDefaultModel: def.resolveDefaultModel?.bind(def) || (async ({ context, catalog }, { deps = suppliedDeps } = {}) => {
             if (context.resumeSessionId && !context.resumedModelId && !context.model)
                 return { status: 'unresolved', reason: 'Resumed session model metadata is required.' };
             const configured = def.defaultModelEnvVar && context.env[def.defaultModelEnvVar]?.trim();
@@ -241,16 +190,16 @@ export function modelDiscoveryForDef(def) {
     };
 }
 /** Resolve against the actual launch scope, pinning the same ID shown by the picker. */
-export async function resolveModelForLaunch({ def, context }, optional = {}) {
+export async function resolveModelForLaunch({ def, context, deps }, optional = {}) {
     if (def.supportsConcreteModelSelection === false)
         throw new Error('This CLI cannot pin a concrete starting model.');
-    const discovery = modelDiscoveryForDef(def);
-    const catalog = await discovery.discoverModels({ context }, { ...optional, staleWhileRevalidate: true });
+    const discovery = modelDiscoveryForDef({ def, deps });
+    const catalog = await discovery.discoverModels({ context }, { ...optional, deps, staleWhileRevalidate: true });
     // Custom input is allowed unless the definition explicitly disables it: an unlisted user ID is already
     // the intended launch value. Never substitute a catalog default or reinterpret its spelling.
     const resolution = context.model && def.supportsCustomModel !== false && !catalog.models.some(row => row.id === context.model)
-        ? { status: 'resolved', id: context.model, selectionId: context.model, source: 'config-file', resolvedAt: new Date((optional.deps || defaultModelDiscoveryDeps).clock.now()).toISOString(), launchFingerprint: catalog.launchFingerprint }
-        : await discovery.resolveDefaultModel({ context, catalog }, optional);
+        ? { status: 'resolved', id: context.model, selectionId: context.model, source: 'config-file', resolvedAt: new Date(deps.clock.now()).toISOString(), launchFingerprint: catalog.launchFingerprint }
+        : await discovery.resolveDefaultModel({ context, catalog }, { ...optional, deps });
     if (resolution.status !== 'resolved')
         throw new Error(resolution.reason);
     return { model: resolution.id, catalog, resolution };

package/dist/models.d.ts

@@ -1,3 +1,4 @@
+import { type AgentRuntimeState } from './runtime-state.js';
 /**
  * @module models
  * Model-option defaults, a per-agent last-surfaced live-model cache and model-id sanitization.
@@ -7,13 +8,15 @@ export declare const DEFAULT_MODEL_OPTION: RuntimeModelOption;
 export declare function rememberLiveModels({ agentId, models }: {
     agentId: string;
     models: RuntimeModelOption[];
-}, { scope }?: {
+}, { scope, state }?: {
     scope?: string | null;
+    state?: AgentRuntimeState;
 }): void;
 export declare function getRememberedLiveModels({ agentId }: {
     agentId: string;
-}, { scope }?: {
+}, { scope, state }?: {
     scope?: string | null;
+    state?: AgentRuntimeState;
 }): RuntimeModelOption[];
 export declare function preferFreshLiveModels({ freshModels, rememberedModels }: {
     freshModels: RuntimeModelOption[];
@@ -22,15 +25,17 @@ export declare function preferFreshLiveModels({ freshModels, rememberedModels }:
 export declare function isKnownModel({ def, modelId }: {
     def: RuntimeAgentDef;
     modelId: string | null | undefined;
-}, { scope }?: {
+}, { scope, state }?: {
     scope?: string | null;
+    state?: AgentRuntimeState;
 }): boolean;
 export declare function resolveModelForAgent({ def, resolved }: {
     def: RuntimeAgentDef;
     resolved: string | null;
-}, { env, liveModelScope }?: {
+}, { env, liveModelScope, state }?: {
     env?: Record<string, string | undefined>;
     liveModelScope?: string | null;
+    state?: AgentRuntimeState;
 }): string | null;
 export declare function sanitizeCustomModel({ id }: {
     id: string | null | undefined;