@jini-ai/agent-runtime 0.4.4 → 0.4.6

package/dist/executables.js

@@ -1,3 +1,4 @@
+import { defaultRuntimeState } from './runtime-state.js';
 /**
  * @module executables
  *
@@ -23,7 +24,7 @@ import { accessSync, constants, existsSync, statSync } from 'node:fs';
 import { delimiter } from 'node:path';
 import path from 'node:path';
 import { homedir } from 'node:os';
-import { wellKnownUserToolchainBins } from '@jini-ai/platform';
+import { wellKnownUserToolchainBins } from '@jini-ai/platform/toolchain';
 import { expandHomePath } from './paths.js';
 const AGENT_BIN_ENV_KEYS = new Map([
     ['amr', 'VELA_BIN'],
@@ -53,59 +54,58 @@ const AGENT_BIN_ENV_KEYS = new Map([
     ['trae-cli', 'TRAE_CLI_BIN'],
     ['vibe', 'VIBE_BIN'],
 ]);
-/** Env var names consulted by detection-home/resource-root resolution. Overridable via `configureExecutableResolutionEnv`. */
-const executableResolutionEnv = {
-    agentHomeEnvVar: 'AGENT_RUNTIME_HOME',
-    resourceRootEnvVar: 'AGENT_RUNTIME_RESOURCE_ROOT',
-};
 /**
  * Override the env var names `resolveDetectionHome` / the packaged-binary
  * lookup read. The host application (e.g. the OD adapter) calls this once
  * at startup if it wants its own namespaced env vars instead of the
  * generic defaults.
  */
