@jini-ai/agent-runtime 0.4.6 → 0.4.7

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.4.7 — 2026-10-13
+
+- New `createNativeAgentRuntime({ env }, { state, acpModelProbe, codexDisablePlugins, piGracefulShutdownMs })`: one host-owned runtime state with detection, launch and definitions bound to it, environment policies resolved once, and `dispose({})` that drains in-flight discovery before clearing caches.
+- ACP model probes can come from the host (`AgentRuntimeState.acpModelProbe`, `fetchModels(required, { acpModelProbe })`); `setAcpModelProbe` stays as the compatibility setter for unbound definitions.
+- Codex `--disable plugins` and the pi RPC shutdown grace period are explicit (`RuntimeBuildOptions.codexDisablePlugins`, `PiRpcSessionOptions.gracefulShutdownMs`); `CODEX_DISABLE_PLUGINS` / `PI_GRACEFUL_SHUTDOWN_MS` are read at native composition instead of inside `buildArgs` / the session.
+
 ## 0.4.6 — 2026-10-13
 
 - New `./model-discovery` subpath: the discovery policy with injected `deps` and `probes` (`createAgentModelDiscovery({ agentId, configuration, deps, probes })`, `modelDiscoveryForDef({ def, deps })`, `resolveModelForLaunch({ def, context, deps })`). It loads no child_process/fs or native adapters. The root keeps the published scalar signatures, wired to the native probes.

package/dist/acp-model-probe.d.ts

@@ -12,18 +12,29 @@ export interface AcpModelProbeRequest {
     cwd?: string;
     env?: RuntimeEnv;
     timeoutMs?: number;
+    signal?: AbortSignal;
     clientName?: string;
     clientVersion?: string;
     defaultModelOption?: RuntimeModelOption;
 }
 export interface AcpModelProbe {
     detectModels(requiredArgs: Pick<AcpModelProbeRequest, 'bin' | 'args'>, optionalArgs?: Omit<AcpModelProbeRequest, 'bin' | 'args'>): Promise<RuntimeModelOption[]>;
+    /** Optional metadata capability preserves a native current selection without guessing from order. */
+    detectMetadata?(requiredArgs: Pick<AcpModelProbeRequest, 'bin' | 'args'>, optionalArgs?: Omit<AcpModelProbeRequest, 'bin' | 'args'>): Promise<{
+        models: RuntimeModelOption[];
+        currentModelId: string | null;
+    }>;
 }
 export declare const noopAcpModelProbe: AcpModelProbe;
-/** Install a transport/test double. Pass `null` to restore the native transport. */
+/** Native adapter selected once by each host composition; independent of the compatibility setter. */
+export declare const nativeAcpModelProbe: AcpModelProbe;
+/** Compatibility setter for unbound definitions. Owned hosts keep their selected transport.
+ * Pass `null` to restore the native transport for the legacy wrapper. */
 export declare function setAcpModelProbe({ probe }: {
     probe: AcpModelProbe | null;
 }): void;
-/** Delegate to the currently installed probe. */
-export declare function detectAcpModels(requiredArgs: Pick<AcpModelProbeRequest, "bin" | "args">, optionalArgs?: Omit<AcpModelProbeRequest, "bin" | "args">): Promise<RuntimeModelOption[]>;
+/** Delegate to an explicit host probe, or the currently installed compatibility probe. */
+export declare function detectAcpModels(requiredArgs: Pick<AcpModelProbeRequest, "bin" | "args">, optionalArgs?: Omit<AcpModelProbeRequest, "bin" | "args"> & {
+    probe?: AcpModelProbe;
+}): Promise<RuntimeModelOption[]>;
 //# sourceMappingURL=acp-model-probe.d.ts.map

package/dist/acp-model-probe.js

@@ -1,17 +1,23 @@
-import { detectAcpModels as probeNativeModels } from './agent-protocol/acp/models.js';
+import { detectAcpModels as probeNativeModels, detectAcpModelMetadata } from './agent-protocol/acp/models.js';
 export const noopAcpModelProbe = {
     async detectModels() {
         return [];
     },
 };
-const nativeAcpModelProbe = { detectModels: (required, optional = {}) => probeNativeModels(required, { ...optional, ...(optional.env ? { env: optional.env } : {}) }) };
+/** Native adapter selected once by each host composition; independent of the compatibility setter. */
+export const nativeAcpModelProbe = {
+    detectModels: (required, optional = {}) => probeNativeModels(required, optional),
+    detectMetadata: (required, optional = {}) => detectAcpModelMetadata(required, optional),
+};
 let activeAcpModelProbe = nativeAcpModelProbe;
