@jini-ai/agent-runtime 0.4.2 → 0.4.4

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.4.3 — 2026-10-08
+
+- Desktop 0.1.13 release fixes: see commits a2659d24 (admin), 5695a7c3 (chat, agent-runtime), 8ad4ac5c (devops).
+
 ## 0.4.2 — 2026-10-08
 
 - Tovu clean-up release: code Tovu moved into Jini, plus the Jini clean-up (see the commit log).

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

@@ -0,0 +1,19 @@
+/** Claude result totals are per segment. Aborted results can zero counters already streamed. */
+export declare function createClaudeSegmentUsage(_required: Record<string, never>, { nowMs }?: {
+    nowMs?: () => number;
+}): {
+    observe: ({ messageId, usage }: {
+        messageId: string;
+        usage: unknown;
+    }, _optional?: {}) => void;
+    finish: ({ result, interrupted }: {
+        result: Record<string, unknown>;
+        interrupted: boolean;
+    }, _optional?: {}) => {
+        usage: {} | null;
+        costUsd: {} | null;
+        durationMs: {} | null;
+    };
+    hasObserved: () => boolean;
+};
+//# sourceMappingURL=claude-segment-usage.d.ts.map

package/dist/claude-segment-usage.js

@@ -0,0 +1,47 @@
+/** Claude result totals are per segment. Aborted results can zero counters already streamed. */
+export function createClaudeSegmentUsage(_required, { nowMs = Date.now } = {}) {
+    const messages = new Map();
+    let startedAt = nowMs();
+    /** 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;
+        return { usage: Object.keys(usage).length ? usage : result.usage ?? null, costUsd, durationMs };
+    }
+    return { observe, finish, hasObserved: () => messages.size > 0 };
+}
+//# sourceMappingURL=claude-segment-usage.js.map

package/dist/claude-stream.d.ts

@@ -157,6 +157,8 @@ 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;
 }
 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,10 @@ export function emitAssistantErrorIfPresent(obj, content, onEvent) {
 }
 export function createClaudeStreamHandler({ onEvent }, options = {}) {
     let buffer = '';
+    const segmentUsage = createClaudeSegmentUsage({}, options.nowMs === undefined ? {} : { nowMs: options.nowMs });
     // 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 +406,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 +573,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 +635,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,9 +675,7 @@ 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,
         });
     }
@@ -703,6 +712,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 +796,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/model-discovery-adapters.d.ts

@@ -5,7 +5,10 @@ export declare function modelProbeTimeoutMs(agentId: string): number;
 export declare function probeCliSubcommand(context: ModelDiscoveryContext, config: AgentDiscoveryConfiguration, deps: ModelDiscoveryDeps, signal: AbortSignal): Promise<ModelProbeResult>;
 /** ACP can create CLI session state/start services. It never sends a user prompt. */
 export declare function probeAcpMetadata(context: ModelDiscoveryContext, args: readonly string[], deps: ModelDiscoveryDeps, signal: AbortSignal): Promise<ModelProbeResult>;
-/** Keep selection IDs, resolved concrete IDs and display names, including capability variants. */
+/** Keep selection IDs, resolved concrete IDs and display names, including capability variants.
+ * Default-policy display names become the exact resolved ID; malformed responses return null.
+ * @complexity O(s + n) time and space in stdout length s and listed models n.
+ */
 export declare function parseClaudeInitializeMetadata(stdout: string): ModelProbeResult | null;
 /** Shared initialize category; CodeBuddy compatibility remains UNVERIFIED locally. */
 export declare function probeClaudeInitialize(context: ModelDiscoveryContext, deps: ModelDiscoveryDeps, signal: AbortSignal): Promise<ModelProbeResult>;

package/dist/model-discovery-adapters.js

@@ -39,7 +39,10 @@ export async function probeCliSubcommand(context, config, deps, signal) {
 export async function probeAcpMetadata(context, args, deps, signal) {
     return deps.acp.probe({ context, args, signal });
 }
-/** Keep selection IDs, resolved concrete IDs and display names, including capability variants. */
+/** Keep selection IDs, resolved concrete IDs and display names, including capability variants.
+ * Default-policy display names become the exact resolved ID; malformed responses return null.
+ * @complexity O(s + n) time and space in stdout length s and listed models n.
+ */
 export function parseClaudeInitializeMetadata(stdout) {
     for (const line of stdout.split('\n')) {
         let obj;
@@ -64,9 +67,10 @@ export function parseClaudeInitializeMetadata(stdout) {
             const resolvedId = typeof row.resolvedModel === 'string' ? row.resolvedModel.trim() : undefined;
             const label = typeof row.displayName === 'string' && row.displayName.trim() ? row.displayName.trim() : resolvedId || id;
             if (id === 'default') {
+                // This displayName describes the CLI's default policy, not the model it resolves to.
                 if (resolvedId && modelIdentityKind(resolvedId) === 'concrete') {
                     defaultSelectionId = resolvedId;
-                    models.push({ id: resolvedId, label, identityKind: 'concrete' });
+                    models.push({ id: resolvedId, label: resolvedId, identityKind: 'concrete' });
                 }
                 continue;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/agent-runtime",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Coding-agent runtime adapters: runtime registry, detection, launch, stream parsers, and the ACP/pi-rpc subprocess transport.",
   "license": "Apache-2.0",
   "repository": {
@@ -79,7 +79,7 @@
     "@jini-ai/core": "^0.4.0",
     "@jini-ai/oauth": "^0.2.1",
     "@jini-ai/platform": "^0.5.2",
-    "@jini-ai/protocol": "^0.4.2"
+    "@jini-ai/protocol": "^0.4.3"
   },
   "dependencies": {
     "@jini-ai/core": "^0.4.2"

package/dist/defs/gemini.d.ts

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

package/dist/defs/gemini.js

@@ -1,81 +0,0 @@
-/**
- * @module defs/gemini
- *
- * Google's Gemini CLI (`gemini`, npm `@google/gemini-cli`). Checked against an installed
- * `gemini` 0.58.0 (`gemini --help` and the bundled headless code path) and the upstream headless
- * docs (<https://geminicli.com/docs/cli/headless>):
- *
- *   - Headless mode starts whenever stdin is not a TTY; the whole piped stdin becomes the prompt
- *     (`-p` is only needed to pass the prompt in argv, and would be "appended to input on stdin").
- *     So the prompt goes over stdin, like the Qwen Code fork, which avoids Windows `spawn
- *     ENAMETOOLONG` on large composed prompts.
- *   - `--output-format stream-json` emits the JSONL `init` / `message` / `tool_use` /
- *     `tool_result` / `error` / `result` events that `json-event-stream.ts`'s `gemini` parser
- *     already reads.
- *   - `--approval-mode yolo` auto-approves every tool (the `--yolo` alias does the same).
- *   - Since folder trust landed, a headless run in an untrusted directory exits with "Gemini CLI
- *     is not running in a trusted directory. To proceed, either use `--skip-trust`, …". The host
- *     already chose the run's cwd, so the def trusts it for this session only. Older builds
- *     reject unknown flags, so `--skip-trust` is gated on the `--help` capability probe.
- *   - `--include-directories` (repeatable) widens the workspace to dirs outside the cwd.
- *
- * Auth: since 2026-06-18 Google no longer serves Gemini CLI's "Login with Google" for free /
- * Google AI Pro / Ultra individual accounts (the run dies with `IneligibleTierError: This client
- * is no longer supported for Gemini Code Assist for individuals`). A Gemini API key, Vertex AI,
- * or a Gemini Code Assist license still works. There is no side-effect-free auth-status
- * subcommand, so no `authProbe`; `auth.ts#classifyAgentAuthFailure` turns the failure text into
- * setup guidance instead.
- */
-import { DEFAULT_MODEL_OPTION } from './shared.js';
-import { agentCapabilities } from '../capabilities.js';
-const SKIP_TRUST_FLAG = '--skip-trust';
-export const geminiAgentDef = {
-    id: 'gemini',
-    name: 'Gemini CLI',
-    bin: 'gemini',
-    versionArgs: ['--version'],
-    // A cold `gemini --version` took 4.7 s on the dev machine (warm ~2 s), past the 3 s default.
-    versionProbeTimeoutMs: 10_000,
-    helpArgs: ['--help'],
-    capabilityFlags: {
-        [SKIP_TRUST_FLAG]: 'skipTrust',
-    },
-    // No `models` subcommand. `auto` and the concrete ids below are the ones the installed
-    // 0.58.0 bundle and the upstream model docs name; any other id can still be typed in.
-    fallbackModels: [
-        DEFAULT_MODEL_OPTION,
-        { id: 'auto', label: 'auto' },
-        { id: 'gemini-3.1-pro-preview', label: 'gemini-3.1-pro-preview' },
-        { id: 'gemini-3.5-flash', label: 'gemini-3.5-flash' },
-        { id: 'gemini-3-pro-preview', label: 'gemini-3-pro-preview' },
-        { id: 'gemini-3-flash-preview', label: 'gemini-3-flash-preview' },
-        { id: 'gemini-2.5-pro', label: 'gemini-2.5-pro' },
-        { id: 'gemini-2.5-flash', label: 'gemini-2.5-flash' },
-    ],
-    buildArgs: ({ prompt: _prompt, imagePaths: _imagePaths }, { extraAllowedDirs = [], options = {} } = {}) => {
-        const args = ['--output-format', 'stream-json'];
-        if (agentCapabilities.get('gemini')?.skipTrust) {
-            args.push(SKIP_TRUST_FLAG);
-        }
-        // See `RuntimeBuildOptions.permissionMode`'s doc: bypass is the default (unchanged
-        // behavior) unless a caller explicitly opts into a restricted run.
-        if (options.permissionMode !== 'restricted') {
-            args.push('--approval-mode', 'yolo');
-        }
-        if (options.model && options.model !== 'default') {
-            args.push('--model', options.model);
-        }
-        const dirs = (extraAllowedDirs || []).filter((d) => typeof d === 'string' && d.length > 0);
-        for (const d of dirs)
-            args.push('--include-directories', d);
-        return args;
-    },
-    promptViaStdin: true,
-    streamFormat: 'json-event-stream',
-    eventParser: 'gemini',
-    // No `externalMcpInjection` yet: Gemini CLI reads `mcpServers` from `settings.json` (user,
-    // project `.gemini/settings.json`, or a system file named by
-    // `GEMINI_CLI_SYSTEM_SETTINGS_PATH`), with no per-run `--mcp-config` flag. A run-scoped
-    // system-settings file is the likely strategy, but it is not wired or verified live.
-};
-//# sourceMappingURL=gemini.js.map