@jini-ai/agent-runtime 0.4.3 → 0.4.5

package/dist/agent-protocol/acp/models.d.ts

@@ -1,3 +1,12 @@
+/** @module agent-protocol/acp/models
+ * ACP model detection, normalisation, and config-option selection. The primary
+ * export `detectAcpModels` spawns an ACP subprocess, performs the
+ * `initialize` + `session/new` handshake, and returns the available model list.
+ * Consumed by runtime adapter definitions. Depends on the core JSON-line
+ * stream and acp/types, acp/constants, acp/json, acp/rpc, and
+ * acp/session-params.
+ */
+import { spawn } from 'node:child_process';
 import type { UnknownRecord } from './types.js';
 /** A single model entry exposed to the daemon's model-selection UI and to `session/set_model` calls. */
 export interface ModelOption {
@@ -22,6 +31,8 @@ export interface DetectAcpModelsOptions {
     defaultModelOption?: ModelOption;
     signal?: AbortSignal;
     onSessionResult?: (result: UnknownRecord) => void;
+    /** Process effect port; metadata tests use a child fake rather than replacing modules. */
+    spawnProcess?: typeof spawn;
 }
 /**
  * Normalises a raw config-option field value to a lowercase, whitespace- and

package/dist/agent-protocol/acp/models.js

@@ -191,10 +191,10 @@ export function currentModelFromSessionResult(result) {
  * @returns A promise resolving to the available `ModelOption[]`.
  */
 export async function detectAcpModels(requiredArgs, optionalArgs = {}) {
-    const { bin, args, cwd = process.cwd(), env = process.env, timeoutMs = DEFAULT_TIMEOUT_MS, clientName = 'agent-runtime-detect', clientVersion = 'runtime-adapter', defaultModelOption = { id: 'default', label: 'Default (CLI config)' }, signal, onSessionResult, } = { ...optionalArgs, ...requiredArgs };
+    const { bin, args, cwd = process.cwd(), env = process.env, timeoutMs = DEFAULT_TIMEOUT_MS, clientName = 'agent-runtime-detect', clientVersion = 'runtime-adapter', defaultModelOption = { id: 'default', label: 'Default (CLI config)' }, signal, onSessionResult, spawnProcess = spawn, } = { ...optionalArgs, ...requiredArgs };
     const effectiveTimeoutMs = resolveAcpTimeoutMs(env, timeoutMs);
     return await new Promise((resolve, reject) => {
-        const child = spawn(bin, args, {
+        const child = spawnProcess(bin, args, {
             cwd,
             stdio: ['pipe', 'pipe', 'pipe'],
             env: { ...env },
@@ -202,6 +202,7 @@ export async function detectAcpModels(requiredArgs, optionalArgs = {}) {
         child.stdout.setEncoding('utf8');
         child.stderr.setEncoding('utf8');
         let settled = false;
+        let closed = false;
         let stderrBuf = '';
         let stdoutBytes = 0;
         let expectedId = 1;
@@ -223,7 +224,14 @@ export async function detectAcpModels(requiredArgs, optionalArgs = {}) {
             const killTimer = setTimeout(() => { if (child.exitCode === null)
                 child.kill('SIGKILL'); }, 250);
             killTimer.unref();
-            fn(value);
+            // The process scheduler must retain its slot until exit, including the SIGKILL grace
+            // period. Returning at metadata receipt would overlap this child with the next probe.
+            if (closed) {
+                clearTimeout(killTimer);
+                fn(value);
+            }
+            else
+                child.once('close', () => { clearTimeout(killTimer); fn(value); });
         };
         const fail = (message) => {
             finish(reject, new Error(message));
@@ -289,6 +297,7 @@ export async function detectAcpModels(requiredArgs, optionalArgs = {}) {
         });
         child.on('error', (err) => fail(`spawn failed: ${err.message}`));
         child.on('close', (code, signal) => {
+            closed = true;
             parser.flush();
             if (!settled) {
                 const errTail = stderrBuf.trim();

package/dist/capabilities.d.ts

@@ -1,9 +1,2 @@
-/**
- * @module capabilities
- *
- * Per-agent `--help`-probed capability flags, cached by agent id. Ported
- * verbatim from OD's `apps/daemon/src/runtimes/capabilities.ts`.
- */
-import type { RuntimeCapabilityMap } from './types.js';
-export declare const agentCapabilities: Map<string, RuntimeCapabilityMap>;
+export declare const agentCapabilities: Map<string, import("./types.js").RuntimeCapabilityMap>;
 //# sourceMappingURL=capabilities.d.ts.map

package/dist/capabilities.js

@@ -1,2 +1,9 @@
-export const agentCapabilities = new Map();
+/**
+ * @module capabilities
+ *
+ * Per-agent `--help`-probed capability flags, cached by agent id. Ported
+ * verbatim from OD's `apps/daemon/src/runtimes/capabilities.ts`.
+ */
+import { defaultRuntimeState } from './runtime-state.js';
+export const agentCapabilities = defaultRuntimeState.capabilities;
 //# sourceMappingURL=capabilities.js.map

package/dist/claude-code-models.d.ts

@@ -1,3 +1,4 @@
+import { type AgentRuntimeState } from './runtime-state.js';
 import type { RuntimeEnv, RuntimeModelOption } from './types.js';
 /** The single stdin line that asks the CLI for its initialize payload (which carries `models`). */
 export declare const CLAUDE_CODE_INITIALIZE_REQUEST = "{\"type\":\"control_request\",\"request_id\":\"jini-model-probe\",\"request\":{\"subtype\":\"initialize\"}}\n";
@@ -58,5 +59,16 @@ export declare function setClaudeCodeModelIoForTesting(io: ClaudeCodeModelIo | n
  * @complexity O(f + l) plus, at most once per {@link CLAUDE_CODE_MODEL_CACHE_TTL_MS} per cache key,
  * one CLI spawn bounded by {@link CLAUDE_CODE_INIT_TIMEOUT_MS} and one file read.
  */
-export declare function loadClaudeCodeModels(bin: string, env: RuntimeEnv, _fallbackModels: readonly RuntimeModelOption[], now?: () => number): Promise<RuntimeModelOption[] | null>;
+export interface ClaudeCodeModelsOptions {
+    state?: AgentRuntimeState;
+    io?: ClaudeCodeModelIo;
+    now?: () => number;
+}
+export declare function loadClaudeCodeModels(required: {
+    bin: string;
+    env: RuntimeEnv;
+    fallbackModels?: readonly RuntimeModelOption[];
+}, optional?: ClaudeCodeModelsOptions): Promise<RuntimeModelOption[] | null>;
+/** Published positional form remains additive compatibility. */
+export declare function loadClaudeCodeModels(bin: string, env: RuntimeEnv, fallbackModels: readonly RuntimeModelOption[], now?: () => number): Promise<RuntimeModelOption[] | null>;
 //# sourceMappingURL=claude-code-models.d.ts.map

package/dist/claude-code-models.js

@@ -1,3 +1,4 @@
+import { defaultRuntimeState } from './runtime-state.js';
 /**
  * @module claude-code-models
  *
@@ -193,7 +194,7 @@ const defaultIo = {
     readConfigFile: (path) => readFile(path, 'utf8').catch(() => null),
 };
 let activeIo = defaultIo;
-const cache = new Map();
+const cache = defaultRuntimeState.claudeModels;
 /** Test-only: install fake I/O (or `null` to restore the real one) and clear the process cache. */
 export function setClaudeCodeModelIoForTesting(io) {
     activeIo = io ?? defaultIo;
@@ -209,13 +210,13 @@ function cacheKeyFor(bin, env) {
     return `${bin}\u0000${resolveClaudeConfigPath(env)}\u0000${fingerprint}`;
 }
 /** Source (1), then source (2). Never rejects. */
-async function discoverClaudeCodeModels(bin, env) {
+async function discoverClaudeCodeModels(bin, env, io) {
     try {
-        const stdout = await activeIo.runInitialize(bin, env);
+        const stdout = await io.runInitialize(bin, env);
         const fromCli = stdout ? parseClaudeInitializeModels(stdout) : null;
         if (fromCli)
             return fromCli;
-        const raw = await activeIo.readConfigFile(resolveClaudeConfigPath(env));
+        const raw = await io.readConfigFile(resolveClaudeConfigPath(env));
         const cached = raw === null ? null : parseClaudeCodePickerCache(raw);
         if (!cached?.ok)
             return null;
@@ -227,21 +228,18 @@ async function discoverClaudeCodeModels(bin, env) {
         return null;
     }
 }
-/**
- * Returns the `claude` model list from the CLI's own picker catalog, or `null` when discovery fails. Needs no API key.
- *
- * @param bin - The resolved `claude` (or fork) binary detection found.
- * @param env - The composed environment for the agent — what a spawn would actually see.
- * @param _fallbackModels - Compatibility argument; packaged rows are offline fallback only.
- * @param now - Injectable clock for TTL tests.
- * @complexity O(f + l) plus, at most once per {@link CLAUDE_CODE_MODEL_CACHE_TTL_MS} per cache key,
- * one CLI spawn bounded by {@link CLAUDE_CODE_INIT_TIMEOUT_MS} and one file read.
- */
-export async function loadClaudeCodeModels(bin, env, _fallbackModels, now = Date.now) {
+export async function loadClaudeCodeModels(required, optional = {}, _fallbackModels = [], clock = Date.now) {
+    const bin = typeof required === 'string' ? required : required.bin;
+    const env = typeof required === 'string' ? optional : required.env;
+    const options = typeof required === 'string' ? {} : optional;
+    const state = options.state ?? defaultRuntimeState;
+    const cache = state.claudeModels;
+    const io = options.io ?? (state === defaultRuntimeState ? activeIo : defaultIo);
+    const now = options.now ?? clock;
     const key = cacheKeyFor(bin, env);
     const cached = cache.get(key);
     const pending = cached && cached.expiresAt > now() ? cached.value : null;
-    const value = pending ?? discoverClaudeCodeModels(bin, env);
+    const value = pending ?? discoverClaudeCodeModels(bin, env, io);
     if (!pending)
         cache.set(key, { expiresAt: now() + CLAUDE_CODE_MODEL_CACHE_TTL_MS, value });
     const live = await value;

package/dist/claude-segment-usage.d.ts

@@ -0,0 +1,26 @@
+/** Token counters are per segment; Claude's dollar counter spans the session.
+ * Aborted results can zero counters already streamed. */
+export declare function createClaudeSegmentUsage(_required: Record<string, never>, { nowMs, costBasis }?: {
+    nowMs?: () => number;
+    costBasis?: 'session' | 'run';
+}): {
+    observe: ({ messageId, usage }: {
+        messageId: string;
+        usage: unknown;
+    }, _optional?: {}) => void;
+    finish: ({ result, interrupted }: {
+        result: Record<string, unknown>;
+        interrupted: boolean;
+    }, _optional?: {}) => {
+        cumulativeCostUsd?: number;
+        costSessionId?: string;
+        usage: {} | null;
+        costUsd: {} | null;
+        durationMs: {} | null;
+    };
+    setSession: ({ id }: {
+        id: unknown;
+    }, _optional?: {}) => void;
+    hasObserved: () => boolean;
+};
+//# sourceMappingURL=claude-segment-usage.d.ts.map

package/dist/claude-segment-usage.js

@@ -0,0 +1,63 @@
+/** Token counters are per segment; Claude's dollar counter spans the session.
+ * Aborted results can zero counters already streamed. */
+export function createClaudeSegmentUsage(_required, { nowMs = Date.now, costBasis = 'session' } = {}) {
+    const messages = new Map();
+    let startedAt = nowMs();
+    let sessionId;
+    /** Capture the CLI's identity so durable chat usage can reconcile resumed runs. */
+    function setSession({ id }, _optional = {}) {
+        if (typeof id === 'string' && id.length > 0)
+            sessionId = id;
+    }
+    /** Merge cumulative counters for one message; wrappers repeat the same streamed usage.
+     * O(k) per snapshot in k reported counters; retained state is O(m·k) for m messages in a segment. */
+    function observe({ messageId, usage }, _optional = {}) {
+        if (!usage || typeof usage !== 'object')
+            return;
+        const previous = messages.get(messageId) ?? {};
+        for (const [key, value] of Object.entries(usage)) {
+            if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
+                previous[key] = Math.max(previous[key] ?? 0, value);
+        }
+        if (Object.keys(previous).length)
+            messages.set(messageId, previous);
+    }
+    /** Produce one segment's totals and release its snapshots. Never infer a monetary charge
+     * from token counts: only CLI-reported costs are eligible. O(m·k), no external effects. */
+    function finish({ result, interrupted }, _optional = {}) {
+        const usage = { ...((result.usage && typeof result.usage === 'object') ? result.usage : {}) };
+        const observed = {};
+        for (const counters of messages.values()) {
+            for (const [key, value] of Object.entries(counters))
+                observed[key] = (observed[key] ?? 0) + value;
+        }
+        for (const [key, value] of Object.entries(observed)) {
+            const reported = usage[key];
+            usage[key] = typeof reported === 'number' && Number.isFinite(reported) ? Math.max(reported, value) : value;
+        }
+        const modelCosts = result.modelUsage && typeof result.modelUsage === 'object' ? Object.values(result.modelUsage) : [];
+        const reportedModelCost = modelCosts.reduce((sum, model) => {
+            const cost = model && typeof model === 'object' ? model.costUSD : undefined;
+            return sum + (typeof cost === 'number' && Number.isFinite(cost) && cost >= 0 ? cost : 0);
+        }, 0);
+        const costUsd = reportedModelCost > 0 ? Math.max(typeof result.total_cost_usd === 'number' ? result.total_cost_usd : 0, reportedModelCost) : result.total_cost_usd ?? null;
+        const endedAt = nowMs();
+        const duration = result.duration_ms;
+        const durationMs = typeof duration === 'number' && duration > 0 ? duration
+            : messages.size || interrupted ? Math.max(0, endedAt - startedAt) : duration ?? null;
+        messages.clear();
+        startedAt = endedAt;
+        // Preserve the cumulative snapshot rather than calling it a per-run charge. A zeroed
+        // aborted result still uses the existing model-cost fallback for its interrupted segment.
+        const cumulative = costBasis === 'session' && sessionId !== undefined &&
+            typeof costUsd === 'number' && Number.isFinite(costUsd) && costUsd >= 0 &&
+            !(interrupted && result.total_cost_usd === 0);
+        return { usage: Object.keys(usage).length ? usage : result.usage ?? null,
+            costUsd: cumulative ? null : costUsd, durationMs,
+            ...(costBasis === 'session' && sessionId !== undefined ? { costSessionId: sessionId } : {}),
+            ...(cumulative ? { cumulativeCostUsd: costUsd } : {}),
+        };
+    }
+    return { observe, finish, setSession, hasObserved: () => messages.size > 0 };
+}
+//# sourceMappingURL=claude-segment-usage.js.map

package/dist/claude-stream.d.ts

@@ -82,6 +82,8 @@ export type ClaudeStreamEvent = {
     type: 'usage';
     usage: unknown;
     costUsd: unknown;
+    cumulativeCostUsd?: number;
+    costSessionId?: string;
     durationMs: unknown;
     stopReason: string | null;
 } | {
@@ -157,6 +159,10 @@ export declare function applyInputJsonDelta(state: BlockState | undefined, parti
 export declare function emitAssistantErrorIfPresent(obj: Record<string, unknown>, content: unknown[], onEvent: EventSink): void;
 interface ClaudeStreamHandlerOptions {
     suppressHtmlArtifactsAfterFileWrite?: boolean;
+    /** Clock used only when an interrupted segment omits its duration. */
+    nowMs?: () => number;
+    /** Claude's results span a session; compatible CLIs can retain per-run cost semantics. */
+    costBasis?: 'session' | 'run';
 }
 export declare function createClaudeStreamHandler({ onEvent }: {
     onEvent: EventSink;

package/dist/claude-stream.js

@@ -37,6 +37,7 @@
  * exercised only through `feed`/`flush` in the test suite.
  */
 import { createRoleMarkerGuard } from './role-marker-guard.js';
+import { createClaudeSegmentUsage } from './claude-segment-usage.js';
 function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -338,9 +339,13 @@ export function emitAssistantErrorIfPresent(obj, content, onEvent) {
 }
 export function createClaudeStreamHandler({ onEvent }, options = {}) {
     let buffer = '';
+    const segmentUsage = createClaudeSegmentUsage({}, {
+        ...(options.nowMs === undefined ? {} : { nowMs: options.nowMs }),
+        ...(options.costBasis === undefined ? {} : { costBasis: options.costBasis }),
+    });
     // Per-content-block scratch, keyed by `${messageId}:${blockIndex}`.
     const blocks = new Map();
-    // Tool uses already emitted from streamed `input_json_delta` data.
+    // Tool uses already emitted from streamed `input_json_delta` data OR full wrappers.
     // Claude Code still repeats them in the final assistant wrapper, often with
     // empty `{}` inputs, so we suppress that duplicate emission.
     const streamedToolUseIds = new Set();
@@ -404,6 +409,11 @@ export function createClaudeStreamHandler({ onEvent }, options = {}) {
         }
     }
     function emitToolUse(id, name, input) {
+        if (typeof id === 'string') {
+            if (streamedToolUseIds.has(id))
+                return;
+            streamedToolUseIds.add(id);
+        }
         if (emitCanonicalTaskSnapshot(id, name, input, taskRegistry, onEvent))
             return;
         if (isFileWriteToolUse(name, input)) {
@@ -566,6 +576,9 @@ export function createClaudeStreamHandler({ onEvent }, options = {}) {
             }
         }
         flushPendingArtifactText();
+        // A hard cancel has no result frame. Flush only counters actually observed, once.
+        if (segmentUsage.hasObserved())
+            onEvent({ type: 'usage', ...segmentUsage.finish({ result: {}, interrupted: true }), stopReason: null });
     }
     function handleToolUseBlock(block) {
         if (typeof block.id === 'string' && streamedToolUseIds.has(block.id))
@@ -625,6 +638,7 @@ export function createClaudeStreamHandler({ onEvent }, options = {}) {
         if (typeof message.model === 'string')
             onEvent({ type: 'status', label: 'model', model: message.model });
         const { textMsgId, thinkingMsgId, textAlreadyStreamed, thinkingAlreadyStreamed } = resolveAssistantMessageIds(message);
+        segmentUsage.observe({ messageId: currentMessageId ?? `anon${anonymousMessageEpoch}`, usage: message.usage });
         // Per-turn `stop_reason` is emitted as `turn_end` AFTER the content
         // blocks have been processed (see below). When `--include-partial-
         // messages` is unsupported, tool_use events surface only from the
@@ -664,15 +678,14 @@ export function createClaudeStreamHandler({ onEvent }, options = {}) {
         }
         onEvent({
             type: 'usage',
-            usage: obj.usage ?? null,
-            costUsd: obj.total_cost_usd ?? null,
-            durationMs: obj.duration_ms ?? null,
+            ...segmentUsage.finish({ result: obj, interrupted: stopReason?.startsWith('aborted') === true }),
             stopReason,
         });
     }
     function handleObject(obj) {
         if (!isRecord(obj))
             return;
+        segmentUsage.setSession({ id: obj.session_id });
         switch (obj.type) {
             case 'system':
                 handleSystemMessage(obj, onEvent);
@@ -703,6 +716,7 @@ export function createClaudeStreamHandler({ onEvent }, options = {}) {
         // New message boundary — see `anonymousMessageEpoch`'s declaration.
         if (currentMessageId === null)
             anonymousMessageEpoch += 1;
+        segmentUsage.observe({ messageId: currentMessageId ?? `anon${anonymousMessageEpoch}`, usage: isRecord(ev.message) ? ev.message.usage : undefined });
         currentMessageStreamedText = false;
         currentMessageStreamedThinking = false;
         if (typeof ev.ttft_ms === 'number') {
@@ -786,6 +800,7 @@ export function createClaudeStreamHandler({ onEvent }, options = {}) {
                 handleContentBlockStop(ev);
                 return;
             case 'message_delta':
+                segmentUsage.observe({ messageId: currentMessageId ?? `anon${anonymousMessageEpoch}`, usage: ev.usage ?? (isRecord(ev.delta) ? ev.delta.usage : undefined) });
                 if (isRecord(ev.delta))
                     handleMessageDeltaEvent(ev.delta);
                 return;

package/dist/defs/claude.d.ts

@@ -37,9 +37,11 @@ export declare const claudeAgentDef: {
     promptViaStdin: true;
     promptInputFormat: "stream-json";
     streamFormat: string;
+    usageCostBasis: "session";
     externalMcpInjection: "claude-mcp-json";
     env: {
         ENABLE_TOOL_SEARCH: string;
+        CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: string;
     };
     systemPromptDelivery: {
         strategy: "append-flag";

package/dist/defs/claude.js

@@ -157,7 +157,7 @@ export const claudeAgentDef = {
     // default), which has no length cap. Mirrors the codex/opencode/
     // cursor/qwen entries below.
     buildArgs: ({ prompt: _prompt, imagePaths: _imagePaths }, { extraAllowedDirs = [], options = {}, runtimeContext = {} } = {}) => {
-        const caps = agentCapabilities.get('claude') || {};
+        const caps = (options.capabilities ?? agentCapabilities.get('claude')) || {};
         // `--input-format stream-json` lets the daemon stream multiple JSONL
         // messages into stdin instead of closing it after the initial prompt,
         // keeping the turn open so the daemon can stream further user messages
@@ -243,6 +243,7 @@ export const claudeAgentDef = {
     promptViaStdin: true,
     promptInputFormat: 'stream-json',
     streamFormat: 'claude-stream-json',
+    usageCostBasis: 'session',
     // Claude Code auto-loads `.mcp.json` from the project cwd at spawn,
     // so the daemon writes the user's external MCP servers there before
     // launching (server.ts handles the cwd guard).
@@ -254,7 +255,14 @@ export const claudeAgentDef = {
     // code.claude.com/docs/en/mcp ("`false` — All MCP tools loaded upfront, no deferral"); verified
     // in the installed 2.1.283 binary (a defined-falsy value selects the "standard" tool mode).
     // A default only: a run's own env can still set ENABLE_TOOL_SEARCH (see agent-executor).
-    env: { ENABLE_TOOL_SEARCH: 'false' },
+    env: {
+        ENABLE_TOOL_SEARCH: 'false',
+        // 2026-10-10 plannie incident: the CLI stopped two background theme subagents ten minutes
+        // after the reply ended. Installed Claude Code 2.1.296 confirms 0 waits indefinitely.
+        // Complements the daemon's stdin hold while background tasks run (agent-executor/events.ts).
+        // A default only: the host can override it through the run's explicit env passthrough.
+        CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: '0',
+    },
     // Formerly inline in `buildArgs` above (see the comment there) — moved to the declarative
     // shape every def now uses to receive `RuntimeBuildOptions.systemPromptOverlay`. Same flag,
     // same probe gate (`capabilityFlags['--append-system-prompt']` above), same "append, never

package/dist/defs/codebuddy.js

@@ -79,7 +79,7 @@ export const codebuddyAgentDef = {
         { id: 'max', label: 'Max' },
     ],
     buildArgs: ({ prompt: _prompt, imagePaths: _imagePaths }, { extraAllowedDirs = [], options = {}, runtimeContext = {} } = {}) => {
-        const caps = agentCapabilities.get('codebuddy') || {};
+        const caps = (options.capabilities ?? agentCapabilities.get('codebuddy')) || {};
         // Same stdin strategy as Claude Code: `--input-format stream-json`
         // enables JSONL stdin so the daemon can answer AskUserQuestion tool
         // calls. `--output-format stream-json` gives us SSE-style events.

package/dist/defs/cursor-agent.js

@@ -67,7 +67,7 @@ export const cursorAgentDef = {
     // which then surfaces as "your message only contains '-'". Keep stdin
     // piped for prompt delivery, but do not append a fake prompt arg.
     buildArgs: ({ prompt: _prompt, imagePaths: _imagePaths }, { extraAllowedDirs: _extra, options = {}, runtimeContext = {} } = {}) => {
-        const caps = agentCapabilities.get('cursor-agent') || {};
+        const caps = (options.capabilities ?? agentCapabilities.get('cursor-agent')) || {};
         const args = [];
         args.push('--print', '--output-format', 'stream-json', '--stream-partial-output');
         // See `RuntimeBuildOptions.permissionMode`'s doc: bypass is the default

package/dist/defs/opencode.js

@@ -58,7 +58,7 @@ export const opencodeAgentDef = {
         // (`skipPermissions`, probed from `--help` text) AND whether the caller wants it — see
         // `RuntimeBuildOptions.permissionMode`'s doc. Bypass remains the default (unchanged
         // behavior) unless a caller explicitly opts into a restricted run.
-        if (agentCapabilities.get('opencode')?.skipPermissions && options.permissionMode !== 'restricted') {
+        if ((options.capabilities ?? agentCapabilities.get('opencode'))?.skipPermissions && options.permissionMode !== 'restricted') {
             args.push(SKIP_PERMISSIONS_FLAG);
         }
         // Capture-style resume: OpenCode mints its own session id (reported on

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