-/** Install a transport/test double. Pass `null` to restore the native transport. */
+/** Compatibility setter for unbound definitions. Owned hosts keep their selected transport.
+ * Pass `null` to restore the native transport for the legacy wrapper. */
 export function setAcpModelProbe({ probe }) {
     activeAcpModelProbe = probe ?? nativeAcpModelProbe;
 }
-/** Delegate to the currently installed probe. */
+/** Delegate to an explicit host probe, or the currently installed compatibility probe. */
 export async function detectAcpModels(requiredArgs, optionalArgs = {}) {
-    return activeAcpModelProbe.detectModels(requiredArgs, optionalArgs);
+    const { probe = activeAcpModelProbe, ...request } = optionalArgs;
+    return probe.detectModels(requiredArgs, request);
 }
 //# sourceMappingURL=acp-model-probe.js.map

package/dist/agent-protocol/pi-rpc/session.d.ts

@@ -19,6 +19,8 @@ export type PiRpcSessionOptions = {
     imagePaths?: string[];
     uploadRoot?: string;
     parentSession?: string;
+    /** Explicit post-completion grace period before SIGTERM. Native hosts resolve env defaults. */
+    gracefulShutdownMs?: number;
 };
 /** Handle returned by `attachPiRpcSession` for querying run state and requesting abort. */
 export type PiRpcSession = {

package/dist/agent-protocol/pi-rpc/session.js

@@ -248,7 +248,7 @@ export function handlePiResponseMessage({ raw, parentSessionRpcId, promptRpcId,
  * @returns A `PiRpcSession` handle with `hasFatalError`, `getLastSessionPath`, and `abort`.
  */
 export function attachPiRpcSession(requiredArgs, optionalArgs = {}) {
-    const { child, prompt, cwd, model, send, imagePaths, uploadRoot, parentSession, } = { ...optionalArgs, ...requiredArgs };
+    const { child, prompt, cwd, model, send, imagePaths, uploadRoot, parentSession, gracefulShutdownMs = 5000, } = { ...optionalArgs, ...requiredArgs };
     const stdin = child.stdin;
     const stdout = child.stdout;
     if (stdin === null) {
@@ -343,13 +343,12 @@ export function attachPiRpcSession(requiredArgs, optionalArgs = {}) {
         catch (err) {
             fail(`stdin close: ${errorMessage(err)}`);
         }
-        // Grace period before SIGTERM. Configurable via PI_GRACEFUL_SHUTDOWN_MS
-        // for resource-constrained machines where the event loop drains slowly.
-        const shutdownMs = Number(process.env.PI_GRACEFUL_SHUTDOWN_MS) || 5000;
+        // Grace period before SIGTERM lets resource-constrained machines drain a slow event loop.
+        // The host supplies timing explicitly, resolving PI_GRACEFUL_SHUTDOWN_MS at composition.
         setTimeout(() => {
             if (!child.killed)
                 child.kill('SIGTERM');
-        }, shutdownMs);
+        }, gracefulShutdownMs);
     };
     // ---- Inbound: parse stdout events ----
     const parser = createJsonLineStream({ onMessage: ({ message: raw }) => {

package/dist/defs/auggie.d.ts

@@ -6,7 +6,9 @@ export declare const auggieAgentDef: {
     fetchModels: ({ resolvedBin, env }: {
         resolvedBin: string;
         env: import("../types.js").RuntimeEnv;
-    }) => Promise<import("../types.js").RuntimeModelOption[]>;
+    }, { acpModelProbe }?: {
+        acpModelProbe?: import("../acp-model-probe.js").AcpModelProbe;
+    } | undefined) => Promise<import("../types.js").RuntimeModelOption[]>;
     fallbackModels: import("../types.js").RuntimeModelOption[];
     buildArgs: () => string[];
     streamFormat: string;

package/dist/defs/auggie.js

@@ -15,7 +15,8 @@ export const auggieAgentDef = {
     name: 'Auggie CLI',
     bin: 'auggie',
     versionArgs: ['--version'],
-    fetchModels: async ({ resolvedBin, env }) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+    fetchModels: async ({ resolvedBin, env }, { acpModelProbe } = {}) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+        ...(acpModelProbe ? { probe: acpModelProbe } : {}),
         bin: resolvedBin,
         args: ['--acp'],
         env,

package/dist/defs/cline.d.ts

@@ -6,7 +6,9 @@ export declare const clineAgentDef: {
     fetchModels: ({ resolvedBin, env }: {
         resolvedBin: string;
         env: import("../types.js").RuntimeEnv;
-    }) => Promise<import("../types.js").RuntimeModelOption[]>;
+    }, { acpModelProbe }?: {
+        acpModelProbe?: import("../acp-model-probe.js").AcpModelProbe;
+    } | undefined) => Promise<import("../types.js").RuntimeModelOption[]>;
     fallbackModels: import("../types.js").RuntimeModelOption[];
     buildArgs: () => string[];
     streamFormat: string;

package/dist/defs/cline.js

@@ -17,7 +17,8 @@ export const clineAgentDef = {
     name: 'Cline',
     bin: 'cline',
     versionArgs: ['--version'],
-    fetchModels: async ({ resolvedBin, env }) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+    fetchModels: async ({ resolvedBin, env }, { acpModelProbe } = {}) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+        ...(acpModelProbe ? { probe: acpModelProbe } : {}),
         bin: resolvedBin,
         args: ['--acp'],
         env,

package/dist/defs/codex.js

@@ -1,6 +1,6 @@
 import { createAgentModelDiscovery } from '../model-discovery-native.js';
-/** CODEX_SANDBOX_MODE and CODEX_DISABLE_PLUGINS are adapter-scoped operator overrides;
- * no product-specific environment naming is required. */
+/** CODEX_SANDBOX_MODE remains an adapter-scoped operator override; plugin policy is supplied
+ * explicitly by the host, whose native composition resolves CODEX_DISABLE_PLUGINS. */
 import { DEFAULT_MODEL_OPTION, clampCodexReasoning } from './shared.js';
 /**
  * The `visibility` values that mean "reachable by id, but do not render in a picker".
@@ -292,7 +292,7 @@ export const codexAgentDef = {
         const args = resumeSessionId
             ? ['exec', 'resume', '--json', '--skip-git-repo-check', ...sandboxArgs]
             : ['exec', '--json', '--skip-git-repo-check', ...sandboxArgs];
-        if (process.env.CODEX_DISABLE_PLUGINS === '1') {
+        if (options.codexDisablePlugins === true) {
             args.push('--disable', 'plugins');
         }
         // `-C <cwd>` and `--add-dir <dir>` are CREATE-only flags: `codex exec

package/dist/defs/devin.d.ts

@@ -6,7 +6,9 @@ export declare const devinAgentDef: {
     fetchModels: ({ resolvedBin, env }: {
         resolvedBin: string;
         env: import("../types.js").RuntimeEnv;
-    }) => Promise<import("../types.js").RuntimeModelOption[]>;
+    }, { acpModelProbe }?: {
+        acpModelProbe?: import("../acp-model-probe.js").AcpModelProbe;
+    } | undefined) => Promise<import("../types.js").RuntimeModelOption[]>;
     fallbackModels: import("../types.js").RuntimeModelOption[];
     buildArgs: ({ prompt: _prompt, imagePaths: _imagePaths }: {
         prompt: string;

package/dist/defs/devin.js

@@ -7,7 +7,8 @@ export const devinAgentDef = {
     name: 'Devin for Terminal',
     bin: 'devin',
     versionArgs: ['--version'],
-    fetchModels: async ({ resolvedBin, env }) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+    fetchModels: async ({ resolvedBin, env }, { acpModelProbe } = {}) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+        ...(acpModelProbe ? { probe: acpModelProbe } : {}),
         bin: resolvedBin,
         args: [
             '--permission-mode',

package/dist/defs/goose.d.ts

@@ -6,7 +6,9 @@ export declare const gooseAgentDef: {
     fetchModels: ({ resolvedBin, env }: {
         resolvedBin: string;
         env: import("../types.js").RuntimeEnv;
-    }) => Promise<import("../types.js").RuntimeModelOption[]>;
+    }, { acpModelProbe }?: {
+        acpModelProbe?: import("../acp-model-probe.js").AcpModelProbe;
+    } | undefined) => Promise<import("../types.js").RuntimeModelOption[]>;
     fallbackModels: import("../types.js").RuntimeModelOption[];
     buildArgs: () => string[];
     streamFormat: string;

package/dist/defs/goose.js

@@ -18,7 +18,8 @@ export const gooseAgentDef = {
     name: 'goose',
     bin: 'goose',
     versionArgs: ['--version'],
-    fetchModels: async ({ resolvedBin, env }) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+    fetchModels: async ({ resolvedBin, env }, { acpModelProbe } = {}) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+        ...(acpModelProbe ? { probe: acpModelProbe } : {}),
         bin: resolvedBin,
         args: ['acp'],
         env,

package/dist/defs/hermes.d.ts

@@ -6,7 +6,9 @@ export declare const hermesAgentDef: {
     fetchModels: ({ resolvedBin, env }: {
         resolvedBin: string;
         env: import("../types.js").RuntimeEnv;
-    }) => Promise<import("../types.js").RuntimeModelOption[]>;
+    }, { acpModelProbe }?: {
+        acpModelProbe?: import("../acp-model-probe.js").AcpModelProbe;
+    } | undefined) => Promise<import("../types.js").RuntimeModelOption[]>;
     fallbackModels: import("../types.js").RuntimeModelOption[];
     buildArgs: () => string[];
     streamFormat: string;

package/dist/defs/hermes.js

@@ -7,7 +7,8 @@ export const hermesAgentDef = {
     name: 'Hermes',
     bin: 'hermes',
     versionArgs: ['--version'],
-    fetchModels: async ({ resolvedBin, env }) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+    fetchModels: async ({ resolvedBin, env }, { acpModelProbe } = {}) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+        ...(acpModelProbe ? { probe: acpModelProbe } : {}),
         bin: resolvedBin,
         args: ['acp', '--accept-hooks'],
         env,

package/dist/defs/kilo.d.ts

@@ -6,7 +6,9 @@ export declare const kiloAgentDef: {
     fetchModels: ({ resolvedBin, env }: {
         resolvedBin: string;
         env: import("../types.js").RuntimeEnv;
-    }) => Promise<import("../types.js").RuntimeModelOption[]>;
+    }, { acpModelProbe }?: {
+        acpModelProbe?: import("../acp-model-probe.js").AcpModelProbe;
+    } | undefined) => Promise<import("../types.js").RuntimeModelOption[]>;
     fallbackModels: import("../types.js").RuntimeModelOption[];
     buildArgs: () => string[];
     streamFormat: string;

package/dist/defs/kilo.js

@@ -7,7 +7,8 @@ export const kiloAgentDef = {
     name: 'Kilo',
     bin: 'kilo',
     versionArgs: ['--version'],
-    fetchModels: async ({ resolvedBin, env }) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+    fetchModels: async ({ resolvedBin, env }, { acpModelProbe } = {}) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+        ...(acpModelProbe ? { probe: acpModelProbe } : {}),
         bin: resolvedBin,
         args: ['acp'],
         env,

package/dist/defs/kimi.d.ts

@@ -7,7 +7,9 @@ export declare const kimiAgentDef: {
     fetchModels: ({ resolvedBin, env }: {
         resolvedBin: string;
         env: import("../types.js").RuntimeEnv;
-    }) => Promise<import("../types.js").RuntimeModelOption[]>;
+    }, { acpModelProbe }?: {
+        acpModelProbe?: import("../acp-model-probe.js").AcpModelProbe;
+    } | undefined) => Promise<import("../types.js").RuntimeModelOption[]>;
     buildArgs: () => string[];
     streamFormat: string;
     mcpDiscovery: string;

package/dist/defs/kimi.js

@@ -13,7 +13,8 @@ export const kimiAgentDef = {
         { id: 'moonshot-v1-8k', label: 'moonshot-v1-8k' },
         { id: 'moonshot-v1-32k', label: 'moonshot-v1-32k' },
     ],
-    fetchModels: async ({ resolvedBin, env }) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+    fetchModels: async ({ resolvedBin, env }, { acpModelProbe } = {}) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+        ...(acpModelProbe ? { probe: acpModelProbe } : {}),
         bin: resolvedBin,
         args: ['acp'],
         env,

package/dist/defs/kiro.d.ts

@@ -6,7 +6,9 @@ export declare const kiroAgentDef: {
     fetchModels: ({ resolvedBin, env }: {
         resolvedBin: string;
         env: import("../types.js").RuntimeEnv;
-    }) => Promise<import("../types.js").RuntimeModelOption[]>;
+    }, { acpModelProbe }?: {
+        acpModelProbe?: import("../acp-model-probe.js").AcpModelProbe;
+    } | undefined) => Promise<import("../types.js").RuntimeModelOption[]>;
     fallbackModels: import("../types.js").RuntimeModelOption[];
     buildArgs: () => string[];
     streamFormat: string;

package/dist/defs/kiro.js

@@ -7,7 +7,8 @@ export const kiroAgentDef = {
     name: 'Kiro CLI',
     bin: 'kiro-cli',
     versionArgs: ['--version'],
-    fetchModels: async ({ resolvedBin, env }) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+    fetchModels: async ({ resolvedBin, env }, { acpModelProbe } = {}) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+        ...(acpModelProbe ? { probe: acpModelProbe } : {}),
         bin: resolvedBin,
         args: ['acp'],
         env,

package/dist/defs/reasonix.d.ts

@@ -7,7 +7,9 @@ export declare const reasonixAgentDef: {
     fetchModels: ({ resolvedBin, env }: {
         resolvedBin: string;
         env: import("../types.js").RuntimeEnv;
-    }) => Promise<import("../types.js").RuntimeModelOption[]>;
+    }, { acpModelProbe }?: {
+        acpModelProbe?: import("../acp-model-probe.js").AcpModelProbe;
+    } | undefined) => Promise<import("../types.js").RuntimeModelOption[]>;
     buildArgs: () => string[];
     streamFormat: string;
     mcpDiscovery: string;

package/dist/defs/reasonix.js

@@ -24,7 +24,8 @@ export const reasonixAgentDef = {
     bin: 'reasonix',
     fallbackBins: ['dsnix'],
     versionArgs: ['--version'],
-    fetchModels: async ({ resolvedBin, env }) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+    fetchModels: async ({ resolvedBin, env }, { acpModelProbe } = {}) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+        ...(acpModelProbe ? { probe: acpModelProbe } : {}),
         bin: resolvedBin,
         args: ['acp'],
         env,

package/dist/defs/trae-cli.d.ts

@@ -7,7 +7,9 @@ export declare const traeCliAgentDef: {
     fetchModels: ({ resolvedBin, env }: {
         resolvedBin: string;
         env: import("../types.js").RuntimeEnv;
-    }) => Promise<import("../types.js").RuntimeModelOption[]>;
+    }, { acpModelProbe }?: {
+        acpModelProbe?: import("../acp-model-probe.js").AcpModelProbe;
+    } | undefined) => Promise<import("../types.js").RuntimeModelOption[]>;
     fallbackModels: import("../types.js").RuntimeModelOption[];
     buildArgs: ({ prompt: _prompt, imagePaths: _imagePaths }: {
         prompt: string;

package/dist/defs/trae-cli.js

@@ -8,7 +8,8 @@ export const traeCliAgentDef = {
     bin: 'traecli',
     versionArgs: ['--version'],
     versionProbeTimeoutMs: 10_000,
-    fetchModels: async ({ resolvedBin, env }) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+    fetchModels: async ({ resolvedBin, env }, { acpModelProbe } = {}) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+        ...(acpModelProbe ? { probe: acpModelProbe } : {}),
         bin: resolvedBin,
         args: ['acp', 'serve'],
         env,

package/dist/defs/vibe.d.ts

@@ -6,7 +6,9 @@ export declare const vibeAgentDef: {
     fetchModels: ({ resolvedBin, env }: {
         resolvedBin: string;
         env: import("../types.js").RuntimeEnv;
-    }) => Promise<import("../types.js").RuntimeModelOption[]>;
+    }, { acpModelProbe }?: {
+        acpModelProbe?: import("../acp-model-probe.js").AcpModelProbe;
+    } | undefined) => Promise<import("../types.js").RuntimeModelOption[]>;
     fallbackModels: import("../types.js").RuntimeModelOption[];
     buildArgs: () => never[];
     streamFormat: string;

package/dist/defs/vibe.js

@@ -7,7 +7,8 @@ export const vibeAgentDef = {
     name: 'Mistral Vibe CLI',
     bin: 'vibe-acp',
     versionArgs: ['--version'],
-    fetchModels: async ({ resolvedBin, env }) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+    fetchModels: async ({ resolvedBin, env }, { acpModelProbe } = {}) => (({ bin, args, ...optionalArgs }) => detectAcpModels({ bin, args }, optionalArgs))({
+        ...(acpModelProbe ? { probe: acpModelProbe } : {}),
         bin: resolvedBin,
         args: [],
         env,

package/dist/index.d.ts

@@ -50,4 +50,5 @@ export { createJsonLineStream, type AcpMcpServerInput, type AcpPermissionDecisio
 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

@@ -73,4 +73,5 @@ export { createJsonLineStream, buildAcpSessionNewParams, normalizeModels, detect
 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/model-discovery-adapters.d.ts

@@ -1,4 +1,5 @@
 import { type AgentRuntimeState } from './runtime-state.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. */
@@ -23,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

@@ -5,7 +5,7 @@ import { readFile, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { createCommandInvocation } from '@jini-ai/platform/command';
-import { detectAcpModelMetadata } from './agent-protocol/acp/models.js';
+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';
@@ -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/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

package/dist/runtime-state.js

@@ -21,11 +21,17 @@ export function createAgentRuntimeState(_required, _optional = {}) {
     return state;
 }
 export const defaultRuntimeState = createAgentRuntimeState({});
-/** 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 function bindRuntimeAgentDef({ def, state }, _optional = {}) {
-    return { ...def, buildArgs: (required, optional = {}) => def.buildArgs(required, {
-            ...optional, options: { ...optional.options, capabilities: state.capabilities.get(def.id) ?? {} },
+export function bindRuntimeAgentDef({ def, state }, { codexDisablePlugins } = {}) {
+    const fetchModels = def.fetchModels;
+    const boundFetchModels = fetchModels
+        ? (required, optional = {}) => fetchModels(required, {
+            ...optional, ...(state.acpModelProbe ? { acpModelProbe: state.acpModelProbe } : {}),
+        }) : undefined;
+    return { ...def, ...(boundFetchModels ? { fetchModels: boundFetchModels } : {}), buildArgs: (required, optional = {}) => def.buildArgs(required, {
+            ...optional, options: { ...optional.options, capabilities: state.capabilities.get(def.id) ?? {},
+                ...(codexDisablePlugins !== undefined ? { codexDisablePlugins } : {}) },
         }) };
 }
 //# sourceMappingURL=runtime-state.js.map

package/dist/types.d.ts

@@ -11,6 +11,7 @@
  * Ported from OD's `apps/daemon/src/runtimes/types.ts`. Product-neutral
  * as found — see `archived provenance ledger` for the full provenance table.
  */
+import type { AcpModelProbe } from './acp-model-probe.js';
 import type { AgentModelDiscoveryPort, ModelCatalogSnapshot, DefaultModelResolution, ModelIdentityKind } from './model-discovery-types.js';
 import type { ExecFileOptions } from 'node:child_process';
 import type { AgentDiagnostic } from '@jini-ai/protocol';
@@ -75,6 +76,8 @@ export type RuntimeReasoningInModelId = {
     levels: readonly RuntimeReasoningOption[];
 };
 export type RuntimeBuildOptions = {
+    /** Explicit host/run policy; environment defaults belong to native composition. */
+    codexDisablePlugins?: boolean;
     /** Host-scoped capability flags; absent retains the published compatibility cache. */
     capabilities?: RuntimeCapabilityMap;
     model?: string | null;
@@ -308,6 +311,8 @@ export type RuntimeAgentDef = Partial<AgentModelDiscoveryPort> & {
     fetchModels?: (requiredArgs: {
         resolvedBin: string;
         env: RuntimeEnv;
+    }, optionalArgs?: {
+        acpModelProbe?: AcpModelProbe;
     }) => Promise<RuntimeModelOption[] | null>;
     reasoningOptions?: RuntimeReasoningOption[];
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/agent-runtime",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "description": "Coding-agent runtime adapters: runtime registry, detection, launch, stream parsers, and the ACP/pi-rpc subprocess transport.",
   "license": "Apache-2.0",
   "repository": {
@@ -99,10 +99,10 @@
   "devDependencies": {
     "@vitest/coverage-v8": "^2.1.9",
     "@jini-ai/core": "^0.4.0",
-    "@jini-ai/integrations": "^0.4.2",
-    "@jini-ai/platform": "^0.5.5",
+    "@jini-ai/oauth": "^0.2.2",
     "@jini-ai/protocol": "^0.4.4",
-    "@jini-ai/oauth": "^0.2.2"
+    "@jini-ai/platform": "^0.5.5",
+    "@jini-ai/integrations": "^0.4.2"
   },
   "dependencies": {
     "@jini-ai/core": "^0.4.4"