-export function configureExecutableResolutionEnv({ overrides }) {
+export function configureExecutableResolutionEnv({ overrides }, { state = defaultRuntimeState } = {}) {
+    const executableResolutionEnv = state.executable.envNames;
     if (overrides.agentHomeEnvVar)
         executableResolutionEnv.agentHomeEnvVar = overrides.agentHomeEnvVar;
     if (overrides.resourceRootEnvVar)
         executableResolutionEnv.resourceRootEnvVar = overrides.resourceRootEnvVar;
 }
 const TOOLCHAIN_DIR_CACHE_TTL_MS = 5000;
-let cachedToolchainHome = null;
-let cachedToolchainDirs = null;
-let cachedToolchainDirsAt = 0;
+// Toolchain cache and env names live with the injected host state.
 // Resolve the home directory detection should search, honoring the
 // configured agent-home override env var. `hasOverride` lets callers scope
 // strictly to the override home (skipping real-machine system locations) so
 // sandboxed detection runs and tests stay deterministic instead of
 // reaching the host.
-function resolveDetectionHome() {
-    const homeOverride = process.env[executableResolutionEnv.agentHomeEnvVar];
-    return { home: homeOverride || homedir(), hasOverride: Boolean(homeOverride) };
+function resolveDetectionHome(options = {}) {
+    const env = options.env ?? process.env;
+    const homeOverride = env[(options.state ?? defaultRuntimeState).executable.envNames.agentHomeEnvVar];
+    return { home: homeOverride || env.HOME || env.USERPROFILE || homedir(), hasOverride: Boolean(homeOverride) };
 }
-function userToolchainDirs() {
-    const { home, hasOverride } = resolveDetectionHome();
+function userToolchainDirs(options = {}) {
+    const env = options.env ?? process.env;
+    const cache = (options.state ?? defaultRuntimeState).executable;
+    const { home, hasOverride } = resolveDetectionHome(options);
+    // Every environment field the existing toolchain adapter consults participates in the cache key.
+    const key = JSON.stringify([home, hasOverride, ...['VP_HOME', 'NPM_CONFIG_PREFIX', 'npm_config_prefix', 'APPDATA', 'LOCALAPPDATA', 'MISE_DATA_DIR', 'FNM_DIR'].map(name => env[name])]);
     const homeOverride = hasOverride ? home : undefined;
     const now = Date.now();
-    if (cachedToolchainHome === home &&
-        cachedToolchainDirs &&
-        now - cachedToolchainDirsAt < TOOLCHAIN_DIR_CACHE_TTL_MS) {
-        return cachedToolchainDirs;
+    if (cache.toolchainKey === key &&
+        cache.toolchainDirs &&
+        now - cache.toolchainDirsAt < TOOLCHAIN_DIR_CACHE_TTL_MS) {
+        return cache.toolchainDirs;
     }
-    cachedToolchainHome = home;
-    cachedToolchainDirsAt = now;
+    cache.toolchainKey = key;
+    cache.toolchainDirsAt = now;
     // When the agent-home override is set, scope the search strictly to the
     // override home: skip Homebrew / /usr/local *and* pass an empty env so
     // that a developer or CI runner with NPM_CONFIG_PREFIX /
     // npm_config_prefix exported can't leak the real machine's <prefix>/bin
     // into a sandboxed detection run. Without this, tests that build a tmp
     // home would be machine-environment-dependent.
-    cachedToolchainDirs = wellKnownUserToolchainBins({
+    cache.toolchainDirs = wellKnownUserToolchainBins({
         home,
         includeSystemBins: process.platform !== 'win32' && !homeOverride,
-        env: homeOverride ? {} : process.env,
+        env: homeOverride ? {} : env,
     });
-    return cachedToolchainDirs;
+    return cache.toolchainDirs;
 }
 // The user-level toolchain bin directories (Homebrew, ~/.local/bin, ~/.bun/bin,
 // version-manager node dirs, npm prefixes, …) that binary *resolution* searches
@@ -113,18 +113,19 @@ function userToolchainDirs() {
 // a binary can resolve here yet fail to *execute* if its shebang interpreter
 // (e.g. `#!/usr/bin/env bun`) lives in one of these dirs and the spawn PATH
 // doesn't include it. Keeping resolution and spawn PATH symmetric fixes that.
-export function userToolchainBinDirs() {
-    return userToolchainDirs();
+export function userToolchainBinDirs(_required = {}, options = {}) {
+    return userToolchainDirs(options);
 }
-function resolvePathDirs() {
+function resolvePathDirs(options = {}) {
+    const env = options.env ?? process.env;
     const seen = new Set();
     const dirs = [
-        ...(process.env.PATH || '').split(delimiter),
+        ...(env.PATH || '').split(delimiter),
         // GUI launchers (macOS .app bundles, Linux .desktop files) often start
         // with a minimal PATH. Include common user-level CLI install locations
         // so agent detection matches the user's shell-installed tools,
         // especially Node version managers.
-        ...userToolchainDirs(),
+        ...userToolchainDirs(options),
     ];
     return dirs.filter((dir) => {
         if (!dir || seen.has(dir))
@@ -137,8 +138,8 @@ function resolvePathDirs() {
 // detection can attach it to a `not-on-path` diagnostic verbatim — the UI
 // shows the user where we actually looked before asking them to set an
 // explicit binary path, instead of recomputing PATH client-side.
-export function agentSearchDirs() {
-    return resolvePathDirs();
+export function agentSearchDirs(_required = {}, options = {}) {
+    return resolvePathDirs(options);
 }
 // The `*_BIN` environment variable that overrides PATH detection for a given
 // agent id (e.g. `cursor-agent` → `CURSOR_AGENT_BIN`), or null when the agent
@@ -148,11 +149,12 @@ export function agentBinEnvKey({ agentId }) {
         return null;
     return AGENT_BIN_ENV_KEYS.get(agentId) ?? null;
 }
-export function resolveOnPath({ bin }) {
+export function resolveOnPath({ bin }, options = {}) {
+    const env = options.env ?? process.env;
     const exts = process.platform === 'win32'
-        ? (process.env.PATHEXT || '.EXE;.CMD;.BAT').split(';')
+        ? (env.PATHEXT || '.EXE;.CMD;.BAT').split(';')
         : [''];
-    const dirs = resolvePathDirs();
+    const dirs = resolvePathDirs(options);
     for (const dir of dirs) {
         for (const ext of exts) {
             const full = path.join(dir, bin + ext);
@@ -162,17 +164,18 @@ export function resolveOnPath({ bin }) {
     }
     return null;
 }
-function looksExecutableOnWindows(filePath) {
+function looksExecutableOnWindows(filePath, options = {}) {
+    const env = options.env ?? process.env;
     const ext = path.extname(filePath).trim().toUpperCase();
     if (!ext)
         return false;
-    const executableExts = (process.env.PATHEXT || '.EXE;.CMD;.BAT')
+    const executableExts = (env.PATHEXT || '.EXE;.CMD;.BAT')
         .split(';')
         .map((value) => value.trim().toUpperCase())
         .filter(Boolean);
     return executableExts.includes(ext);
 }
-function executableFilePath(raw) {
+function executableFilePath(raw, options = {}) {
     if (typeof raw !== 'string' || raw.trim().length === 0)
         return null;
     const expanded = expandHomePath({ value: raw.trim() });
@@ -182,7 +185,7 @@ function executableFilePath(raw) {
         if (!statSync(expanded).isFile())
             return null;
         if (process.platform === 'win32') {
-            if (!looksExecutableOnWindows(expanded))
+            if (!looksExecutableOnWindows(expanded, options))
                 return null;
         }
         else {
@@ -198,30 +201,32 @@ function executableFilePath(raw) {
 // `def.bin` first, then walks `def.fallbackBins` in order. Used for agents
 // whose forks ship under a different binary name but speak the exact same
 // CLI. Returns null when no candidate is on PATH.
-function configuredExecutableOverride(def, configuredEnv = {}) {
+function configuredExecutableOverride(def, configuredEnv = {}, options = {}) {
     const envKey = AGENT_BIN_ENV_KEYS.get(def?.id);
     if (!envKey)
         return null;
-    return executableFilePath(configuredEnv?.[envKey]);
+    return executableFilePath(configuredEnv?.[envKey], options);
 }
-export function resolveAmrOpenCodeExecutable({}, { env = process.env } = {}) {
-    const configured = executableFilePath(env.VELA_OPENCODE_BIN);
+export function resolveAmrOpenCodeExecutable({}, { env = process.env, state = defaultRuntimeState } = {}) {
+    const options = { env, state };
+    const executableResolutionEnv = state.executable.envNames;
+    const configured = executableFilePath(env.VELA_OPENCODE_BIN, options);
     if (configured)
         return configured;
     // In packaged builds prefer the bundled companion under
     // `<resourceRoot>/bin/libexec/opencode/opencode` so a stale global
     // `opencode` on the user's PATH can't override the known-good build that
     // shipped with this app. PATH is only consulted as a last resort.
-    const resourceRoot = (env[executableResolutionEnv.resourceRootEnvVar] ?? process.env[executableResolutionEnv.resourceRootEnvVar])?.trim();
+    const resourceRoot = (env[executableResolutionEnv.resourceRootEnvVar])?.trim();
     if (resourceRoot) {
-        const bundledDir = packagedVelaOpenCodeCompanionTree(resourceRoot);
+        const bundledDir = packagedVelaOpenCodeCompanionTree(resourceRoot, options);
         if (bundledDir) {
-            const bundled = executableFilePath(path.join(bundledDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode'));
+            const bundled = executableFilePath(path.join(bundledDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode'), options);
             if (bundled)
                 return bundled;
         }
     }
-    return resolveOnPath({ bin: 'opencode-cli' }) ?? resolveOnPath({ bin: 'opencode' });
+    return resolveOnPath({ bin: 'opencode-cli' }, options) ?? resolveOnPath({ bin: 'opencode' }, options);
 }
 // The AMR (vela) OpenCode companion ships as a
 // `<resourceRoot>/bin/libexec/opencode/opencode` *executable file*, not just
@@ -229,7 +234,7 @@ export function resolveAmrOpenCodeExecutable({}, { env = process.env } = {}) {
 // a false-positive availability path: `detectAgents()` would surface AMR as
 // available even though the first real run can't launch. Verify the inner
 // executable too.
-function packagedVelaOpenCodeCompanionTree(resourceRoot) {
+function packagedVelaOpenCodeCompanionTree(resourceRoot, options = {}) {
     const candidate = path.join(resourceRoot, 'bin', 'libexec', 'opencode');
     const exe = path.join(candidate, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
     try {
@@ -238,7 +243,7 @@ function packagedVelaOpenCodeCompanionTree(resourceRoot) {
         if (!statSync(exe).isFile())
             return null;
         if (process.platform === 'win32') {
-            if (!looksExecutableOnWindows(exe))
+            if (!looksExecutableOnWindows(exe, options))
                 return null;
         }
         else {
@@ -250,14 +255,16 @@ function packagedVelaOpenCodeCompanionTree(resourceRoot) {
         return null;
     }
 }
-function packagedBuiltInExecutable(def, configuredEnv = {}) {
+function packagedBuiltInExecutable(def, configuredEnv = {}, options = {}) {
     if (def.id !== 'amr')
         return null;
-    const resourceRoot = process.env[executableResolutionEnv.resourceRootEnvVar]?.trim();
+    const env = options.env ?? process.env;
+    const executableResolutionEnv = (options.state ?? defaultRuntimeState).executable.envNames;
+    const resourceRoot = env[executableResolutionEnv.resourceRootEnvVar]?.trim();
     if (!resourceRoot)
         return null;
-    if (!resolveAmrOpenCodeExecutable({}, { env: { ...process.env, ...configuredEnv } }) &&
-        !packagedVelaOpenCodeCompanionTree(resourceRoot)) {
+    if (!resolveAmrOpenCodeExecutable({}, { ...options, env: { ...env, ...configuredEnv } }) &&
+        !packagedVelaOpenCodeCompanionTree(resourceRoot, options)) {
         return null;
     }
     const candidate = path.join(resourceRoot, 'bin', process.platform === 'win32' ? 'vela.exe' : 'vela');
@@ -265,7 +272,7 @@ function packagedBuiltInExecutable(def, configuredEnv = {}) {
         if (!statSync(candidate).isFile())
             return null;
         if (process.platform === 'win32') {
-            if (!looksExecutableOnWindows(candidate))
+            if (!looksExecutableOnWindows(candidate, options))
                 return null;
         }
         else {
@@ -286,11 +293,11 @@ function packagedBuiltInExecutable(def, configuredEnv = {}) {
 // bundle. Probe the well-known bundle locations so app-only installs are
 // detected. This is a last-resort fallback that ranks below PATH, so an
 // explicit `npm i -g` / Homebrew / version-manager install always wins.
-function codexAppBundleExecutable(def) {
+function codexAppBundleExecutable(def, options = {}) {
     if (def?.id !== 'codex')
         return null;
-    for (const candidate of codexAppBundleCandidates()) {
-        const resolved = executableFilePath(candidate);
+    for (const candidate of codexAppBundleCandidates({}, options)) {
+        const resolved = executableFilePath(candidate, options);
         if (resolved)
             return resolved;
     }
@@ -301,12 +308,12 @@ function codexAppBundleExecutable(def) {
 // depend on the host actually having `/Applications/Codex.app`), so tests
 // assert the built candidate list directly to catch a path typo or
 // ordering regression in the common real-world install case.
-export function codexAppBundleCandidates() {
+export function codexAppBundleCandidates(_required = {}, options = {}) {
     // The Codex app bundle is a macOS-only concept; other platforms have no
     // analogous standalone install of the `codex` CLI to probe for here.
     if (process.platform !== 'darwin')
         return [];
-    const { home, hasOverride } = resolveDetectionHome();
+    const { home, hasOverride } = resolveDetectionHome(options);
     const bundleSuffix = ['Codex.app', 'Contents', 'Resources', 'codex'];
     // User-scoped install (~/Applications). Honors the override home so
     // sandboxed detection runs and tests stay deterministic.
@@ -319,10 +326,10 @@ export function codexAppBundleCandidates() {
     }
     return candidates;
 }
-export function resolveAgentExecutable({ def }, { configuredEnv = {} } = {}) {
-    return inspectAgentExecutableResolution({ def: def }, { configuredEnv: configuredEnv }).selectedPath;
+export function resolveAgentExecutable({ def }, options = {}) {
+    return inspectAgentExecutableResolution({ def: def }, options).selectedPath;
 }
-export function inspectAgentExecutableResolution({ def }, { configuredEnv = {} } = {}) {
+export function inspectAgentExecutableResolution({ def }, options = {}) {
     if (!def?.bin) {
         return {
             configuredOverridePath: null,
@@ -330,21 +337,22 @@ export function inspectAgentExecutableResolution({ def }, { configuredEnv = {} }
             selectedPath: null,
         };
     }
-    const configuredOverridePath = configuredExecutableOverride(def, configuredEnv);
+    const configuredEnv = options.configuredEnv ?? {};
+    const configuredOverridePath = configuredExecutableOverride(def, configuredEnv, options);
     const candidates = [
         def.bin,
         ...(Array.isArray(def.fallbackBins) ? def.fallbackBins : []),
     ];
     let pathResolvedPath = null;
     for (const bin of candidates) {
-        const resolved = resolveOnPath({ bin: bin });
+        const resolved = resolveOnPath({ bin: bin }, options);
         if (resolved) {
             pathResolvedPath = resolved;
             break;
         }
     }
-    const builtInPath = packagedBuiltInExecutable(def, configuredEnv);
-    const appBundlePath = codexAppBundleExecutable(def);
+    const builtInPath = packagedBuiltInExecutable(def, configuredEnv, options);
+    const appBundlePath = codexAppBundleExecutable(def, options);
     return {
         configuredOverridePath,
         pathResolvedPath,

package/dist/index.d.ts

@@ -47,6 +47,7 @@ export * from './telemetry-sink.js';
 export * from './providers/index.js';
 /** ACP + pi-rpc protocol adapters over the shared JSON-line-stream core. See aliases above. */
 export { createJsonLineStream, type AcpMcpServerInput, type AcpPermissionDecision, type AcpPermissionHandler, type AcpPermissionOption, type AcpPermissionRequest, type AcpSessionController, type ModelOption, type AttachAcpSessionOptions, type AccountFailure, type AccountFailureClassifier, buildAcpSessionNewParams, normalizeModels, detectAcpModels, attachAcpSession, noopAccountFailureClassifier, mapPiRpcEvent, attachPiRpcSession, parsePiModels as parsePiRpcModels, type PiRpcSession, type PiRpcSessionOptions, } from './agent-protocol/index.js';
-export * from './model-discovery.js';
-export { defaultModelDiscoveryDeps, parseClaudeInitializeMetadata, parsePiRpcMetadata } from './model-discovery-adapters.js';
+export * from './model-discovery-native.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

@@ -70,6 +70,7 @@ export * from './telemetry-sink.js';
 export * from './providers/index.js';
 /** ACP + pi-rpc protocol adapters over the shared JSON-line-stream core. See aliases above. */
 export { createJsonLineStream, buildAcpSessionNewParams, normalizeModels, detectAcpModels, attachAcpSession, noopAccountFailureClassifier, mapPiRpcEvent, attachPiRpcSession, parsePiModels as parsePiRpcModels, } from './agent-protocol/index.js';
-export * from './model-discovery.js';
-export { defaultModelDiscoveryDeps, parseClaudeInitializeMetadata, parsePiRpcMetadata } from './model-discovery-adapters.js';
+export * from './model-discovery-native.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,9 +10,10 @@
  * 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';
+import { createCommandInvocation } from '@jini-ai/platform/command';
 const execFileP = promisify(execFile);
 // Agent probes (model-list / version / help / auth-status) are short
 // read-only metadata calls that never need the caller's project files.
@@ -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,5 +1,5 @@
-import { type AgentDiscoveryConfiguration } from './model-discovery.js';
-import type { ModelDiscoveryContext, ModelDiscoveryDeps, ModelProbeResult } from './model-discovery-types.js';
+import { type AgentRuntimeState } from './runtime-state.js';
+import type { AgentDiscoveryConfiguration, ModelDiscoveryContext, ModelDiscoveryDeps, ModelProbeResult } from './model-discovery-types.js';
 export declare function modelProbeTimeoutMs(agentId: string): number;
 /** Shared CLI-subcommand adapter. Output parsers are pure def-owned functions, not vendor tools. */
 export declare function probeCliSubcommand(context: ModelDiscoveryContext, config: AgentDiscoveryConfiguration, deps: ModelDiscoveryDeps, signal: AbortSignal): Promise<ModelProbeResult>;
@@ -19,4 +19,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