@jini-ai/agent-runtime 0.4.3 → 0.4.5

package/dist/index.d.ts

@@ -48,5 +48,6 @@ 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 { defaultModelDiscoveryDeps, parseClaudeInitializeMetadata, parsePiRpcMetadata } from './model-discovery-adapters.js';
+export { getRuntimeModelDiscoveryDeps, defaultModelDiscoveryDeps, parseClaudeInitializeMetadata, parsePiRpcMetadata } from './model-discovery-adapters.js';
+export * from './runtime-state.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -71,5 +71,6 @@ 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 { defaultModelDiscoveryDeps, parseClaudeInitializeMetadata, parsePiRpcMetadata } from './model-discovery-adapters.js';
+export { getRuntimeModelDiscoveryDeps, defaultModelDiscoveryDeps, parseClaudeInitializeMetadata, parsePiRpcMetadata } from './model-discovery-adapters.js';
+export * from './runtime-state.js';
 //# sourceMappingURL=index.js.map

package/dist/invocation.d.ts

@@ -1,11 +1,33 @@
+/**
+ * @module invocation
+ *
+ * Short, read-only metadata probes (model-list / version / help /
+ * auth-status) for an agent CLI. Ported from OD's
+ * `apps/daemon/src/runtimes/invocation.ts` with one dependency swap:
+ * `createCommandInvocation` now comes from `@jini-ai/platform` instead of the
+ * OD workspace package it originally shipped from — the two are the same
+ * function (platform was already verbatim-lifted into `@jini-ai/platform`,
+ * see its `archived provenance ledger`).
+ */
+import { execFile } from 'node:child_process';
 import type { RuntimeExecOptions } from './types.js';
+declare const execFileP: typeof execFile.__promisify__;
+type ProbeExecPort = (input: {
+    command: string;
+    args: string[];
+    options: RuntimeExecOptions & {
+        windowsVerbatimArguments?: boolean | undefined;
+    };
+}, optional: Record<string, never>) => ReturnType<typeof execFileP>;
 export declare function execAgentFile({ command, args }: {
     command: string;
     args: string[];
-}, { options }?: {
+}, { options, execute }?: {
     options?: RuntimeExecOptions;
-}): import("child_process").PromiseWithChild<{
+    execute?: ProbeExecPort;
+}): Promise<{
     stdout: string | NonSharedBuffer;
     stderr: string | NonSharedBuffer;
 }>;
+export {};
 //# sourceMappingURL=invocation.d.ts.map

package/dist/invocation.js

@@ -10,6 +10,7 @@
  * see its `archived provenance ledger`).
  */
 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';
@@ -27,7 +28,7 @@ const execFileP = promisify(execFile);
 // running dev server. A probe writing a stray lockfile under the OS temp
 // dir is harmless. Actual agent runs spawn elsewhere with an explicit
 // project cwd and are unaffected.
