@jini-ai/agent-runtime 0.3.10 → 0.4.1

package/dist/agent-protocol/acp/text-suppression.d.ts

@@ -14,7 +14,7 @@
  * dead, unreachable code would force either a contrived test or a
  * coverage-suppression comment to satisfy this package's >=99% bar, and this
  * repo's coverage-discipline convention calls for refactoring dead branches
- * away rather than either of those. See source-map.md.
+ * away rather than either of those. See archived provenance ledger.
  */
 /** A single streamed text delta event, as consumed by `emitWithTextSuppressor`. */
 type EventSink = (event: {

package/dist/agent-protocol/acp/text-suppression.js

@@ -14,7 +14,7 @@
  * dead, unreachable code would force either a contrived test or a
  * coverage-suppression comment to satisfy this package's >=99% bar, and this
  * repo's coverage-discipline convention calls for refactoring dead branches
- * away rather than either of those. See source-map.md.
+ * away rather than either of those. See archived provenance ledger.
  */
 const ARTIFACT_OPEN_RE = /(?:<\s*\|?\s*DSML[\s,]+artifact\b[^>]*>|<\s*artifact\b[^>]*>)/i;
 const DSML_ARTIFACT_CLOSE_RE = /(?:<\/artifact>|<\/\s*\|?\s*DSML\s*>|<\s*\|?\s*\/\s*DSML\s*\|?\s*>)/i;

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

@@ -8,7 +8,8 @@ import type { ChildProcess } from 'node:child_process';
 /** A JSON-RPC 2.0 request or response identifier. May be a numeric integer or a string. */
 export type JsonRpcId = string | number;
 /** An arbitrary JSON object with string keys and unknown values. Used as a loose type for parsed RPC frames. */
-export type JsonObject = Record<string, unknown>;
+/** ACP records may contain unvalidated provider values; this does not assert JSON safety. */
+export type UnknownRecord = Record<string, unknown>;
 /** Minimal writable interface required to send JSON-RPC newline-delimited frames to an ACP agent's stdin. */
 export type RpcWritable = Pick<Writable, 'write' | 'end'>;
 /** The Node `ChildProcess` handle for a spawned ACP agent subprocess. */
@@ -21,7 +22,7 @@ export type TimerHandle = ReturnType<typeof setTimeout>;
  * (`'text_artifact'`). Inlined here rather than imported from an external
  * contracts package — the upstream type is a trivial two-value literal union
  * with no product-specific branding, so importing a whole package for it
- * would be the tail wagging the dog. See source-map.md.
+ * would be the tail wagging the dog. See archived provenance ledger.
  */
 export type ExecutionProfile = 'filesystem' | 'text_artifact';
 //# sourceMappingURL=types.d.ts.map

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

@@ -5,7 +5,7 @@
  * diagnostics. Depends on acp/types, acp/json, and acp/account-failure;
  * consumed exclusively by acp/session.ts.
  */
-import type { JsonObject } from './types.js';
+import type { UnknownRecord } from './types.js';
 import { type AccountFailureClassifier } from './account-failure.js';
 /**
  * Produces a shallow diagnostic snapshot of an ACP update object for the
@@ -17,7 +17,7 @@ import { type AccountFailureClassifier } from './account-failure.js';
  * @param update - A parsed ACP `session/update` params object.
  * @returns A flat diagnostic object suitable for inclusion in an agent event payload.
  */
-export declare function acpRawEventShape(update: JsonObject): {
+export declare function acpRawEventShape(update: UnknownRecord): {
     sessionUpdate: string | null;
     keys: string[];
     contentKind: string;
@@ -42,25 +42,25 @@ export declare function acpRawEventShape(update: JsonObject): {
  *
  * @param update - A parsed ACP `session/update` params object.
  */
-export declare function acpUpdateStatus(update: JsonObject): string;
+export declare function acpUpdateStatus(update: UnknownRecord): string;
 /**
  * Returns `true` when the update's `status` field represents a successful
  * terminal state (`completed`, `complete`, `succeeded`, or `success`).
  * Used to decide when to emit deferred artifact-write tool events.
  */
-export declare function isAcpCompletedStatus(update: JsonObject): boolean;
+export declare function isAcpCompletedStatus(update: UnknownRecord): boolean;
 /**
  * Returns `true` when the update's `status` field represents a terminal
  * failure state (`failed`, `failure`, `error`, `cancelled`, or `canceled`).
  * Used to clean up pending write-suppression state and emit failed tool events.
  */
-export declare function isAcpTerminalFailureStatus(update: JsonObject): boolean;
+export declare function isAcpTerminalFailureStatus(update: UnknownRecord): boolean;
 /**
  * Returns `true` when the update's status is `'retry'`. Signals that the AMR
  * agent wants to restart the request; the session promoter maps this to a
  * structured error payload via `promotedAmrRetryStatusPayload`.
  */
-export declare function isAcpRetryStatus(update: JsonObject): boolean;
+export declare function isAcpRetryStatus(update: UnknownRecord): boolean;
 /**
  * Recursively collects all text-bearing leaf values from an ACP update
  * (strings, numbers, booleans) up to 4 levels deep. Used to produce a flat
@@ -83,7 +83,7 @@ export declare function acpUpdateDiagnosticText(value: unknown, depth?: number):
  *   `noopAccountFailureClassifier`, under which this always returns `null`.
  * @returns A structured error payload with `message` and `error`, or `null`.
  */
-export declare function promotedAmrRetryStatusPayload(update: JsonObject, classifier?: AccountFailureClassifier): {
+export declare function promotedAmrRetryStatusPayload(update: UnknownRecord, classifier?: AccountFailureClassifier): {
     message: string;
     error: {
         code: string;
@@ -129,7 +129,7 @@ export declare function promotedAmrStderrPayload(chunk: string, classifier?: Acc
  *
  * @param update - A parsed ACP `session/update` params object.
  */
-export declare function acpToolCallId(update: JsonObject): string | null;
+export declare function acpToolCallId(update: UnknownRecord): string | null;
 /**
  * Returns `true` when the update's `title` or `name` field contains a word
  * that indicates a file-write operation (`edit`, `write`, `create`, `update`,
@@ -138,7 +138,7 @@ export declare function acpToolCallId(update: JsonObject): string | null;
  *
  * @param update - A parsed ACP `session/update` params object.
  */
-export declare function isAcpArtifactWriteLabel(update: JsonObject): boolean;
+export declare function isAcpArtifactWriteLabel(update: UnknownRecord): boolean;
 /**
  * Returns `true` when an ACP update represents the terminal completion of an
  * artifact-write tool call and should arm the DSML text suppressor. Requires
@@ -148,7 +148,7 @@ export declare function isAcpArtifactWriteLabel(update: JsonObject): boolean;
  * @param update - A parsed ACP `session/update` params object.
  * @param writeToolCallIds - The set of tool call ids identified as artifact writes so far.
  */
-export declare function isAcpArtifactWriteUpdate(update: JsonObject, writeToolCallIds: Set<string>): boolean;
+export declare function isAcpArtifactWriteUpdate(update: UnknownRecord, writeToolCallIds: Set<string>): boolean;
 /**
  * Best-effort extraction of a concrete file path from an ACP artifact-write
  * tool call update, checking three sources in priority order:
@@ -162,5 +162,5 @@ export declare function isAcpArtifactWriteUpdate(update: JsonObject, writeToolCa
  * @param update - A parsed ACP `session/update` params object.
  * @returns An absolute or relative file path string, or `null` when absent.
  */
-export declare function acpArtifactWritePath(update: JsonObject): string | null;
+export declare function acpArtifactWritePath(update: UnknownRecord): string | null;
 //# sourceMappingURL=updates.d.ts.map

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

@@ -130,7 +130,7 @@ export function promotedAmrRetryStatusPayload(update, classifier = noopAccountFa
     if (!isAcpRetryStatus(update))
         return null;
     const diagnosticText = acpUpdateDiagnosticText(update).join('\n');
-    const failure = classifier.classify(diagnosticText);
+    const failure = classifier.classify({ text: diagnosticText });
     if (!failure)
         return null;
     return {
@@ -162,7 +162,7 @@ export function promotedAmrStderrPayload(chunk, classifier = noopAccountFailureC
         return null;
     if (!/\bretry\b/i.test(chunk))
         return null;
-    const failure = classifier.classify(chunk);
+    const failure = classifier.classify({ text: chunk });
     if (!failure)
         return null;
     return {

package/dist/agent-protocol/core/json-line-stream.d.ts

@@ -16,10 +16,19 @@ export interface JsonLineAccumulatorState {
     pendingJson: string;
     pendingJsonLineCount: number;
 }
-export declare function emitJsonLine(candidate: string, onMessage: (message: unknown, rawLine: string) => void): boolean;
-export declare function continuePendingJsonLine(state: JsonLineAccumulatorState, trimmed: string, onMessage: (message: unknown, rawLine: string) => void): void;
+export declare function emitJsonLine(candidate: string, onMessage: (requiredArgs: {
+    message: unknown;
+    rawLine: string;
+}) => void): boolean;
+export declare function continuePendingJsonLine(state: JsonLineAccumulatorState, trimmed: string, onMessage: (requiredArgs: {
+    message: unknown;
+    rawLine: string;
+}) => void): void;
 export declare function tryStartPendingJsonLine(state: JsonLineAccumulatorState, trimmed: string): void;
-export declare function handleJsonLine(state: JsonLineAccumulatorState, line: string, onMessage: (message: unknown, rawLine: string) => void): void;
+export declare function handleJsonLine(state: JsonLineAccumulatorState, line: string, onMessage: (requiredArgs: {
+    message: unknown;
+    rawLine: string;
+}) => void): void;
 /**
  * Creates a streaming JSON-line parser over a raw byte/string stream.
  * Buffers incoming chunks, splits on newline boundaries, and attempts
@@ -30,13 +39,20 @@ export declare function handleJsonLine(state: JsonLineAccumulatorState, line: st
  * Used as the shared ACP transport: both the acp/ and pi-rpc/ adapters call
  * this to decode JSON-RPC frames from a subprocess's stdout.
  *
- * @param onMessage - Called for each successfully parsed JSON value along with
- *   the raw reassembled line string as a second argument.
- * @returns An object with `feed(chunk)` for incremental input and `flush()` to
+ * @param requiredArgs.onMessage - Called with `{ message, rawLine }` for each
+ *   successfully parsed JSON value and its raw reassembled line string.
+ * @returns An object with `feed({ chunk })` for incremental input and `flush()` to
  *   drain any residual buffered content at stream end.
  */
-export declare function createJsonLineStream(onMessage: (message: unknown, rawLine: string) => void): {
-    feed(chunk: string): void;
+export declare function createJsonLineStream({ onMessage }: {
+    onMessage: (requiredArgs: {
+        message: unknown;
+        rawLine: string;
+    }) => void;
+}): {
+    feed({ chunk }: {
+        chunk: string;
+    }): void;
     flush(): void;
 };
 export type JsonObjectScanFrame = {

package/dist/agent-protocol/core/json-line-stream.js

@@ -22,7 +22,7 @@ function resetPendingJson(state) {
 }
 export function emitJsonLine(candidate, onMessage) {
     try {
-        onMessage(JSON.parse(candidate), candidate);
+        onMessage({ message: JSON.parse(candidate), rawLine: candidate });
         return true;
     }
     catch {
@@ -81,16 +81,16 @@ export function handleJsonLine(state, line, onMessage) {
  * Used as the shared ACP transport: both the acp/ and pi-rpc/ adapters call
  * this to decode JSON-RPC frames from a subprocess's stdout.
  *
- * @param onMessage - Called for each successfully parsed JSON value along with
- *   the raw reassembled line string as a second argument.
- * @returns An object with `feed(chunk)` for incremental input and `flush()` to
+ * @param requiredArgs.onMessage - Called with `{ message, rawLine }` for each
+ *   successfully parsed JSON value and its raw reassembled line string.
+ * @returns An object with `feed({ chunk })` for incremental input and `flush()` to
  *   drain any residual buffered content at stream end.
  */
-export function createJsonLineStream(onMessage) {
+export function createJsonLineStream({ onMessage }) {
     let buffer = '';
     const state = { pendingJson: '', pendingJsonLineCount: 0 };
     return {
-        feed(chunk) {
+        feed({ chunk }) {
             buffer += chunk;
             const lines = buffer.split('\n');
             buffer = lines.pop() || '';
@@ -114,7 +114,7 @@ export function createJsonLineStream(onMessage) {
             // a defensive `if (pendingJson && emit(pendingJson)) { pendingJson =
             // '' }` here that was provably dead code; removed per this package's
             // coverage-driven dead-branch discipline rather than left uncovered or
-            // suppressed. See source-map.md.
+            // suppressed. See archived provenance ledger.
             // Ignore trailing non-JSON log lines on stdout.
         },
     };
@@ -136,7 +136,7 @@ export function afterValue(state) {
 // guard was provably dead (verified by a 2M-trial adversarial fuzz,
 // including deliberately malformed bracket sequences, finding zero
 // mismatches) and is removed here per this package's coverage-driven
-// dead-branch discipline. See source-map.md.
+// dead-branch discipline. See archived provenance ledger.
 function closeFrame(state) {
     state.stack.pop();
     afterValue(state);

package/dist/agent-protocol/pi-rpc/events.d.ts

@@ -43,5 +43,9 @@ export declare function handleAutoRetryEnd(raw: JsonRecord, send: SendAgentEvent
  * @param ctx  - Per-run context: start timestamp and first-token sentinel.
  * @returns `'agent_end'` on run completion, `null` otherwise.
  */
-export declare function mapPiRpcEvent(raw: JsonRecord, send: SendAgentEvent, ctx: PiRpcContext): 'agent_end' | null;
+export declare function mapPiRpcEvent({ raw, send, ctx }: {
+    raw: JsonRecord;
+    send: SendAgentEvent;
+    ctx: PiRpcContext;
+}): 'agent_end' | null;
 //# sourceMappingURL=events.d.ts.map

package/dist/agent-protocol/pi-rpc/events.js

@@ -1,13 +1,13 @@
 import { getRecord } from './internal.js';
 export function handleAgentStart(_raw, send) {
-    send('agent', { type: 'status', label: 'working' });
+    send({ event: 'agent', payload: { type: 'status', label: 'working' } });
     return null;
 }
 export function handleAgentEnd() {
     return 'agent_end';
 }
 export function handleTurnStart(_raw, send) {
-    send('agent', { type: 'status', label: 'thinking' });
+    send({ event: 'agent', payload: { type: 'status', label: 'thinking' } });
     return null;
 }
 /** Extracts the subset of pi's `message.usage` fields the daemon reports as token usage. */
@@ -30,12 +30,12 @@ export function emitTurnEndUsage(u, send, ctx) {
     if (Object.keys(usage).length === 0)
         return;
     const cost = getRecord(u.cost);
-    send('agent', {
-        type: 'usage',
-        usage,
-        costUsd: cost?.total ?? cost?.totalCost ?? null,
-        durationMs: Date.now() - ctx.runStartedAt,
-    });
+    send({ event: 'agent', payload: {
+            type: 'usage',
+            usage,
+            costUsd: cost?.total ?? cost?.totalCost ?? null,
+            durationMs: Date.now() - ctx.runStartedAt,
+        } });
 }
 export function emitTurnEndErrorIfPresent(message, raw, send) {
     if (message?.stopReason !== 'error')
@@ -43,7 +43,7 @@ export function emitTurnEndErrorIfPresent(message, raw, send) {
     const messageText = typeof message.errorMessage === 'string' && message.errorMessage.length > 0
         ? message.errorMessage
         : 'Pi agent error';
-    send('agent', { type: 'error', message: messageText, raw });
+    send({ event: 'agent', payload: { type: 'error', message: messageText, raw } });
 }
 export function handleTurnEnd(raw, send, ctx) {
     const message = getRecord(raw.message);
@@ -58,24 +58,24 @@ export function handleAssistantTextDelta(ev, send, ctx) {
         return;
     if (!ctx.sentFirstToken.value) {
         ctx.sentFirstToken.value = true;
-        send('agent', {
-            type: 'status',
-            label: 'streaming',
-            ttftMs: Date.now() - ctx.runStartedAt,
-        });
+        send({ event: 'agent', payload: {
+                type: 'status',
+                label: 'streaming',
+                ttftMs: Date.now() - ctx.runStartedAt,
+            } });
     }
-    send('agent', { type: 'text_delta', delta: ev.delta });
+    send({ event: 'agent', payload: { type: 'text_delta', delta: ev.delta } });
 }
 export function handleAssistantThinkingDelta(ev, send) {
     if (typeof ev.delta !== 'string')
         return;
-    send('agent', { type: 'thinking_delta', delta: ev.delta });
+    send({ event: 'agent', payload: { type: 'thinking_delta', delta: ev.delta } });
 }
 export function handleAssistantThinkingStart(_ev, send) {
-    send('agent', { type: 'thinking_start' });
+    send({ event: 'agent', payload: { type: 'thinking_start' } });
 }
 export function handleAssistantThinkingEnd(_ev, send) {
-    send('agent', { type: 'thinking_end' });
+    send({ event: 'agent', payload: { type: 'thinking_end' } });
 }
 // pi's RPC protocol emits a message_update with error delta when
 // the model returns an error (e.g. aborted, context overflow).
@@ -87,7 +87,7 @@ export function handleAssistantError(ev, send, _ctx, raw) {
         : typeof ev.delta === 'string' && ev.delta.length > 0
             ? ev.delta
             : 'Agent error';
-    send('agent', { type: 'error', message, raw });
+    send({ event: 'agent', payload: { type: 'error', message, raw } });
 }
 const ASSISTANT_MESSAGE_EVENT_HANDLERS = {
     text_delta: handleAssistantTextDelta,
@@ -112,12 +112,12 @@ export function handleMessageEnd() {
     return null;
 }
 export function handleToolExecutionStart(raw, send) {
-    send('agent', {
-        type: 'tool_use',
-        id: raw.toolCallId ?? null,
-        name: raw.toolName ?? null,
-        input: raw.args ?? null,
-    });
+    send({ event: 'agent', payload: {
+            type: 'tool_use',
+            id: raw.toolCallId ?? null,
+            name: raw.toolName ?? null,
+            input: raw.args ?? null,
+        } });
     return null;
 }
 export function handleToolExecutionEnd(raw, send) {
@@ -133,12 +133,12 @@ export function handleToolExecutionEnd(raw, send) {
         : typeof content === 'string'
             ? content
             : '';
-    send('agent', {
-        type: 'tool_result',
-        toolUseId: raw.toolCallId ?? null,
-        content: text,
-        isError: raw.isError === true,
-    });
+    send({ event: 'agent', payload: {
+            type: 'tool_result',
+            toolUseId: raw.toolCallId ?? null,
+            content: text,
+            isError: raw.isError === true,
+        } });
     return null;
 }
 // pi's RPC protocol can emit `extension_error` when an extension
@@ -149,15 +149,15 @@ export function handleExtensionError(raw, send) {
     const message = typeof raw.error === 'string' && raw.error.length > 0
         ? raw.error
         : 'Extension error';
-    send('agent', { type: 'error', message, raw });
+    send({ event: 'agent', payload: { type: 'error', message, raw } });
     return null;
 }
 export function handleCompactionStart(_raw, send) {
-    send('agent', { type: 'status', label: 'compacting' });
+    send({ event: 'agent', payload: { type: 'status', label: 'compacting' } });
     return null;
 }
 export function handleAutoRetryStart(_raw, send) {
-    send('agent', { type: 'status', label: 'retrying' });
+    send({ event: 'agent', payload: { type: 'status', label: 'retrying' } });
     return null;
 }
 export function handleAutoRetryEnd(raw, send) {
@@ -169,7 +169,7 @@ export function handleAutoRetryEnd(raw, send) {
     const message = typeof raw.finalError === 'string' && raw.finalError.length > 0
         ? raw.finalError
         : 'Auto-retry exhausted';
-    send('agent', { type: 'error', message, raw });
+    send({ event: 'agent', payload: { type: 'error', message, raw } });
     return null;
 }
 const PI_RPC_EVENT_HANDLERS = {
@@ -196,7 +196,7 @@ const PI_RPC_EVENT_HANDLERS = {
  * @param ctx  - Per-run context: start timestamp and first-token sentinel.
  * @returns `'agent_end'` on run completion, `null` otherwise.
  */
-export function mapPiRpcEvent(raw, send, ctx) {
+export function mapPiRpcEvent({ raw, send, ctx }) {
     const handler = typeof raw.type === 'string' ? PI_RPC_EVENT_HANDLERS[raw.type] : undefined;
     return handler ? handler(raw, send, ctx) : null;
 }

package/dist/agent-protocol/pi-rpc/internal.d.ts

@@ -6,7 +6,10 @@
 /** A plain JSON object — the base payload type for pi RPC messages. */
 export type JsonRecord = Record<string, unknown>;
 /** Callback signature for forwarding a typed event to the daemon's SSE layer. */
-export type SendAgentEvent = (channel: string, payload: JsonRecord) => void;
+export type SendAgentEvent = (requiredArgs: {
+    event: string;
+    payload: JsonRecord;
+}) => void;
 /** Optional token-count fields surfaced by pi's RPC protocol on turn completion. */
 export type TokenUsage = {
     input_tokens?: number;

package/dist/agent-protocol/pi-rpc/models.d.ts

@@ -17,5 +17,7 @@ export type PiModelOption = {
  * @param stdout - Raw stdout captured from `pi --list-models`, as a string or Buffer.
  * @returns Parsed model array (at least 2 entries), or `null` when nothing is found.
  */
-export declare function parsePiModels(stdout: unknown): PiModelOption[] | null;
+export declare function parsePiModels({ stdout }: {
+    stdout: unknown;
+}): PiModelOption[] | null;
 //# sourceMappingURL=models.d.ts.map

package/dist/agent-protocol/pi-rpc/models.js

@@ -12,7 +12,7 @@
  * @param stdout - Raw stdout captured from `pi --list-models`, as a string or Buffer.
  * @returns Parsed model array (at least 2 entries), or `null` when nothing is found.
  */
-export function parsePiModels(stdout) {
+export function parsePiModels({ stdout }) {
     const lines = String(stdout || '')
         .split('\n')
         .map((l) => l.trim())

package/dist/agent-protocol/pi-rpc/session.d.ts

@@ -141,5 +141,5 @@ export declare function handlePiResponseMessage({ raw, parentSessionRpcId, promp
  *                  parent session path for conversation resume.
  * @returns A `PiRpcSession` handle with `hasFatalError`, `getLastSessionPath`, and `abort`.
  */
-export declare function attachPiRpcSession({ child, prompt, cwd, model, send, imagePaths, uploadRoot, parentSession, }: PiRpcSessionOptions): PiRpcSession;
+export declare function attachPiRpcSession(requiredArgs: Pick<PiRpcSessionOptions, "child" | "prompt" | "send">, optionalArgs?: Omit<PiRpcSessionOptions, "child" | "prompt" | "send">): PiRpcSession;
 //# sourceMappingURL=session.d.ts.map

package/dist/agent-protocol/pi-rpc/session.js

@@ -247,7 +247,8 @@ export function handlePiResponseMessage({ raw, parentSessionRpcId, promptRpcId,
  *                  parent session path for conversation resume.
  * @returns A `PiRpcSession` handle with `hasFatalError`, `getLastSessionPath`, and `abort`.
  */
-export function attachPiRpcSession({ child, prompt, cwd, model, send, imagePaths, uploadRoot, parentSession, }) {
+export function attachPiRpcSession(requiredArgs, optionalArgs = {}) {
+    const { child, prompt, cwd, model, send, imagePaths, uploadRoot, parentSession, } = { ...optionalArgs, ...requiredArgs };
     const stdin = child.stdin;
     const stdout = child.stdout;
     if (stdin === null) {
@@ -281,17 +282,17 @@ export function attachPiRpcSession({ child, prompt, cwd, model, send, imagePaths
             return;
         finished = true;
         fatal = true;
-        send('error', { message, ...(code ? { code } : {}) });
+        send({ event: 'error', payload: { message, ...(code ? { code } : {}) } });
         if (!child.killed)
             child.kill('SIGTERM');
     };
     // Emit initial status with model name immediately — before pi even
     // responds — so the UI header shows the model name at session start.
-    send('agent', {
-        type: 'status',
-        label: 'initializing',
-        model: typeof model === 'string' && model ? model : null,
-    });
+    send({ event: 'agent', payload: {
+            type: 'status',
+            label: 'initializing',
+            model: typeof model === 'string' && model ? model : null,
+        } });
     // ---- Outbound: send new_session (if parentSession provided) then prompt via RPC ----
     stdin.on('error', (err) => {
         if (errorCode(err) !== 'EPIPE') {
@@ -351,33 +352,33 @@ export function attachPiRpcSession({ child, prompt, cwd, model, send, imagePaths
         }, shutdownMs);
     };
     // ---- Inbound: parse stdout events ----
-    const parser = createJsonLineStream((raw) => {
-        if (!isRecord(raw))
-            return;
-        // Once finished (agent_end or abort), stop processing — the run is
-        // over, so no more agent events should be emitted. We still drain
-        // stdout via parser.feed() so the pipe doesn't break; we just skip
-        // acting on the parsed objects.
-        if (finished)
-            return;
-        // Extension UI requests: auto-resolve to keep pi unblocked.
-        if (raw.type === 'extension_ui_request') {
-            replyExtensionUi(stdin, raw);
-            return;
-        }
-        if (raw.type === 'response') {
-            handlePiResponseMessage({ raw, parentSessionRpcId, promptRpcId, fail, sendPromptCommand });
-            return;
-        }
-        // Agent events: delegate to the pure mapper.
-        const result = mapPiRpcEvent(raw, send, { runStartedAt, sentFirstToken });
-        if (result === 'agent_end') {
-            handlePiAgentEnd();
-        }
-    });
+    const parser = createJsonLineStream({ onMessage: ({ message: raw }) => {
+            if (!isRecord(raw))
+                return;
+            // Once finished (agent_end or abort), stop processing — the run is
+            // over, so no more agent events should be emitted. We still drain
+            // stdout via parser.feed() so the pipe doesn't break; we just skip
+            // acting on the parsed objects.
+            if (finished)
+                return;
+            // Extension UI requests: auto-resolve to keep pi unblocked.
+            if (raw.type === 'extension_ui_request') {
+                replyExtensionUi(stdin, raw);
+                return;
+            }
+            if (raw.type === 'response') {
+                handlePiResponseMessage({ raw, parentSessionRpcId, promptRpcId, fail, sendPromptCommand });
+                return;
+            }
+            // Agent events: delegate to the pure mapper.
+            const result = mapPiRpcEvent({ raw: raw, send: send, ctx: { runStartedAt, sentFirstToken } });
+            if (result === 'agent_end') {
+                handlePiAgentEnd();
+            }
+        } });
     stdout.on('data', (chunk) => {
         try {
-            parser.feed(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+            parser.feed({ chunk: typeof chunk === 'string' ? chunk : chunk.toString('utf8') });
         }
         catch (err) {
             fail(`parser: ${errorMessage(err)}`);

package/dist/amr-model-cache.d.ts

@@ -26,11 +26,19 @@ type Fetchers = {
     fetchRemote: () => Promise<RuntimeModelOption[]>;
 };
 export declare class AmrModelLoadingCache {
-    private readonly refreshIntervalMs;
     private readonly states;
-    constructor(refreshIntervalMs?: number);
-    get(cacheKey: string, fetchers: Fetchers): Promise<AmrModelsResponse>;
-    warm(cacheKey: string, fetchRemote: () => Promise<RuntimeModelOption[]>): void;
+    private readonly refreshIntervalMs;
+    constructor(_requiredArgs?: Record<string, never>, { refreshIntervalMs }?: {
+        refreshIntervalMs?: number;
+    });
+    get({ cacheKey, fetchers }: {
+        cacheKey: string;
+        fetchers: Fetchers;
+    }): Promise<AmrModelsResponse>;
+    warm({ cacheKey, fetchRemote }: {
+        cacheKey: string;
+        fetchRemote: () => Promise<RuntimeModelOption[]>;
+    }): void;
     resetForTests(): void;
     private stateFor;
     private startRefresh;

package/dist/amr-model-cache.js

@@ -1,3 +1,4 @@
+import { coalesceModelLoad } from './model-loading-state.js';
 // The AMR model catalog changes rarely (new models land on the order of
 // days), and a cached remote list is returned immediately while a refresh
 // runs in the background — `get()` never blocks on the network when a
@@ -11,12 +12,12 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error ?? 'unknown error');
 }
 export class AmrModelLoadingCache {
-    refreshIntervalMs;
     states = new Map();
-    constructor(refreshIntervalMs = DEFAULT_REMOTE_REFRESH_INTERVAL_MS) {
+    refreshIntervalMs;
+    constructor(_requiredArgs = {}, { refreshIntervalMs = DEFAULT_REMOTE_REFRESH_INTERVAL_MS } = {}) {
         this.refreshIntervalMs = refreshIntervalMs;
     }
-    async get(cacheKey, fetchers) {
+    async get({ cacheKey, fetchers }) {
         const state = this.stateFor(cacheKey);
         const now = Date.now();
         if (state.remote) {
@@ -40,7 +41,7 @@ export class AmrModelLoadingCache {
             ...(state.lastRemoteError ? { remoteError: state.lastRemoteError } : {}),
         };
     }
-    warm(cacheKey, fetchRemote) {
+    warm({ cacheKey, fetchRemote }) {
         this.startRefresh(this.stateFor(cacheKey), fetchRemote);
     }
     resetForTests() {
@@ -55,24 +56,19 @@ export class AmrModelLoadingCache {
         return created;
     }
     startRefresh(state, fetchRemote) {
-        if (state.inFlight)
-            return;
-        state.inFlight = (async () => {
-            try {
-                const models = await fetchRemote();
-                if (models.length === 0) {
-                    throw new Error('AMR remote model list returned no chat models');
+        void coalesceModelLoad({ state, load: async () => {
+                try {
+                    const models = await fetchRemote();
+                    if (models.length === 0) {
+                        throw new Error('AMR remote model list returned no chat models');
+                    }
+                    state.remote = { models, fetchedAt: Date.now() };
+                    state.lastRemoteError = null;
+                }
+                catch (error) {
+                    state.lastRemoteError = errorMessage(error);
                 }
-                state.remote = { models, fetchedAt: Date.now() };
-                state.lastRemoteError = null;
-            }
-            catch (error) {
-                state.lastRemoteError = errorMessage(error);
-            }
-            finally {
-                state.inFlight = null;
-            }
-        })();
+            } });
     }
 }
 export const amrModelLoadingCache = new AmrModelLoadingCache();