@jini-ai/agent-runtime 0.4.4 → 0.4.6

package/dist/detection.d.ts

@@ -1,6 +1,7 @@
+import { type AgentRuntimeState } from './runtime-state.js';
 import type { ModelDiscoveryContext, ModelDiscoveryDeps, ModelCatalogSnapshot, DefaultModelResolution } from './model-discovery-types.js';
 import { type AmrProfileResolver } from './amr-profile-resolver.js';
-import type { AgentDiagnostic, DetectedAgent, RuntimeAgentDef, RuntimeModelSource, RuntimeModelOption } from './types.js';
+import type { AgentDiagnostic, DetectedAgent, RuntimeAgentDef, RuntimeCapabilityMap, RuntimeModelSource, RuntimeModelOption } from './types.js';
 type FetchedRuntimeModels = {
     models: RuntimeModelOption[];
     source: RuntimeModelSource;
@@ -30,6 +31,14 @@ export declare function ensureAgentCapabilities({ def, launchPath, env }: {
     def: RuntimeAgentDef;
     launchPath: string;
     env: NodeJS.ProcessEnv;
+}, { state, probe }?: {
+    state?: AgentRuntimeState;
+    probe?: (required: {
+        helpArgs: readonly string[];
+        capabilityFlags: Readonly<Record<string, string>>;
+        launchPath: string;
+        env: NodeJS.ProcessEnv;
+    }, optional: Record<string, never>) => Promise<RuntimeCapabilityMap>;
 }): Promise<void>;
 /** Result of {@link probeAgentModels}: the models to surface and where they came from. */
 export type ProbedAgentModels = FetchedRuntimeModels;
@@ -47,7 +56,9 @@ export type ProbedAgentModels = FetchedRuntimeModels;
  */
 export declare function probeAgentModels({ def }: {
     def: RuntimeAgentDef;
-}, { configuredEnv, amrProfileResolver, context, deps, force }?: {
+}, { configuredEnv, amrProfileResolver, context, deps, force, state, env }?: {
+    state?: AgentRuntimeState;
+    env?: NodeJS.ProcessEnv;
     configuredEnv?: Record<string, string>;
     amrProfileResolver?: AmrProfileResolver;
     context?: ModelDiscoveryContext;
@@ -58,13 +69,23 @@ export interface AgentDetectionModelOptions {
     context?: ModelDiscoveryContext;
     deps?: ModelDiscoveryDeps;
     force?: boolean;
+    state?: AgentRuntimeState;
+    env?: NodeJS.ProcessEnv;
+    probeAgent?: (input: {
+        def: RuntimeAgentDef;
+        configuredEnv: Record<string, string>;
+        amrProfileResolver: AmrProfileResolver;
+    }, options: AgentDetectionModelOptions) => Promise<DetectedAgent>;
 }
-export declare function detectAgents({}: {}, { configuredEnvByAgent, amrProfileResolver, modelContextByAgent, modelDiscoveryDeps, force }?: {
+export declare function detectAgents({}: {}, { configuredEnvByAgent, amrProfileResolver, modelContextByAgent, modelDiscoveryDeps, force, state, env, probeAgent }?: {
+    state?: AgentRuntimeState;
+    env?: NodeJS.ProcessEnv;
     configuredEnvByAgent?: Record<string, Record<string, string>>;
     amrProfileResolver?: AmrProfileResolver;
     modelContextByAgent?: Record<string, ModelDiscoveryContext>;
     modelDiscoveryDeps?: ModelDiscoveryDeps;
     force?: boolean;
+    probeAgent?: AgentDetectionModelOptions['probeAgent'];
 }): Promise<(Omit<RuntimeAgentDef, "discoverModels" | "resolveDefaultModel" | "buildArgs" | "listModels" | "fetchModels" | "deriveReasoningOptions" | "fallbackModels" | "fallbackModelsAssertedAt" | "helpArgs" | "capabilityFlags" | "fallbackBins" | "versionProbeTimeoutMs" | "maxPromptArgBytes" | "env" | "inactivityTimeoutMs" | "authProbe" | "needsAgentLogFile" | "stdoutPolicy" | "runtimeLock"> & {
     models: RuntimeModelOption[];
     modelsSource: RuntimeModelSource;
@@ -77,12 +98,15 @@ export declare function detectAgents({}: {}, { configuredEnvByAgent, amrProfileR
     version?: string | null;
     diagnostics?: AgentDiagnostic[];
 })[]>;
-export declare function detectAgentsStream({}: {}, { configuredEnvByAgent, amrProfileResolver, modelContextByAgent, modelDiscoveryDeps, force }?: {
+export declare function detectAgentsStream({}: {}, { configuredEnvByAgent, amrProfileResolver, modelContextByAgent, modelDiscoveryDeps, force, state, env, probeAgent }?: {
+    state?: AgentRuntimeState;
+    env?: NodeJS.ProcessEnv;
     configuredEnvByAgent?: Record<string, Record<string, string>>;
     amrProfileResolver?: AmrProfileResolver;
     modelContextByAgent?: Record<string, ModelDiscoveryContext>;
     modelDiscoveryDeps?: ModelDiscoveryDeps;
     force?: boolean;
+    probeAgent?: AgentDetectionModelOptions['probeAgent'];
 }): AsyncGenerator<DetectedAgent>;
 export {};
 //# sourceMappingURL=detection.d.ts.map

package/dist/detection.js

@@ -1,3 +1,7 @@
+import { createHash } from 'node:crypto';
+import { userToolchainBinDirs } from './executables.js';
+import { defaultRuntimeState } from './runtime-state.js';
+import { getRuntimeModelDiscoveryDeps } from './model-discovery-adapters.js';
 /**
  * @module detection
  *
@@ -12,9 +16,8 @@
  * `archived provenance ledger`.
  */
 import { execAgentFile } from './invocation.js';
-import { offlineSnapshot, modelDiscoveryForDef } from './model-discovery.js';
+import { offlineSnapshot, modelDiscoveryForDef } from './model-discovery-native.js';
 import { rememberLiveModels } from './models.js';
-import { agentCapabilities } from './capabilities.js';
 import { installMetaForAgent } from './metadata.js';
 import { AGENT_DEFS } from './registry.js';
 import { applyAgentLaunchEnv, resolveAgentLaunch } from './launch.js';
@@ -109,8 +112,8 @@ function unavailableAgent(def, diagnostics = []) {
 }
 // Probe the agent's `--help` once and record which advertised flags the
 // installed CLI supports, so buildArgs can consult the cache. Extracted
-// from the main probe so it can run concurrently with model + auth probing
-// instead of blocking them. Returns the capability map (or null when the
+// from the main probe so it can run before model discovery. It shares the existing
+// capability cache with real launches. Returns the capability map (or null when the
 // agent declares no help/capability metadata or the probe failed).
 async function probeCapabilities(def, launchPath, env) {
     if (!def.helpArgs || !def.capabilityFlags)
@@ -133,8 +136,6 @@ async function readCapabilities(helpArgs, capabilityFlags, launchPath, env) {
     }
     return caps;
 }
-/** One in-flight or settled `--help` probe per def id + launch path, so a run never re-spawns it. */
-const capabilityProbes = new Map();
 /**
  * Makes sure `agentCapabilities` holds this def's `--help`-probed flags before its `buildArgs` runs.
  *
@@ -154,7 +155,9 @@ const capabilityProbes = new Map();
  * @param env - The env the run will spawn with.
  * @complexity O(1) after the first call per def + path; the first call costs one `--help` spawn (5 s cap).
  */
-export function ensureAgentCapabilities({ def, launchPath, env }) {
+export function ensureAgentCapabilities({ def, launchPath, env }, { state = defaultRuntimeState, probe = ({ helpArgs, capabilityFlags, launchPath, env }) => readCapabilities(helpArgs, capabilityFlags, launchPath, env) } = {}) {
+    const agentCapabilities = state.capabilities;
+    const capabilityProbes = state.capabilityProbes;
     const { helpArgs, capabilityFlags } = def;
     if (!helpArgs || !capabilityFlags || agentCapabilities.has(def.id))
         return Promise.resolve();
@@ -162,12 +165,12 @@ export function ensureAgentCapabilities({ def, launchPath, env }) {
     const existing = capabilityProbes.get(key);
     if (existing)
         return existing;
-    const probe = readCapabilities(helpArgs, capabilityFlags, launchPath, env).then((caps) => {
+    const pending = probe({ helpArgs, capabilityFlags, launchPath, env }, {}).then((caps) => {
         if (!agentCapabilities.has(def.id))
             agentCapabilities.set(def.id, caps);
     }, () => undefined);
-    capabilityProbes.set(key, probe);
-    return probe;
+    capabilityProbes.set(key, pending);
+    return pending;
 }
 /**
  * The effort-level override a live model catalog earns, if any.
@@ -186,8 +189,8 @@ function derivedReasoningOverride(def, models) {
     return derived && derived.length > 0 ? { reasoningOptions: derived } : {};
 }
 /** The env every probe of one def spawns with — the same env a real run would see. */
-function probeEnvForLaunch(def, configuredEnv, launch) {
-    return applyAgentLaunchEnv({ env: spawnEnvForAgent({ agentId: def.id, baseEnv: { ...process.env, ...(def.env || {}) } }, { configuredEnv: configuredEnv, hooks: {} }), launch: launch });
+function probeEnvForLaunch(def, configuredEnv, launch, options = {}) {
+    return applyAgentLaunchEnv({ env: spawnEnvForAgent({ agentId: def.id, baseEnv: { ...(options.env ?? process.env), ...(def.env || {}) } }, { configuredEnv: configuredEnv, hooks: {} }), launch: launch }, { appendPathDirs: userToolchainBinDirs({}, options) });
 }
 function unavailableModels(def) {
     const catalog = offlineSnapshot('', Date.now(), def.fallbackModels);
@@ -205,15 +208,15 @@ function unavailableModels(def) {
  * `source: 'fallback'` (including when the binary is not found). Never rejects.
  * @complexity At most one model-listing spawn, bounded by the def's own timeout.
  */
-export async function probeAgentModels({ def }, { configuredEnv = {}, amrProfileResolver = noopAmrProfileResolver, context, deps, force = false } = {}) {
+export async function probeAgentModels({ def }, { configuredEnv = {}, amrProfileResolver = noopAmrProfileResolver, context, deps, force = false, state = defaultRuntimeState, env = process.env } = {}) {
     try {
-        const launch = resolveAgentLaunch({ def: def }, { configuredEnv: configuredEnv });
+        const launch = resolveAgentLaunch({ def: def }, { configuredEnv: configuredEnv, state, env });
         if (!launch.launchPath)
             return unavailableModels(def);
-        const probeEnv = probeEnvForLaunch(def, configuredEnv, launch);
-        const fetched = await fetchModels(def, launch.launchPath, probeEnv, { ...(context ? { context } : {}), ...(deps ? { deps } : {}), force });
+        const probeEnv = probeEnvForLaunch(def, configuredEnv, launch, { state, env });
+        const fetched = await fetchModels(def, launch.launchPath, probeEnv, { ...(context ? { context } : {}), deps: deps ?? getRuntimeModelDiscoveryDeps({ state }), force });
         const result = withRememberedAmrModels(def, probeEnv, fetched, amrProfileResolver);
-        rememberDetectedModelList(def, configuredEnv, result.models, amrProfileResolver);
+        rememberDetectedModelList(def, configuredEnv, result.models, amrProfileResolver, { state, env });
         return result;
     }
     catch {
@@ -229,28 +232,34 @@ async function probe(def, configuredEnv = {}, amrProfileResolver, options = {})
     // detection probes the shim but chat/run spawns the native binary, the
     // UI incorrectly reports "not installed" until the user pins the bin
     // override by hand even though the real launch path is healthy.
-    const launch = resolveAgentLaunch({ def: def }, { configuredEnv: configuredEnv });
+    const launch = resolveAgentLaunch({ def: def }, { configuredEnv: configuredEnv, ...(options.state ? { state: options.state } : {}), ...(options.env ? { env: options.env } : {}) });
     if (!launch.selectedPath || !launch.launchPath) {
-        return unavailableAgent(def, [buildExecutableDiagnostic({ def: def }, { configuredEnv: configuredEnv })]);
+        return unavailableAgent(def, [buildExecutableDiagnostic({ def: def }, { configuredEnv: configuredEnv, ...(options.state ? { state: options.state } : {}), ...(options.env ? { env: options.env } : {}) })]);
     }
-    const probeEnv = probeEnvForLaunch(def, configuredEnv, launch);
+    const probeEnv = probeEnvForLaunch(def, configuredEnv, launch, options);
     const outcome = await probeVersionAtPath(def, launch.launchPath, probeEnv);
     if (outcome.kind === 'not-invocable') {
         return unavailableAgent(def, [buildNotInvocableDiagnostic({ def: def, launch: launch, cause: outcome.cause })]);
     }
-    // The version probe must finish first (it gates availability), but the
-    // three post-version probes are independent reads — run them
-    // concurrently so a single agent's detection wall is
-    // max(help, models, auth) instead of the sum. `--help` capabilities are
-    // cached on `agentCapabilities` for buildArgs to consult.
-    const [caps, modelResult, auth] = await Promise.all([
-        probeCapabilities(def, launch.launchPath, probeEnv),
-        fetchModels(def, launch.launchPath, probeEnv, { version: outcome.version, ...options }),
-        probeAgentAuthStatus({ def: def, resolvedBin: launch.launchPath, env: probeEnv }),
-    ]);
+    // The version probe must finish first (it gates availability). Cheap help/auth checks
+    // precede model discovery; the shared process scheduler prevents concurrent CLI startups.
+    // Capability evidence belongs to the existing ensureAgentCapabilities cache, also used by runs.
+    const runtimeState = options.state ?? defaultRuntimeState;
+    const capabilityKey = `${def.id}\u0000${launch.launchPath}`;
+    if (options.force || !runtimeState.capabilityProbes.has(capabilityKey)) {
+        runtimeState.capabilities.delete(def.id);
+        if (options.force)
+            runtimeState.capabilityProbes.delete(capabilityKey);
+    }
+    await ensureAgentCapabilities({ def, launchPath: launch.launchPath, env: probeEnv }, { state: runtimeState,
+        probe: async () => (await probeCapabilities(def, launch.launchPath, probeEnv)) ?? {},
+    });
+    const caps = runtimeState.capabilities.get(def.id);
+    const auth = await probeAgentAuthStatus({ def, resolvedBin: launch.launchPath, env: probeEnv });
+    const modelResult = await fetchModels(def, launch.launchPath, probeEnv, { version: outcome.version, ...options, deps: options.deps ?? getRuntimeModelDiscoveryDeps({ state: runtimeState }) });
     const surfacedModelResult = withRememberedAmrModels(def, probeEnv, modelResult, amrProfileResolver);
     if (caps) {
-        agentCapabilities.set(def.id, caps);
+        (options.state ?? defaultRuntimeState).capabilities.set(def.id, caps);
     }
     const authDiagnostic = auth ? buildAuthDiagnostic({ def: def, auth: auth }) : null;
     return {
@@ -290,8 +299,38 @@ function stripFns(def) {
     const { discoverModels: _discoverModels, resolveDefaultModel: _resolveDefaultModel, buildArgs: _buildArgs, listModels: _listModels, fetchModels: _fetchModels, deriveReasoningOptions: _deriveReasoningOptions, fallbackModels: _fallbackModels, fallbackModelsAssertedAt: _fallbackModelsAssertedAt, helpArgs: _helpArgs, capabilityFlags: _capabilityFlags, fallbackBins: _fallbackBins, versionProbeTimeoutMs: _versionProbeTimeoutMs, maxPromptArgBytes: _maxPromptArgBytes, env: _env, inactivityTimeoutMs: _inactivityTimeoutMs, authProbe: _authProbe, needsAgentLogFile: _needsAgentLogFile, stdoutPolicy: _stdoutPolicy, runtimeLock: _runtimeLock, ...rest } = def;
     return rest;
 }
-async function safeProbe(def, configuredEnv = {}, amrProfileResolver, options = {}) {
+/** Cache complete detection per host and effective launch. No TTL re-spawns version/help/auth.
+ * Explicit force queues after the current scan, so a rescan cannot overlap its predecessor.
+ * Hash credentials rather than retaining them in keys. @complexity O(e) launch-env hashing. */
+function safeProbe(def, configuredEnv, amrProfileResolver, options = {}) {
+    const state = options.state ?? defaultRuntimeState;
+    let key;
+    try {
+        key = detectionCacheKey({ def, configuredEnv, options, state });
+    }
+    catch {
+        return Promise.resolve(unavailableAgent(def));
+    }
+    const previous = state.detections.get(key);
+    if (previous && !options.force)
+        return previous;
+    const pending = (previous ?? Promise.resolve()).then(() => executeSafeProbe(def, configuredEnv, amrProfileResolver, options));
+    state.detections.set(key, pending);
+    return pending;
+}
+/** Effective launch material is hashed, so cache keys never expose credentials.
+ * Legacy remembered-model profile resolution must not gate executable availability. */
+function detectionCacheKey({ def, configuredEnv, options, state }, _options = {}) {
+    const launch = resolveAgentLaunch({ def }, { configuredEnv, state, ...(options.env ? { env: options.env } : {}) });
+    const env = options.env ?? process.env;
+    return createHash('sha256').update(JSON.stringify({ id: def.id, path: launch.launchPath,
+        env: Object.entries(env).sort(([a], [b]) => a.localeCompare(b)), configuredEnv,
+        context: options.context })).digest('hex');
+}
+async function executeSafeProbe(def, configuredEnv = {}, amrProfileResolver, options = {}) {
     try {
+        if (options.probeAgent)
+            return await options.probeAgent({ def, configuredEnv, amrProfileResolver }, options);
         return await probe(def, configuredEnv, amrProfileResolver, options);
     }
     catch {
@@ -302,19 +341,19 @@ async function safeProbe(def, configuredEnv = {}, amrProfileResolver, options =
         return unavailableAgent(def);
     }
 }
-function rememberDetectedLiveModels(def, configuredEnv, agent, amrProfileResolver) {
-    rememberDetectedModelList(def, configuredEnv, agent.models, amrProfileResolver);
+function rememberDetectedLiveModels(def, configuredEnv, agent, amrProfileResolver, options = {}) {
+    rememberDetectedModelList(def, configuredEnv, agent.models, amrProfileResolver, options);
 }
-function rememberDetectedModelList(def, configuredEnv, models, amrProfileResolver) {
+function rememberDetectedModelList(def, configuredEnv, models, amrProfileResolver, options = {}) {
     if (def.id === 'amr' && models.length === 0)
         return;
     const scope = def.id === 'amr'
-        ? amrModelScopeFromEnv({ ...process.env, ...(def.env || {}), ...configuredEnv }, amrProfileResolver)
+        ? amrModelScopeFromEnv({ ...(options.env ?? process.env), ...(def.env || {}), ...configuredEnv }, amrProfileResolver)
         : null;
-    rememberLiveModels({ agentId: def.id, models: models.filter((row) => row.identityKind !== 'routing-mode') }, { scope: scope });
+    rememberLiveModels({ agentId: def.id, models: models.filter((row) => row.identityKind !== 'routing-mode') }, { scope: scope, ...(options.state ? { state: options.state } : {}) });
 }
-export async function detectAgents({}, { configuredEnvByAgent = {}, amrProfileResolver = noopAmrProfileResolver, modelContextByAgent = {}, modelDiscoveryDeps, force = false } = {}) {
-    const results = await Promise.all(AGENT_DEFS.map((def) => safeProbe(def, configuredEnvByAgent?.[def.id] ?? {}, amrProfileResolver, { ...(modelContextByAgent[def.id] ? { context: modelContextByAgent[def.id] } : {}), ...(modelDiscoveryDeps ? { deps: modelDiscoveryDeps } : {}), force })));
+export async function detectAgents({}, { configuredEnvByAgent = {}, amrProfileResolver = noopAmrProfileResolver, modelContextByAgent = {}, modelDiscoveryDeps, force = false, state = defaultRuntimeState, env = process.env, probeAgent } = {}) {
+    const results = await Promise.all(AGENT_DEFS.map((def) => safeProbe(def, configuredEnvByAgent?.[def.id] ?? {}, amrProfileResolver, { ...(modelContextByAgent[def.id] ? { context: modelContextByAgent[def.id] } : {}), deps: modelDiscoveryDeps ?? getRuntimeModelDiscoveryDeps({ state }), force, state, env, ...(probeAgent ? { probeAgent } : {}) })));
     // Refresh the validation cache from whatever we just surfaced to the UI
     // so a chat endpoint can accept any model the user could have just
     // picked, including ones that only showed up after a CLI re-auth.
@@ -323,7 +362,7 @@ export async function detectAgents({}, { configuredEnvByAgent = {}, amrProfileRe
         // is in-bounds for `AGENT_DEFS` too — the assertion just satisfies
         // `noUncheckedIndexedAccess`.
         const def = AGENT_DEFS[index];
-        rememberDetectedLiveModels(def, configuredEnvByAgent?.[def.id] ?? {}, agent, amrProfileResolver);
+        rememberDetectedLiveModels(def, configuredEnvByAgent?.[def.id] ?? {}, agent, amrProfileResolver, { state, env });
     }
     return results;
 }
@@ -333,9 +372,9 @@ export async function detectAgents({}, { configuredEnvByAgent = {}, amrProfileRe
 // validation cache is refreshed per-agent (same effect as the batch path,
 // just incrementally). `detectAgents` keeps the array contract for callers
 // that don't care about incremental delivery.
-export async function* detectAgentsStream({}, { configuredEnvByAgent = {}, amrProfileResolver = noopAmrProfileResolver, modelContextByAgent = {}, modelDiscoveryDeps, force = false } = {}) {
-    const tagged = AGENT_DEFS.map((def, index) => safeProbe(def, configuredEnvByAgent?.[def.id] ?? {}, amrProfileResolver, { ...(modelContextByAgent[def.id] ? { context: modelContextByAgent[def.id] } : {}), ...(modelDiscoveryDeps ? { deps: modelDiscoveryDeps } : {}), force }).then((agent) => {
-        rememberDetectedLiveModels(def, configuredEnvByAgent?.[def.id] ?? {}, agent, amrProfileResolver);
+export async function* detectAgentsStream({}, { configuredEnvByAgent = {}, amrProfileResolver = noopAmrProfileResolver, modelContextByAgent = {}, modelDiscoveryDeps, force = false, state = defaultRuntimeState, env = process.env, probeAgent } = {}) {
+    const tagged = AGENT_DEFS.map((def, index) => safeProbe(def, configuredEnvByAgent?.[def.id] ?? {}, amrProfileResolver, { ...(modelContextByAgent[def.id] ? { context: modelContextByAgent[def.id] } : {}), deps: modelDiscoveryDeps ?? getRuntimeModelDiscoveryDeps({ state }), force, state, env, ...(probeAgent ? { probeAgent } : {}) }).then((agent) => {
+        rememberDetectedLiveModels(def, configuredEnvByAgent?.[def.id] ?? {}, agent, amrProfileResolver, { state, env });
         return { index, agent };
     }));
     const pending = new Set(tagged.keys());

package/dist/diagnostics.d.ts

@@ -1,9 +1,14 @@
+/**
+ * @module diagnostics
+ * Explain three detection failures: unresolved executable, uninvocable executable or missing authentication.
+ */
+import { type ExecutableResolutionOptions } from './executables.js';
 import type { AgentLaunchResolution } from './launch.js';
 import type { AgentAuthProbeResult } from './auth.js';
 import type { AgentDiagnostic, RuntimeAgentDef } from './types.js';
 export declare function buildExecutableDiagnostic({ def }: {
     def: Pick<RuntimeAgentDef, 'id' | 'name' | 'bin'>;
-}, { configuredEnv }?: {
+}, { configuredEnv, ...options }?: ExecutableResolutionOptions & {
     configuredEnv?: Record<string, string>;
 }): AgentDiagnostic;
 export type NotInvocableCause = 'not-executable' | 'missing-target';

package/dist/diagnostics.js

@@ -16,7 +16,7 @@ function setEnvIntent(agentId) {
 // user-supplied `*_BIN` override points at a missing/invalid file. The two
 // cases get different copy + fix affordances because the remedy differs
 // (install / point us at the binary vs. fix or clear the override).
-export function buildExecutableDiagnostic({ def }, { configuredEnv = {} } = {}) {
+export function buildExecutableDiagnostic({ def }, { configuredEnv = {}, ...options } = {}) {
     const envKey = agentBinEnvKey({ agentId: def.id });
     const overrideRaw = envKey ? configuredEnv?.[envKey]?.trim() : '';
     if (envKey && overrideRaw) {
@@ -32,7 +32,7 @@ export function buildExecutableDiagnostic({ def }, { configuredEnv = {} } = {})
         reason: 'not-on-path',
         severity: 'error',
         message: `${def.name} (\`${def.bin}\`) was not found on your PATH.`,
-        searchedDirs: agentSearchDirs().slice(0, MAX_SEARCHED_DIRS),
+        searchedDirs: agentSearchDirs({}, options).slice(0, MAX_SEARCHED_DIRS),
         fixActions: [{ kind: 'openInstall' }, ...setEnvIntent(def.id), { kind: 'rescan' }],
     };
 }

package/dist/env.js

@@ -7,7 +7,7 @@
  * sandboxOverlay. The engine must not import a product's config/sandbox subsystems or env names.
  */
 import os from 'node:os';
-import { mergeProxyAwareEnv, resolveSystemProxyEnv } from '@jini-ai/platform';
+import { mergeProxyAwareEnv, resolveSystemProxyEnv } from '@jini-ai/platform/proxy-env';
 import { expandConfiguredEnv } from './paths.js';
 import { resolveAmrOpenCodeExecutable } from './executables.js';
 function stripKeysCaseInsensitive(env, keysToStrip) {

package/dist/executables.d.ts

@@ -1,4 +1,10 @@
+import { type AgentRuntimeState } from './runtime-state.js';
 import type { RuntimeAgentDef } from './types.js';
+/** Host environment and runtime state used by executable resolution. */
+export interface ExecutableResolutionOptions {
+    env?: NodeJS.ProcessEnv;
+    state?: AgentRuntimeState;
+}
 /**
  * Override the env var names `resolveDetectionHome` / the packaged-binary
  * lookup read. The host application (e.g. the OD adapter) calls this once
@@ -10,27 +16,27 @@ export declare function configureExecutableResolutionEnv({ overrides }: {
         agentHomeEnvVar?: string;
         resourceRootEnvVar?: string;
     };
+}, { state }?: {
+    state?: AgentRuntimeState;
 }): void;
-export declare function userToolchainBinDirs(): string[];
-export declare function agentSearchDirs(): string[];
+export declare function userToolchainBinDirs(_required?: Record<string, never>, options?: ExecutableResolutionOptions): string[];
+export declare function agentSearchDirs(_required?: Record<string, never>, options?: ExecutableResolutionOptions): string[];
 export declare function agentBinEnvKey({ agentId }: {
     agentId: string | undefined;
 }): string | null;
 export declare function resolveOnPath({ bin }: {
     bin: string;
-}): string | null;
-export declare function resolveAmrOpenCodeExecutable({}: {}, { env }?: {
-    env?: Record<string, string | undefined>;
-}): string | null;
-export declare function codexAppBundleCandidates(): string[];
+}, options?: ExecutableResolutionOptions): string | null;
+export declare function resolveAmrOpenCodeExecutable({}: {}, { env, state }?: ExecutableResolutionOptions): string | null;
+export declare function codexAppBundleCandidates(_required?: Record<string, never>, options?: ExecutableResolutionOptions): string[];
 export declare function resolveAgentExecutable({ def }: {
     def: RuntimeAgentDef;
-}, { configuredEnv }?: {
+}, options?: ExecutableResolutionOptions & {
     configuredEnv?: Record<string, string>;
 }): string | null;
 export declare function inspectAgentExecutableResolution({ def }: {
     def: RuntimeAgentDef;
-}, { configuredEnv }?: {
+}, options?: ExecutableResolutionOptions & {
     configuredEnv?: Record<string, string>;
 }): {
     configuredOverridePath: string | null;