-export function execAgentFile({ command, args }, { options = {} } = {}) {
+export function execAgentFile({ command, args }, { options = {}, execute = (input) => execFileP(input.command, input.args, input.options) } = {}) {
     const invocation = createCommandInvocation(options.env
         ? {
             command,
@@ -38,10 +39,21 @@ export function execAgentFile({ command, args }, { options = {} } = {}) {
             command,
             args,
         });
-    return execFileP(invocation.command, invocation.args, {
-        ...options,
-        cwd: options.cwd ?? os.tmpdir(),
-        windowsVerbatimArguments: invocation.windowsVerbatimArguments,
-    });
+    return scheduleProbeProcess({ work: async () => {
+            const pending = execute({ command: invocation.command, args: invocation.args, options: {
+                    killSignal: 'SIGKILL', ...options, cwd: options.cwd ?? os.tmpdir(),
+                    windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+                } }, {});
+            try {
+                return await pending;
+            }
+            finally {
+                // AbortError can precede close. Hold the shared slot until the child actually exits.
+                const child = pending.child;
+                if (child?.pid && child.exitCode === null && child.signalCode === null) {
+                    await new Promise(resolve => { child.once('close', () => resolve()); });
+                }
+            }
+        } }, { priority: args.includes('--version') ? 'version' : 'metadata', signal: options.signal });
 }
 //# sourceMappingURL=invocation.js.map

package/dist/launch.d.ts

@@ -1,3 +1,4 @@
+import type { ExecutableResolutionOptions } from './executables.js';
 import { inspectAgentExecutableResolution } from './executables.js';
 import type { RuntimeAgentDef } from './types.js';
 export type AgentLaunchKind = 'selected' | 'codex-native';
@@ -9,7 +10,7 @@ export type AgentLaunchResolution = ReturnType<typeof inspectAgentExecutableReso
 };
 export declare function resolveAgentLaunch({ def }: {
     def: RuntimeAgentDef;
-}, { configuredEnv }?: {
+}, options?: ExecutableResolutionOptions & {
     configuredEnv?: Record<string, string>;
 }): AgentLaunchResolution;
 export declare function applyAgentLaunchEnv({ env, launch }: {

package/dist/launch.js

@@ -5,8 +5,8 @@
 import { accessSync, closeSync, constants, openSync, readdirSync, readSync, realpathSync, statSync } from 'node:fs';
 import path, { delimiter } from 'node:path';
 import { inspectAgentExecutableResolution, userToolchainBinDirs } from './executables.js';
-export function resolveAgentLaunch({ def }, { configuredEnv = {} } = {}) {
-    const resolution = inspectAgentExecutableResolution({ def: def }, { configuredEnv: configuredEnv });
+export function resolveAgentLaunch({ def }, options = {}) {
+    const resolution = inspectAgentExecutableResolution({ def: def }, options);
     if (!resolution.selectedPath) {
         return { ...resolution, launchPath: null, launchKind: 'selected', childPathPrepend: [], diagnostic: null };
     }

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

@@ -1,3 +1,4 @@
+import { type AgentRuntimeState } from './runtime-state.js';
 import { type AgentDiscoveryConfiguration } from './model-discovery.js';
 import type { ModelDiscoveryContext, ModelDiscoveryDeps, ModelProbeResult } from './model-discovery-types.js';
 export declare function modelProbeTimeoutMs(agentId: string): number;
@@ -19,4 +20,8 @@ export declare function probeAgentCatalog(agentId: string, context: ModelDiscove
 export declare const defaultModelDiscoveryDeps: ModelDiscoveryDeps;
 /** Pi's native RPC supplies catalog AND current provider/id without making an inference call. */
 export declare function parsePiRpcMetadata(stdout: string): ModelProbeResult;
+/** Stable dependency identity preserves the existing per-host single-probe budget as well as its cache. */
+export declare function getRuntimeModelDiscoveryDeps({ state }: {
+    state: AgentRuntimeState;
+}, _optional?: Record<string, never>): ModelDiscoveryDeps;
 //# sourceMappingURL=model-discovery-adapters.d.ts.map

package/dist/model-discovery-adapters.js

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

package/dist/model-discovery.js

@@ -30,11 +30,11 @@ export function modelLaunchFingerprint(context, configMaterial = '') {
 class ProbeTimeout extends Error {
 }
 const probePools = new WeakMap();
-/** Four simultaneous cold probes per host; queued callers keep cancellation responsive. */
+/** One cold catalog probe per host; queued callers keep cancellation responsive. */
 async function boundedProbe(deps, work, signal) {
     const pool = probePools.get(deps) || { active: 0, queue: [] };
     probePools.set(deps, pool);
-    if (pool.active >= 4) {
+    if (pool.active >= 1) {
         await new Promise((resolve, reject) => {
             const ready = () => { signal?.removeEventListener('abort', abort); resolve(); };
             const abort = () => { const index = pool.queue.indexOf(ready); if (index >= 0)

package/dist/models.d.ts

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

package/dist/models.js

@@ -1,3 +1,4 @@
+import { defaultRuntimeState } from './runtime-state.js';
 export const DEFAULT_MODEL_OPTION = {
     id: 'default',
     label: 'Default (CLI config)',
@@ -7,33 +8,32 @@ export const DEFAULT_MODEL_OPTION = {
 // recent live list (refreshed every detectAgents() call) and additionally
 // trust any value present in the static fallback. A model that's neither
 // gets rejected so a stale or hostile value can't smuggle arbitrary flags.
-const liveModelCache = new Map();
-const liveModelOrder = new Map();
+// Host state carries these maps; legacy callers use defaultRuntimeState.
 function liveModelCacheKey(agentId, scope) {
     const trimmedScope = typeof scope === 'string' ? scope.trim() : '';
     return trimmedScope ? `${agentId}\0${trimmedScope}` : agentId;
 }
-export function rememberLiveModels({ agentId, models }, { scope } = {}) {
+export function rememberLiveModels({ agentId, models }, { scope, state = defaultRuntimeState } = {}) {
     if (!Array.isArray(models))
         return;
     const ids = models
         .map((m) => m && m.id)
         .filter((id) => typeof id === 'string');
     const key = liveModelCacheKey(agentId, scope);
-    liveModelCache.set(key, new Set(ids));
-    liveModelOrder.set(key, ids);
+    state.liveModelCache.set(key, new Set(ids));
+    state.liveModelOrder.set(key, ids);
 }
-export function getRememberedLiveModels({ agentId }, { scope } = {}) {
-    const ids = liveModelOrder.get(liveModelCacheKey(agentId, scope)) ?? [];
+export function getRememberedLiveModels({ agentId }, { scope, state = defaultRuntimeState } = {}) {
+    const ids = state.liveModelOrder.get(liveModelCacheKey(agentId, scope)) ?? [];
     return ids.map((id) => ({ id, label: id }));
 }
 export function preferFreshLiveModels({ freshModels, rememberedModels }) {
     return freshModels.length > 0 ? freshModels : rememberedModels;
 }
-export function isKnownModel({ def, modelId }, { scope } = {}) {
+export function isKnownModel({ def, modelId }, { scope, state = defaultRuntimeState } = {}) {
     if (!modelId)
         return false;
-    const live = liveModelCache.get(liveModelCacheKey(def.id, scope));
+    const live = state.liveModelCache.get(liveModelCacheKey(def.id, scope));
     if (live && live.has(modelId))
         return true;
     if (Array.isArray(def.fallbackModels)) {
@@ -49,7 +49,7 @@ export function isKnownModel({ def, modelId }, { scope } = {}) {
 // surfaced to the UI, then fall back to the def's first concrete fallback
 // id so the spawn layer always has a real model to forward. Defs that DO
 // list 'default' (the common case) are left untouched.
-export function resolveModelForAgent({ def, resolved }, { env = process.env, liveModelScope } = {}) {
+export function resolveModelForAgent({ def, resolved }, { env = process.env, liveModelScope, state = defaultRuntimeState } = {}) {
     if (resolved && resolved !== 'default')
         return resolved;
     // Host-process env override. Lets an operator pin a different fallback
@@ -66,7 +66,7 @@ export function resolveModelForAgent({ def, resolved }, { env = process.env, liv
     const fallbacks = def.fallbackModels;
     if (fallbacks.some((m) => m.id === 'default'))
         return resolved;
-    const liveModels = liveModelOrder.get(liveModelCacheKey(def.id, liveModelScope)) ?? [];
+    const liveModels = state.liveModelOrder.get(liveModelCacheKey(def.id, liveModelScope)) ?? [];
     const firstLive = liveModels[0];
     if (firstLive)
         return firstLive;

package/dist/probe-scheduler.d.ts

@@ -0,0 +1,19 @@
+type Priority = 'version' | 'metadata';
+/** All metadata process adapters share one process-wide slot. Version checks precede queued
+ * metadata, so expensive discovery cannot delay cheap availability checks. Actual chat runs
+ * never use this queue. A slot is held until the child adapter settles, including cancellation.
+ * @complexity O(q) queued selection, bounded by the runtime registry's probe count. */
+export declare function createProbeScheduler(_input: Record<string, never>, _options?: Record<string, never>): <T>({ work }: {
+    work: () => Promise<T>;
+}, { priority, signal }?: {
+    priority?: Priority;
+    signal?: AbortSignal | undefined;
+}) => Promise<T>;
+export declare const scheduleProbeProcess: <T>({ work }: {
+    work: () => Promise<T>;
+}, { priority, signal }?: {
+    priority?: Priority;
+    signal?: AbortSignal | undefined;
+}) => Promise<T>;
+export {};
+//# sourceMappingURL=probe-scheduler.d.ts.map

package/dist/probe-scheduler.js

@@ -0,0 +1,30 @@
+/** All metadata process adapters share one process-wide slot. Version checks precede queued
+ * metadata, so expensive discovery cannot delay cheap availability checks. Actual chat runs
+ * never use this queue. A slot is held until the child adapter settles, including cancellation.
+ * @complexity O(q) queued selection, bounded by the runtime registry's probe count. */
+export function createProbeScheduler(_input, _options = {}) {
+    const queue = [];
+    let running = false;
+    function drain() {
+        if (running || !queue.length)
+            return;
+        const version = queue.findIndex(entry => entry.priority === 'version');
+        const entry = queue.splice(version < 0 ? 0 : version, 1)[0];
+        running = true;
+        entry.start();
+    }
+    return function schedule({ work }, { priority = 'metadata', signal } = {}) {
+        return new Promise((resolve, reject) => {
+            queue.push({ priority, start: () => {
+                    Promise.resolve().then(() => {
+                        if (signal?.aborted)
+                            throw new Error('Probe cancelled');
+                        return work();
+                    }).then(resolve, reject).finally(() => { running = false; drain(); });
+                } });
+            drain();
+        });
+    };
+}
+export const scheduleProbeProcess = createProbeScheduler({});
+//# sourceMappingURL=probe-scheduler.js.map

package/dist/runtime-state.d.ts

@@ -0,0 +1,41 @@
+/** Mutable runtime data belongs to one host. Compatibility functions use defaultRuntimeState. */
+import type { RuntimeAgentDef, RuntimeCapabilityMap, RuntimeModelOption, DetectedAgent } from './types.js';
+import type { ModelCacheEntry, ModelDiscoveryDeps } from './model-discovery-types.js';
+export interface AgentRuntimeState {
+    /** One in-flight or settled complete detection per launch scope until explicit Rescan. */
+    readonly detections: Map<string, Promise<DetectedAgent>>;
+    readonly capabilities: Map<string, RuntimeCapabilityMap>;
+    /** One in-flight or settled `--help` probe per def id + launch path, so a run never re-spawns it. */
+    readonly capabilityProbes: Map<string, Promise<void>>;
+    readonly liveModelCache: Map<string, Set<string>>;
+    readonly liveModelOrder: Map<string, string[]>;
+    readonly claudeModels: Map<string, {
+        expiresAt: number;
+        value: Promise<readonly RuntimeModelOption[] | null>;
+    }>;
+    discoveryDeps?: ModelDiscoveryDeps;
+    readonly modelCatalog: Map<string, ModelCacheEntry>;
+    readonly executable: {
+        /** Env var names consulted by detection-home/resource-root resolution. Overridable via `configureExecutableResolutionEnv`. */
+        envNames: {
+            agentHomeEnvVar: string;
+            resourceRootEnvVar: string;
+        };
+        toolchainKey: string | null;
+        toolchainDirs: string[] | null;
+        toolchainDirsAt: number;
+    };
+    /** Clear settled caches after host operations finish; retain its configured env names. */
+    clear(required: Record<string, never>, optional: Record<string, never>): void;
+}
+/** Independent state, including in-flight probes, for each embedding host.
+ * 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.
+ * 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;
+//# sourceMappingURL=runtime-state.d.ts.map

package/dist/runtime-state.js

@@ -0,0 +1,31 @@
+/** Independent state, including in-flight probes, for each embedding host.
+ * Returns empty owned maps; no I/O. @complexity O(1) initialization; retained data grows with probes. */
+export function createAgentRuntimeState(_required, _optional = {}) {
+    const state = {
+        detections: new Map(), capabilities: new Map(), capabilityProbes: new Map(), liveModelCache: new Map(), liveModelOrder: new Map(),
+        claudeModels: new Map(), modelCatalog: new Map(),
+        executable: { envNames: { agentHomeEnvVar: 'AGENT_RUNTIME_HOME', resourceRootEnvVar: 'AGENT_RUNTIME_RESOURCE_ROOT' }, toolchainKey: null, toolchainDirs: null, toolchainDirsAt: 0 },
+        clear() {
+            state.detections.clear();
+            state.capabilities.clear();
+            state.capabilityProbes.clear();
+            state.liveModelCache.clear();
+            state.liveModelOrder.clear();
+            state.claudeModels.clear();
+            state.modelCatalog.clear();
+            state.executable.toolchainKey = null;
+            state.executable.toolchainDirs = null;
+            state.executable.toolchainDirsAt = 0;
+        },
+    };
+    return state;
+}
+export const defaultRuntimeState = createAgentRuntimeState({});
+/** Bind the agent argument builder to the same capability state detection and launch use.
+ * 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) ?? {} },
+        }) };
+}
+//# sourceMappingURL=runtime-state.js.map

package/dist/types.d.ts

@@ -75,6 +75,8 @@ export type RuntimeReasoningInModelId = {
     levels: readonly RuntimeReasoningOption[];
 };
 export type RuntimeBuildOptions = {
+    /** Host-scoped capability flags; absent retains the published compatibility cache. */
+    capabilities?: RuntimeCapabilityMap;
     model?: string | null;
     reasoning?: string | null;
     permissionMode?: 'bypass' | 'restricted';
@@ -291,6 +293,8 @@ export type RuntimeAgentDef = Partial<AgentModelDiscoveryPort> & {
         runtimeContext?: RuntimeContext;
     }) => string[];
     streamFormat: string;
+    /** Reported money spans a session or one run; absent preserves per-run adapter behavior. */
+    usageCostBasis?: 'session' | 'run';
     fallbackBins?: string[];
     versionProbeTimeoutMs?: number;
     helpArgs?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/agent-runtime",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Coding-agent runtime adapters: runtime registry, detection, launch, stream parsers, and the ACP/pi-rpc subprocess transport.",
   "license": "Apache-2.0",
   "repository": {
@@ -77,20 +77,25 @@
   "devDependencies": {
     "@vitest/coverage-v8": "^2.1.9",
     "@jini-ai/core": "^0.4.0",
-    "@jini-ai/oauth": "^0.2.1",
-    "@jini-ai/platform": "^0.5.2",
-    "@jini-ai/protocol": "^0.4.2"
+    "@jini-ai/oauth": "^0.2.2",
+    "@jini-ai/integrations": "^0.4.2",
+    "@jini-ai/platform": "^0.5.3",
+    "@jini-ai/protocol": "^0.4.4"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.2"
+    "@jini-ai/core": "^0.4.3"
   },
   "peerDependencies": {
+    "@jini-ai/integrations": "^0.4.2",
     "@github/copilot-sdk": "*",
-    "@jini-ai/oauth": "^0.2.0",
-    "@jini-ai/platform": "^0.5.1",
-    "@jini-ai/protocol": "^0.4.1"
+    "@jini-ai/oauth": "^0.2.2",
+    "@jini-ai/platform": "^0.5.3",
+    "@jini-ai/protocol": "^0.4.4"
   },
   "peerDependenciesMeta": {
+    "@jini-ai/integrations": {
+      "optional": true
+    },
     "@github/copilot-sdk": {
       "optional": true
     },

package/dist/defs/gemini.d.ts

@@ -1,24 +0,0 @@
-export declare const geminiAgentDef: {
-    id: string;
-    name: string;
-    bin: string;
-    versionArgs: string[];
-    versionProbeTimeoutMs: number;
-    helpArgs: string[];
-    capabilityFlags: {
-        "--skip-trust": string;
-    };
-    fallbackModels: import("../types.js").RuntimeModelOption[];
-    buildArgs: ({ prompt: _prompt, imagePaths: _imagePaths }: {
-        prompt: string;
-        imagePaths: string[];
-    }, { extraAllowedDirs, options }?: {
-        extraAllowedDirs?: string[];
-        options?: import("../types.js").RuntimeBuildOptions;
-        runtimeContext?: import("../types.js").RuntimeContext;
-    } | undefined) => string[];
-    promptViaStdin: true;
-    streamFormat: string;
-    eventParser: string;
-};
-//# sourceMappingURL=gemini.d.ts.map