@jini-ai/agent-runtime 0.4.6 → 0.4.8

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.4.8 — 2026-10-13
+
+- The root import no longer needs the optional `@jini-ai/integrations` peer: the media-provider catalog loads lazily, only when a default provider URL is needed. A missing peer at that point throws an actionable error with the import failure as its `cause`; explicit `*_BASE_URL` env values never touch it.
+- New `createElevenLabsVoiceClient({ http, clock }, { maxCacheEntries })`: voices listed through an injected `HttpClientPort`, expired entries swept, oldest evicted past the bound, `clearCache()`. `listElevenLabsVoiceOptions` stays as the compatibility wrapper over native fetch.
+
+## 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

@@ -1,11 +1,10 @@
 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/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';
@@ -303,6 +302,21 @@ function runProcess(input) {
             child.stdin?.end(input.stdin);
         }) }, { signal: input.signal });
 }
+/** Load the catalog owner only for a default URL, so importing the runtime never needs this peer.
+ * @param required - The vendor whose default endpoint is needed.
+ * @returns The catalog-owned base URL; explicit host URLs bypass this lookup.
+ * @throws An actionable load error retaining the original import failure as its cause.
+ * @complexity O(1) lookup after Node's cached module load.
+ */
+async function defaultProviderBaseUrl({ provider }, _optional = {}) {
+    try {
+        const { VENDOR_API_BASE_URLS } = await import('@jini-ai/integrations/media-providers/catalog');
+        return VENDOR_API_BASE_URLS[provider];
+    }
+    catch (cause) {
+        throw new Error('Could not load @jini-ai/integrations/media-providers/catalog. Install the optional peer @jini-ai/integrations or inject ModelDiscoveryDeps.credential to discover models with default provider URLs.', { cause });
+    }
+}
 export const defaultModelDiscoveryDeps = {
     process: { run: runProcess },
     fs: {
@@ -326,25 +340,21 @@ 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 || VENDOR_API_BASE_URLS.anthropic, apiKey: env.ANTHROPIC_API_KEY };
+                return { protocol: 'anthropic', baseUrl: env.ANTHROPIC_BASE_URL || await defaultProviderBaseUrl({ provider: '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 || VENDOR_API_BASE_URLS.anthropic, apiKey: env.ANTHROPIC_API_KEY };
+                return { protocol: 'anthropic', baseUrl: env.ANTHROPIC_BASE_URL || await defaultProviderBaseUrl({ provider: 'anthropic' }), apiKey: env.ANTHROPIC_API_KEY };
             if (/^(gemini\/|google\/|gemini-)/.test(selected) && env.GEMINI_API_KEY)
-                return { protocol: 'google', baseUrl: VENDOR_API_BASE_URLS.google, apiKey: env.GEMINI_API_KEY };
+                return { protocol: 'google', baseUrl: await defaultProviderBaseUrl({ provider: 'google' }), apiKey: env.GEMINI_API_KEY };
             if (/^openrouter\//.test(selected) && env.OPENROUTER_API_KEY)
-                return { protocol: 'openai', baseUrl: env.OPENROUTER_API_BASE || VENDOR_API_BASE_URLS.openrouter, apiKey: env.OPENROUTER_API_KEY };
+                return { protocol: 'openai', baseUrl: env.OPENROUTER_API_BASE || await defaultProviderBaseUrl({ provider: '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 || VENDOR_API_BASE_URLS.openai, apiKey: env.OPENAI_API_KEY };
+                return { protocol: 'openai', baseUrl: env.OPENAI_BASE_URL || env.OPENAI_API_BASE || await defaultProviderBaseUrl({ provider: '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 +409,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/providers/elevenlabs.d.ts

@@ -1,3 +1,4 @@
+import { type Clock, type HttpClientPort } from '@jini-ai/core/primitives';
 export interface ElevenLabsVoiceOption {
     voiceId: string;
     name: string;
@@ -17,16 +18,32 @@ export type ElevenLabsCredentialResolver = (requiredArgs: {
 export declare class ElevenLabsCredentialMissingError extends Error {
     constructor();
 }
-/**
- * Lists the ElevenLabs voice catalog for a workspace, resolving credentials
- * via the injected {@link ElevenLabsCredentialResolver} and caching the
- * result for {@link ELEVENLABS_VOICE_CACHE_TTL_MS}. Throws
- * {@link ElevenLabsCredentialMissingError} when no API key is configured.
- */
-export declare function listElevenLabsVoiceOptions({ workspaceKey, resolveCredentials }: {
+export interface ElevenLabsVoiceClientOptions {
+    /** Maximum cached workspace/credential/page variants; oldest inserted entries are evicted. */
+    maxCacheEntries?: number;
+}
+export interface ElevenLabsVoiceListRequired {
     workspaceKey: string;
     resolveCredentials: ElevenLabsCredentialResolver;
-}, options?: {
+}
+export interface ElevenLabsVoiceListOptions {
+    limit?: number;
+}
+/** Owns transport, time and a bounded voice cache for one host lifecycle.
+ * Supply the existing policy-enforcing HTTP client; this factory never constructs a raw transport.
+ * @throws RangeError for an invalid cache bound; credential/transport/JSON errors propagate from listing.
+ * @complexity O(c + v) per lookup, c <= maxCacheEntries and v <= the requested page size.
+ */
+export declare function createElevenLabsVoiceClient({ http, clock }: {
+    readonly http: HttpClientPort;
+    readonly clock: Clock;
+}, { maxCacheEntries }?: ElevenLabsVoiceClientOptions): {
+    listVoiceOptions: ({ workspaceKey, resolveCredentials }: ElevenLabsVoiceListRequired, options?: ElevenLabsVoiceListOptions) => Promise<ElevenLabsVoiceOption[]>;
+    clearCache: () => void;
+};
+export type ElevenLabsVoiceClient = ReturnType<typeof createElevenLabsVoiceClient>;
+/** Compatibility wrapper for existing callers. New hosts retain an injected client and clear it on shutdown. */
+export declare function listElevenLabsVoiceOptions(required: ElevenLabsVoiceListRequired, options?: {
     limit?: number;
     requestInit?: Pick<RequestInit, 'dispatcher'>;
 }): Promise<ElevenLabsVoiceOption[]>;

package/dist/providers/elevenlabs.js

@@ -2,7 +2,7 @@
  * @module providers/elevenlabs
  *
  * ElevenLabs voice-catalog listing (`GET /v2/voices`), with a short in-memory
- * TTL cache keyed by workspace + base URL + page size + a credential
+ * bounded, client-owned TTL cache keyed by workspace + base URL + page size + a credential
  * fingerprint (never the raw key). Ported from OD's
  * `integrations/elevenlabs-voices.ts`.
  *
@@ -16,6 +16,7 @@
  * ElevenLabs wire API once it has a key.
  */
 import { createHash } from 'node:crypto';
+import { createSystemClock } from '@jini-ai/core/primitives';
 import { FETCH_TIMEOUT_MS, fetchWithTimeout } from '@jini-ai/platform/fetch-with-timeout';
 const ELEVENLABS_DEFAULT_BASE_URL = 'https://api.elevenlabs.io';
 const ELEVENLABS_DEFAULT_VOICE_LIMIT = 100;
@@ -28,7 +29,6 @@ export class ElevenLabsCredentialMissingError extends Error {
         this.name = 'ElevenLabsCredentialMissingError';
     }
 }
-const voiceOptionsCache = new Map();
 function isRecord(value) {
     return value !== null && typeof value === 'object';
 }
@@ -87,53 +87,90 @@ function cloneVoiceOptions(voices) {
         ...(voice.labels ? { labels: { ...voice.labels } } : {}),
     }));
 }
-/**
- * Lists the ElevenLabs voice catalog for a workspace, resolving credentials
- * via the injected {@link ElevenLabsCredentialResolver} and caching the
- * result for {@link ELEVENLABS_VOICE_CACHE_TTL_MS}. Throws
- * {@link ElevenLabsCredentialMissingError} when no API key is configured.
+/** Owns transport, time and a bounded voice cache for one host lifecycle.
+ * Supply the existing policy-enforcing HTTP client; this factory never constructs a raw transport.
+ * @throws RangeError for an invalid cache bound; credential/transport/JSON errors propagate from listing.
+ * @complexity O(c + v) per lookup, c <= maxCacheEntries and v <= the requested page size.
  */
-export async function listElevenLabsVoiceOptions({ workspaceKey, resolveCredentials }, options = {}) {
-    const credentials = await resolveCredentials({ workspaceKey });
-    if (!credentials.apiKey) {
-        throw new ElevenLabsCredentialMissingError();
+export function createElevenLabsVoiceClient({ http, clock }, { maxCacheEntries = 64 } = {}) {
+    if (!Number.isSafeInteger(maxCacheEntries) || maxCacheEntries < 1) {
+        throw new RangeError('maxCacheEntries must be a positive safe integer');
+    }
+    const cache = new Map();
+    function sweepExpired(now) {
+        for (const [key, entry] of cache)
+            if (entry.expiresAt <= now)
+                cache.delete(key);
     }
-    const baseUrl = (credentials.baseUrl || ELEVENLABS_DEFAULT_BASE_URL).replace(/\/$/, '');
-    const pageSize = clampLimit(options.limit);
-    const cacheKey = voiceCacheKey({
-        workspaceKey,
-        baseUrl,
-        apiKey: credentials.apiKey,
-        pageSize,
-    });
-    const cached = voiceOptionsCache.get(cacheKey);
-    const now = Date.now();
-    if (cached && cached.expiresAt > now) {
-        return cloneVoiceOptions(cached.voices);
+    /** Drops retained voices so a host can release them when its lifecycle ends. */
+    function clearCache() { cache.clear(); }
+    /** Lists and clones credential-scoped catalog values; unsuccessful responses are never cached. */
+    async function listVoiceOptions({ workspaceKey, resolveCredentials }, options = {}) {
+        const credentials = await resolveCredentials({ workspaceKey });
+        if (!credentials.apiKey)
+            throw new ElevenLabsCredentialMissingError();
+        const baseUrl = (credentials.baseUrl || ELEVENLABS_DEFAULT_BASE_URL).replace(/\/$/, '');
+        const pageSize = clampLimit(options.limit);
+        const cacheKey = voiceCacheKey({ workspaceKey, baseUrl, apiKey: credentials.apiKey, pageSize });
+        sweepExpired(clock.nowMs());
+        const cached = cache.get(cacheKey);
+        if (cached)
+            return cloneVoiceOptions(cached.voices);
+        const resp = await http.send({ request: {
+                url: `${baseUrl}/v2/voices?page_size=${pageSize}`,
+                method: 'GET',
+                headers: { 'xi-api-key': credentials.apiKey, accept: 'application/json' },
+                idleTimeoutMs: FETCH_TIMEOUT_MS.QUICK,
+                totalDeadlineMs: FETCH_TIMEOUT_MS.QUICK,
+                maxResponseBytes: 1024 * 1024,
+            } });
+        if (resp.status < 200 || resp.status >= 300) {
+            throw new Error(`elevenlabs voices ${resp.status}: ${resp.bodyText.slice(0, 240)}`);
+        }
+        if (resp.bodyTruncated)
+            throw new Error('elevenlabs voices response was truncated');
+        const payload = JSON.parse(resp.bodyText);
+        const rawVoices = isRecord(payload) && Array.isArray(payload.voices) ? payload.voices : [];
+        const voices = rawVoices.map((voice) => normalizeVoice(voice))
+            .filter((voice) => voice !== null);
+        const now = clock.nowMs();
+        sweepExpired(now);
+        // Replacing a key refreshes insertion order; concurrent misses cannot grow past the bound.
+        cache.delete(cacheKey);
+        if (cache.size >= maxCacheEntries)
+            cache.delete(cache.keys().next().value);
+        cache.set(cacheKey, { expiresAt: now + ELEVENLABS_VOICE_CACHE_TTL_MS, voices: cloneVoiceOptions(voices) });
+        return voices;
     }
-    const resp = await fetchWithTimeout(`${baseUrl}/v2/voices?page_size=${pageSize}`, {
-        ...options.requestInit,
-        method: 'GET',
-        headers: {
-            'xi-api-key': credentials.apiKey,
-            accept: 'application/json',
-        },
-    }, { timeoutMs: FETCH_TIMEOUT_MS.QUICK });
-    if (!resp.ok) {
-        const errText = await resp.text();
-        throw new Error(`elevenlabs voices ${resp.status}: ${errText.slice(0, 240)}`);
+    return { listVoiceOptions, clearCache };
+}
+/** Native defaults stay in this compatibility assembly; injected clients use HttpClientPort directly. */
+function createCompatibilityClient(requestInit = {}) {
+    return createElevenLabsVoiceClient({ clock: createSystemClock(), http: {
+            async send({ request }) {
+                const response = await fetchWithTimeout(request.url, {
+                    ...requestInit, method: request.method, headers: request.headers,
+                }, { timeoutMs: FETCH_TIMEOUT_MS.QUICK });
+                // Same reads as before the port: json() on success, text() for the error message.
+                return { status: response.status, headers: {},
+                    bodyText: response.ok ? JSON.stringify(await response.json()) : await response.text() };
+            },
+        } });
+}
+const compatibilityClient = createCompatibilityClient();
+const dispatcherClients = new WeakMap();
+/** Compatibility wrapper for existing callers. New hosts retain an injected client and clear it on shutdown. */
+export async function listElevenLabsVoiceOptions(required, options = {}) {
+    let client = compatibilityClient;
+    const dispatcher = options.requestInit?.dispatcher;
+    if (dispatcher && typeof dispatcher === 'object') {
+        let owned = dispatcherClients.get(dispatcher);
+        if (!owned) {
+            owned = createCompatibilityClient(options.requestInit);
+            dispatcherClients.set(dispatcher, owned);
+        }
+        client = owned;
     }
-    const payload = await resp.json();
-    const rawVoices = isRecord(payload) && Array.isArray(payload.voices)
-        ? payload.voices
-        : [];
-    const voices = rawVoices
-        .map((voice) => normalizeVoice(voice))
-        .filter((voice) => voice !== null);
-    voiceOptionsCache.set(cacheKey, {
-        expiresAt: now + ELEVENLABS_VOICE_CACHE_TTL_MS,
-        voices: cloneVoiceOptions(voices),
-    });
-    return voices;
+    return client.listVoiceOptions(required, options);
 }
 //# sourceMappingURL=elevenlabs.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.8",
   "description": "Coding-agent runtime adapters: runtime registry, detection, launch, stream parsers, and the ACP/pi-rpc subprocess transport.",
   "license": "Apache-2.0",
   "repository": {
@@ -101,8 +101,8 @@
     "@jini-ai/core": "^0.4.0",
     "@jini-ai/integrations": "^0.4.2",
     "@jini-ai/platform": "^0.5.5",
-    "@jini-ai/protocol": "^0.4.4",
-    "@jini-ai/oauth": "^0.2.2"
+    "@jini-ai/oauth": "^0.2.2",
+    "@jini-ai/protocol": "^0.4.4"
   },
   "dependencies": {
     "@jini-ai/core": "^0.4.4"