@jini-ai/agent-runtime 0.4.5 → 0.4.7

package/dist/executables.js

@@ -24,7 +24,7 @@ import { accessSync, constants, existsSync, statSync } from 'node:fs';
 import { delimiter } from 'node:path';
 import path from 'node:path';
 import { homedir } from 'node:os';
-import { wellKnownUserToolchainBins } from '@jini-ai/platform';
+import { wellKnownUserToolchainBins } from '@jini-ai/platform/toolchain';
 import { expandHomePath } from './paths.js';
 const AGENT_BIN_ENV_KEYS = new Map([
     ['amr', 'VELA_BIN'],

package/dist/index.d.ts

@@ -47,7 +47,8 @@ export * from './telemetry-sink.js';
 export * from './providers/index.js';
 /** ACP + pi-rpc protocol adapters over the shared JSON-line-stream core. See aliases above. */
 export { createJsonLineStream, type AcpMcpServerInput, type AcpPermissionDecision, type AcpPermissionHandler, type AcpPermissionOption, type AcpPermissionRequest, type AcpSessionController, type ModelOption, type AttachAcpSessionOptions, type AccountFailure, type AccountFailureClassifier, buildAcpSessionNewParams, normalizeModels, detectAcpModels, attachAcpSession, noopAccountFailureClassifier, mapPiRpcEvent, attachPiRpcSession, parsePiModels as parsePiRpcModels, type PiRpcSession, type PiRpcSessionOptions, } from './agent-protocol/index.js';
-export * from './model-discovery.js';
+export * from './model-discovery-native.js';
 export { getRuntimeModelDiscoveryDeps, defaultModelDiscoveryDeps, parseClaudeInitializeMetadata, parsePiRpcMetadata } from './model-discovery-adapters.js';
 export * from './runtime-state.js';
+export * from './native-runtime.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -70,7 +70,8 @@ export * from './telemetry-sink.js';
 export * from './providers/index.js';
 /** ACP + pi-rpc protocol adapters over the shared JSON-line-stream core. See aliases above. */
 export { createJsonLineStream, buildAcpSessionNewParams, normalizeModels, detectAcpModels, attachAcpSession, noopAccountFailureClassifier, mapPiRpcEvent, attachPiRpcSession, parsePiModels as parsePiRpcModels, } from './agent-protocol/index.js';
-export * from './model-discovery.js';
+export * from './model-discovery-native.js';
 export { getRuntimeModelDiscoveryDeps, defaultModelDiscoveryDeps, parseClaudeInitializeMetadata, parsePiRpcMetadata } from './model-discovery-adapters.js';
 export * from './runtime-state.js';
+export * from './native-runtime.js';
 //# sourceMappingURL=index.js.map

package/dist/invocation.js

@@ -13,7 +13,7 @@ import { execFile } from 'node:child_process';
 import { scheduleProbeProcess } from './probe-scheduler.js';
 import os from 'node:os';
 import { promisify } from 'node:util';
-import { createCommandInvocation } from '@jini-ai/platform';
+import { createCommandInvocation } from '@jini-ai/platform/command';
 const execFileP = promisify(execFile);
 // Agent probes (model-list / version / help / auth-status) are short
 // read-only metadata calls that never need the caller's project files.

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

@@ -1,6 +1,6 @@
 import { type AgentRuntimeState } from './runtime-state.js';
-import { type AgentDiscoveryConfiguration } from './model-discovery.js';
-import type { ModelDiscoveryContext, ModelDiscoveryDeps, ModelProbeResult } from './model-discovery-types.js';
+import { type AcpModelProbe } from './acp-model-probe.js';
+import type { AgentDiscoveryConfiguration, ModelDiscoveryContext, ModelDiscoveryDeps, ModelProbeResult } from './model-discovery-types.js';
 export declare function modelProbeTimeoutMs(agentId: string): number;
 /** Shared CLI-subcommand adapter. Output parsers are pure def-owned functions, not vendor tools. */
 export declare function probeCliSubcommand(context: ModelDiscoveryContext, config: AgentDiscoveryConfiguration, deps: ModelDiscoveryDeps, signal: AbortSignal): Promise<ModelProbeResult>;
@@ -24,4 +24,13 @@ export declare function parsePiRpcMetadata(stdout: string): ModelProbeResult;
 export declare function getRuntimeModelDiscoveryDeps({ state }: {
     state: AgentRuntimeState;
 }, _optional?: Record<string, never>): ModelDiscoveryDeps;
+/** Adapt the existing ACP port to catalog metadata; array-only transports cannot claim a default.
+ * Keeps invocation normalization, cancellation and the shared process budget in the native adapter.
+ * @param required - The host's existing ACP probe, optionally capable of reporting current selection.
+ * @returns A catalog adapter using that probe without changing security or concurrency guarantees.
+ * @example const acp = createAcpDiscoveryAdapter({ probe: hostProbe });
+ */
+export declare function createAcpDiscoveryAdapter({ probe }: {
+    probe: AcpModelProbe;
+}, _optional?: Record<string, never>): ModelDiscoveryDeps['acp'];
 //# sourceMappingURL=model-discovery-adapters.d.ts.map

package/dist/model-discovery-adapters.js

@@ -4,15 +4,15 @@ 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 { detectAcpModelMetadata } from './agent-protocol/acp/models.js';
+import { createCommandInvocation } from '@jini-ai/platform/command';
+import { nativeAcpModelProbe } from './acp-model-probe.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'],
@@ -340,11 +340,7 @@ export const defaultModelDiscoveryDeps = {
                 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 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 } : {}) };
