@jini-ai/agent-runtime 0.4.4 → 0.4.6

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.4",
+  "version": "0.4.6",
   "description": "Coding-agent runtime adapters: runtime registry, detection, launch, stream parsers, and the ACP/pi-rpc subprocess transport.",
   "license": "Apache-2.0",
   "repository": {
@@ -16,7 +16,21 @@
       ".": "node",
       "./providers/tool-turn": "node",
       "./model-catalog/cache": "universal",
-      "./providers/sse-decode": "universal"
+      "./providers/sse-decode": "universal",
+      "./model-discovery": "node"
+    },
+    "isolation": {
+      "forbidden": {
+        "./model-discovery": [
+          "node:child_process",
+          "child_process",
+          "node:fs",
+          "fs",
+          "./model-discovery-adapters.js",
+          "./model-discovery-native.js",
+          "./model-discovery-sdk.js"
+        ]
+      }
     }
   },
   "type": "module",
@@ -43,6 +57,11 @@
       "types": "./dist/providers/sse-decode.d.ts",
       "import": "./dist/providers/sse-decode.js",
       "default": "./dist/providers/sse-decode.js"
+    },
+    "./model-discovery": {
+      "types": "./dist/model-discovery.d.ts",
+      "import": "./dist/model-discovery.js",
+      "default": "./dist/model-discovery.js"
     }
   },
   "typesVersions": {
@@ -55,6 +74,9 @@
       ],
       "providers/sse-decode": [
         "./dist/providers/sse-decode.d.ts"
+      ],
+      "model-discovery": [
+        "./dist/model-discovery.d.ts"
       ]
     }
   },
@@ -77,20 +99,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.3"
+    "@jini-ai/integrations": "^0.4.2",
+    "@jini-ai/platform": "^0.5.5",
+    "@jini-ai/protocol": "^0.4.4",
+    "@jini-ai/oauth": "^0.2.2"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.2"
+    "@jini-ai/core": "^0.4.4"
   },
   "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.5",
+    "@jini-ai/protocol": "^0.4.4"
   },
   "peerDependenciesMeta": {
+    "@jini-ai/integrations": {
+      "optional": true
+    },
     "@github/copilot-sdk": {
       "optional": true
     },