-        } },
+    acp: createAcpDiscoveryAdapter({ probe: nativeAcpModelProbe }),
     rpc: { async probe({ agentId, context, signal }) {
             // UNVERIFIED locally: use official prompt-free SDK interfaces, not invented CLI flags.
             if (agentId === 'copilot')
@@ -399,6 +395,27 @@ export function parsePiRpcMetadata(stdout) {
 export function getRuntimeModelDiscoveryDeps({ state }, _optional = {}) {
     if (state === defaultRuntimeState)
         return defaultModelDiscoveryDeps;
-    return state.discoveryDeps ??= { ...defaultModelDiscoveryDeps, cache: state.modelCatalog };
+    return state.discoveryDeps ??= { ...defaultModelDiscoveryDeps, cache: state.modelCatalog,
+        acp: createAcpDiscoveryAdapter({ probe: state.acpModelProbe ?? nativeAcpModelProbe }),
+    };
+}
+/** Adapt the existing ACP port to catalog metadata; array-only transports cannot claim a default.
+ * Keeps invocation normalization, cancellation and the shared process budget in the native adapter.
+ * @param required - The host's existing ACP probe, optionally capable of reporting current selection.
+ * @returns A catalog adapter using that probe without changing security or concurrency guarantees.
+ * @example const acp = createAcpDiscoveryAdapter({ probe: hostProbe });
+ */
+export function createAcpDiscoveryAdapter({ probe }, _optional = {}) {
+    return { async probe({ context, args, signal }) {
+            const invocation = createCommandInvocation({ command: context.executable, args: [...args], env: context.env });
+            const required = { bin: invocation.command, args: invocation.args };
+            const optional = { cwd: context.cwd, env: context.env, timeoutMs: 15_000, signal };
+            const result = await scheduleProbeProcess({ work: async () => {
+                    if (probe.detectMetadata)
+                        return probe.detectMetadata(required, optional);
+                    return { models: await probe.detectModels(required, optional), currentModelId: null };
+                } }, { signal });
+            return { models: result.models, source: 'rpc', coverage: 'account', ...(result.currentModelId ? { defaultSelectionId: result.currentModelId } : {}) };
+        } };
 }
 //# 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,34 +1,14 @@
 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();
 /** One cold catalog probe per host; queued callers keep cancellation responsive. */
 async function boundedProbe(deps, work, signal) {
@@ -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/native-runtime.d.ts

@@ -0,0 +1,35 @@
+/** Native host composition: one state and transport, with environment policies resolved once. */
+import { type AcpModelProbe } from './acp-model-probe.js';
+import { detectAgents, probeAgentModels } from './detection.js';
+import { resolveAgentLaunch } from './launch.js';
+import { getAgentDef } from './registry.js';
+import { type AgentRuntimeState } from './runtime-state.js';
+import type { RuntimeEnv } from './types.js';
+export interface NativeAgentRuntime {
+    readonly state: AgentRuntimeState;
+    readonly hostEnv: RuntimeEnv;
+    readonly codexDisablePlugins: boolean;
+    readonly piGracefulShutdownMs: number;
+    readonly detectAgents: typeof detectAgents;
+    readonly probeAgentModels: typeof probeAgentModels;
+    readonly resolveAgentLaunch: typeof resolveAgentLaunch;
+    readonly getAgentDef: (required: Parameters<typeof getAgentDef>[0], optional?: Record<string, never>) => ReturnType<typeof getAgentDef>;
+    /** Drain owned discovery before clearing caches, so late probes cannot repopulate them. */
+    dispose(required: Record<string, never>, optional?: Record<string, never>): Promise<void>;
+}
+/** Bind existing runtime owners to a host; copies env without performing I/O.
+ * @param required - The host's selected environment, used instead of ambient process configuration.
+ * @param optional - An existing state, ACP transport, or explicit policies overriding env defaults.
+ * @returns Bound runtime operations and an idempotent cache disposer. Stop runs before disposing.
+ * Discovery after disposal rejects with `InvalidStateError`; native probe failures retain their existing outcomes.
+ * @example const runtime = createNativeAgentRuntime({ env: process.env });
+ */
+export declare function createNativeAgentRuntime({ env }: {
+    env: RuntimeEnv;
+}, { state, acpModelProbe, codexDisablePlugins, piGracefulShutdownMs, }?: {
+    state?: AgentRuntimeState;
+    acpModelProbe?: AcpModelProbe;
+    codexDisablePlugins?: boolean;
+    piGracefulShutdownMs?: number;
+}): NativeAgentRuntime;
+//# sourceMappingURL=native-runtime.d.ts.map

package/dist/native-runtime.js

@@ -0,0 +1,53 @@
+/** Native host composition: one state and transport, with environment policies resolved once. */
+import { nativeAcpModelProbe } from './acp-model-probe.js';
+import { detectAgents, probeAgentModels } from './detection.js';
+import { resolveAgentLaunch } from './launch.js';
+import { getAgentDef } from './registry.js';
+import { createAcpDiscoveryAdapter } from './model-discovery-adapters.js';
+import { bindRuntimeAgentDef, createAgentRuntimeState } from './runtime-state.js';
+/** Bind existing runtime owners to a host; copies env without performing I/O.
+ * @param required - The host's selected environment, used instead of ambient process configuration.
+ * @param optional - An existing state, ACP transport, or explicit policies overriding env defaults.
+ * @returns Bound runtime operations and an idempotent cache disposer. Stop runs before disposing.
+ * Discovery after disposal rejects with `InvalidStateError`; native probe failures retain their existing outcomes.
+ * @example const runtime = createNativeAgentRuntime({ env: process.env });
+ */
+export function createNativeAgentRuntime({ env }, { state = createAgentRuntimeState({}), acpModelProbe = state.acpModelProbe ?? nativeAcpModelProbe, codexDisablePlugins = env.CODEX_DISABLE_PLUGINS === '1', piGracefulShutdownMs = Number(env.PI_GRACEFUL_SHUTDOWN_MS) || 5000, } = {}) {
+    const hostEnv = { ...env };
+    if (state.discoveryDeps && state.acpModelProbe !== acpModelProbe) {
+        state.discoveryDeps = { ...state.discoveryDeps, acp: createAcpDiscoveryAdapter({ probe: acpModelProbe }) };
+    }
+    state.acpModelProbe = acpModelProbe;
+    const pending = new Set();
+    let disposal;
+    /** Retain operations until disposal can wait for their final cache writes. */
+    function track(work) {
+        if (disposal)
+            return Promise.reject(new DOMException('Agent runtime is disposed', 'InvalidStateError'));
+        const result = work();
+        pending.add(result);
+        void result.then(() => pending.delete(result), () => pending.delete(result));
+        return result;
+    }
+    return {
+        state, hostEnv, codexDisablePlugins, piGracefulShutdownMs,
+        detectAgents: (required, optional = {}) => track(() => detectAgents(required, { ...optional, state, env: hostEnv })),
+        probeAgentModels: (required, optional = {}) => track(() => probeAgentModels(required, { ...optional, state, env: hostEnv })),
+        resolveAgentLaunch: (required, optional = {}) => resolveAgentLaunch(required, { ...optional, state, env: hostEnv }),
+        getAgentDef: (required, _optional = {}) => {
+            const def = getAgentDef(required);
+            return def ? bindRuntimeAgentDef({ def, state }, { codexDisablePlugins }) : def;
+        },
+        dispose(_required, _optional = {}) {
+            disposal ??= (async () => {
+                await Promise.allSettled([...pending, ...state.detections.values(), ...state.capabilityProbes.values(),
+                    ...[...state.modelCatalog.values()].flatMap(entry => entry.pending ? [entry.pending] : []),
+                    ...[...state.claudeModels.values()].map(entry => entry.value),
+                ]);
+                state.clear({}, {});
+            })();
+            return disposal;
+        },
+    };
+}
+//# sourceMappingURL=native-runtime.js.map

package/dist/runtime-state.d.ts

@@ -1,4 +1,5 @@
 /** Mutable runtime data belongs to one host. Compatibility functions use defaultRuntimeState. */
+import type { AcpModelProbe } from './acp-model-probe.js';
 import type { RuntimeAgentDef, RuntimeCapabilityMap, RuntimeModelOption, DetectedAgent } from './types.js';
 import type { ModelCacheEntry, ModelDiscoveryDeps } from './model-discovery-types.js';
 export interface AgentRuntimeState {
@@ -13,6 +14,8 @@ export interface AgentRuntimeState {
         expiresAt: number;
         value: Promise<readonly RuntimeModelOption[] | null>;
     }>;
+    /** Host-owned transport. Absent only for legacy definitions using the compatibility wrapper. */
+    acpModelProbe?: AcpModelProbe;
     discoveryDeps?: ModelDiscoveryDeps;
     readonly modelCatalog: Map<string, ModelCacheEntry>;
     readonly executable: {
@@ -32,10 +35,12 @@ export interface AgentRuntimeState {
  * Returns empty owned maps; no I/O. @complexity O(1) initialization; retained data grows with probes. */
 export declare function createAgentRuntimeState(_required: Record<string, never>, _optional?: Record<string, never>): AgentRuntimeState;
 export declare const defaultRuntimeState: AgentRuntimeState;
-/** Bind the agent argument builder to the same capability state detection and launch use.
+/** Bind model probes and the argument builder to the host transport, capability state and plugin policy.
  * Returns a definition copy without mutating the registry. @complexity O(1). */
 export declare function bindRuntimeAgentDef({ def, state }: {
     def: RuntimeAgentDef;
     state: AgentRuntimeState;
-}, _optional?: Record<string, never>): RuntimeAgentDef;
+}, { codexDisablePlugins }?: {
+    codexDisablePlugins?: boolean;
+}): RuntimeAgentDef;
 //# sourceMappingURL=runtime-state.d.ts.map