@jini-ai/agent-runtime 0.3.9 → 0.4.0

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

@@ -107,9 +107,9 @@ export function handleThoughtChunkUpdate({ state, effects, update, }) {
         return;
     if (!state.emittedThinkingStart) {
         state.emittedThinkingStart = true;
-        effects.send('agent', { type: 'thinking_start' });
+        effects.send({ event: 'agent', payload: { type: 'thinking_start' } });
     }
-    effects.send('agent', { type: 'thinking_delta', delta: text });
+    effects.send({ event: 'agent', payload: { type: 'thinking_delta', delta: text } });
 }
 /** Strips tool-call XML from a raw message delta via the session's tool-call text suppressor, noting the suppression reason. */
 export function stripToolCallText({ effects, delta }) {
@@ -251,13 +251,13 @@ export function mirrorArtifactWriteToolEvent({ state, effects, update, toolCallI
     if (!shouldEmit)
         return;
     st.emitted = true;
-    effects.send('agent', {
-        type: 'tool_use',
-        id: toolCallId,
-        name: 'Write',
-        input: { file_path: st.path ?? toolCallId },
-    });
-    effects.send('agent', { type: 'tool_result', toolUseId: toolCallId, isError: failed });
+    effects.send({ event: 'agent', payload: {
+            type: 'tool_use',
+            id: toolCallId,
+            name: 'Write',
+            input: { file_path: st.path ?? toolCallId },
+        } });
+    effects.send({ event: 'agent', payload: { type: 'tool_result', toolUseId: toolCallId, isError: failed } });
     state.emittedConcreteToolEvent = true;
 }
 /** Arms the DSML artifact suppressor when a tool_call/tool_call_update completes an artifact write, or disarms it once its owning write call terminally fails. */
@@ -302,11 +302,11 @@ export function handleSessionUpdate({ state, effects, update, }) {
     if (effects.modelUnavailableErrorCode && tryPromoteAmrRetryStatus({ effects, update }))
         return;
     if (update.sessionUpdate !== 'agent_message_chunk' && update.sessionUpdate !== 'agent_thought_chunk') {
-        effects.send('agent', {
-            type: 'status',
-            label: String(update.sessionUpdate || 'session_update'),
-            elapsedMs: Date.now() - effects.runStartedAt,
-        });
+        effects.send({ event: 'agent', payload: {
+                type: 'status',
+                label: String(update.sessionUpdate || 'session_update'),
+                elapsedMs: Date.now() - effects.runStartedAt,
+            } });
         effects.emitAcpRawShapeDiagnostic(update);
     }
     if (update.sessionUpdate === 'agent_thought_chunk') {
@@ -329,7 +329,7 @@ export function handleInitializeAck({ state, effects }) {
         effects.writeRpc(state.nextId, 'session/load', { sessionId: effects.resumeSessionId, cwd: effects.effectiveCwd }, 'session/load');
     }
     else {
-        effects.writeRpc(state.nextId, 'session/new', buildAcpSessionNewParams(effects.effectiveCwd, effects.mcpServers ? { mcpServers: effects.mcpServers, envFormat: effects.envFormat } : { envFormat: effects.envFormat }), 'session/new');
+        effects.writeRpc(state.nextId, 'session/new', buildAcpSessionNewParams({ cwd: effects.effectiveCwd }, effects.mcpServers ? { mcpServers: effects.mcpServers, envFormat: effects.envFormat } : { envFormat: effects.envFormat }), 'session/new');
     }
     state.nextId += 1;
 }
@@ -358,7 +358,7 @@ export function handleSessionNewAck({ state, effects, result, rawLine, }) {
     state.modelConfigId = resolveModelConfigId(findModelConfigOption(result.configOptions));
     state.activeModel = currentModelFromSessionResult(result);
     if (state.sessionId && state.activeModel) {
-        effects.send('agent', { type: 'status', label: 'model', model: state.activeModel });
+        effects.send({ event: 'agent', payload: { type: 'status', label: 'model', model: state.activeModel } });
     }
     if (triggerSetModelIfNeeded({ state, effects }))
         return;
@@ -403,7 +403,7 @@ export function handleModelSetAck({ state, effects, result, }) {
     // across the function boundary for the type checker (it doesn't survive
     // the call), not a behavior change.
     state.activeModel = currentModelFromSessionResult(result) ?? effects.model;
-    effects.send('agent', { type: 'status', label: 'model', model: state.activeModel });
+    effects.send({ event: 'agent', payload: { type: 'status', label: 'model', model: state.activeModel } });
     effects.sendPrompt();
 }
 /** Top-level JSON-RPC result dispatcher, keyed by which request `expectedId`/`promptRequestId` is currently outstanding. */
@@ -462,13 +462,19 @@ function resolveAcpSessionOptionDefaults(options) {
  * @returns A controller with `hasFatalError`, `getDurableSessionId`,
  *   `completedSuccessfully`, and `abort` methods.
  */
-export function attachAcpSession(options) {
+export function attachAcpSession(requiredArgs, optionalArgs = {}) {
+    const options = { ...optionalArgs, ...requiredArgs };
     const { child, prompt, cwd, model, mcpServers, send, modelUnavailableErrorCode, resumeSessionId, onPermissionRequest, onCliReady, onSessionInit, } = options;
     const { imagePaths, envFormat, clientName, clientVersion, stageTimeoutMs, executionProfile, accountFailureClassifier, } = resolveAcpSessionOptionDefaults(options);
     const runStartedAt = Date.now();
     const effectiveCwd = path.resolve(cwd || process.cwd());
     if (!child.stdin || !child.stdout) {
-        throw new Error('ACP child process must expose stdin and stdout streams');
+        const error = new Error('ACP child process must expose stdin and stdout streams');
+        if (resumeSessionId)
+            Object.assign(error, {
+                details: { kind: 'resume_failed', sessionId: resumeSessionId },
+            });
+        throw error;
     }
     const stdin = child.stdin;
     const stdout = child.stdout;
@@ -531,6 +537,34 @@ export function attachAcpSession(options) {
             value.includes('unknown model') ||
             value.includes('invalid model'));
     };
+    /** Emits a failure, tagging an unacknowledged resume without losing its cause.
+     * The session id is only set by a valid load acknowledgement, so the same
+     * boundary covers initialize/load RPC errors, watchdogs, and transport loss.
+     * Fresh sessions and errors after load keep their existing payloads.
+     * @complexity O(1), excluding the host's event sink.
+     */
+    const sendFailure = ({ payload }) => {
+        if (!resumeSessionId || state.sessionId) {
+            send({ event: 'error', payload });
+            return;
+        }
+        const original = asObject(payload) ?? {};
+        const originalError = asObject(original.error);
+        send({ event: 'error', payload: {
+                ...original,
+                error: {
+                    code: 'AGENT_EXECUTION_FAILED',
+                    message: original.message,
+                    retryable: false,
+                    ...originalError,
+                    details: {
+                        kind: 'resume_failed',
+                        sessionId: resumeSessionId,
+                        ...(originalError?.details === undefined ? {} : { cause: originalError.details }),
+                    },
+                },
+            } });
+    };
     // Both call sites below (the session/update retry-status promotion and the
     // stderr promotion) are already nested inside a scope gated by `finished`
     // at their own entry point (the parser callback's own `if (aborted ||
@@ -540,12 +574,12 @@ export function attachAcpSession(options) {
     // second time once `finished` is true. The origin file carried its own
     // `if (finished) return;` re-entry guard here anyway; removed per this
     // package's coverage-driven dead-branch discipline (verified unreachable
-    // by tracing every call site — see source-map.md), not suppressed.
+    // by tracing every call site — see archived provenance ledger), not suppressed.
     const failWithPayload = (payload) => {
         finished = true;
         fatal = true;
         clearStageTimer();
-        send('error', payload);
+        sendFailure({ payload });
         if (!child.killed)
             child.kill('SIGTERM');
     };
@@ -557,29 +591,29 @@ export function attachAcpSession(options) {
         clearStageTimer();
         const useModelUnavailable = modelUnavailableErrorCode &&
             (options.forceModelUnavailable || isModelUnavailableError(message));
-        send('error', useModelUnavailable
-            ? amrModelUnavailablePayload(message)
-            : options.details === undefined && options.retryable === undefined
-                ? { message }
-                : {
-                    message,
-                    error: {
-                        code: 'AGENT_EXECUTION_FAILED',
+        sendFailure({ payload: useModelUnavailable
+                ? amrModelUnavailablePayload(message)
+                : options.details === undefined && options.retryable === undefined
+                    ? { message }
+                    : {
                         message,
-                        retryable: options.retryable ?? false,
-                        // Every real call site that reaches this branch (the
-                        // RPC-error path and the no-visible-output path) always
-                        // supplies `details` whenever it supplies `retryable`, and
-                        // `retryable` is itself derived from the same `details`
-                        // source at the RPC-error call site — so `options.details`
-                        // is never actually undefined here. Spreading it
-                        // unconditionally (rather than conditionally omitting the
-                        // key) is behaviorally identical for every real caller;
-                        // simplified per this package's coverage-driven
-                        // dead-branch discipline. See source-map.md.
-                        details: options.details,
-                    },
-                });
+                        error: {
+                            code: 'AGENT_EXECUTION_FAILED',
+                            message,
+                            retryable: options.retryable ?? false,
+                            // Every real call site that reaches this branch (the
+                            // RPC-error path and the no-visible-output path) always
+                            // supplies `details` whenever it supplies `retryable`, and
+                            // `retryable` is itself derived from the same `details`
+                            // source at the RPC-error call site — so `options.details`
+                            // is never actually undefined here. Spreading it
+                            // unconditionally (rather than conditionally omitting the
+                            // key) is behaviorally identical for every real caller;
+                            // simplified per this package's coverage-driven
+                            // dead-branch discipline. See archived provenance ledger.
+                            details: options.details,
+                        },
+                    } });
         if (!child.killed)
             child.kill('SIGTERM');
     };
@@ -598,13 +632,13 @@ export function attachAcpSession(options) {
         if (rawAcpShapeDiagnosticCount >= ACP_RAW_EVENT_SHAPE_DIAGNOSTIC_LIMIT)
             return;
         rawAcpShapeDiagnosticCount += 1;
-        send('agent', {
-            type: 'diagnostic',
-            name: 'acp_raw_event_shape',
-            source: 'acp-json-rpc',
-            elapsedMs: Date.now() - runStartedAt,
-            shape: acpRawEventShape(update),
-        });
+        send({ event: 'agent', payload: {
+                type: 'diagnostic',
+                name: 'acp_raw_event_shape',
+                source: 'acp-json-rpc',
+                elapsedMs: Date.now() - runStartedAt,
+                shape: acpRawEventShape(update),
+            } });
     };
     // All three call sites guard against an empty `delta` before calling this
     // (the finishCleanPrompt flush, the `if (outputDelta)` branch, and the
@@ -613,18 +647,18 @@ export function attachAcpSession(options) {
     // origin file's own `if (!delta) return;` guard here can never actually
     // fire. Removed per this package's coverage-driven dead-branch
     // discipline (verified unreachable by tracing every call site — see
-    // source-map.md), not suppressed.
+    // archived provenance ledger), not suppressed.
     const emitVisibleTextDelta = (delta) => {
         state.emittedVisibleTextChunk = true;
         if (!emittedFirstTokenStatus) {
             emittedFirstTokenStatus = true;
-            send('agent', {
-                type: 'status',
-                label: 'streaming',
-                ttftMs: Date.now() - runStartedAt,
-            });
+            send({ event: 'agent', payload: {
+                    type: 'status',
+                    label: 'streaming',
+                    ttftMs: Date.now() - runStartedAt,
+                } });
         }
-        send('agent', { type: 'text_delta', delta });
+        send({ event: 'agent', payload: { type: 'text_delta', delta } });
     };
     const noteArtifactTextSuppression = (reason) => {
         if (!state.dsmlArtifactSuppressor)
@@ -641,42 +675,42 @@ export function attachAcpSession(options) {
         if (artifactSuppressionDiagnosticCount >= ACP_RAW_EVENT_SHAPE_DIAGNOSTIC_LIMIT)
             return;
         artifactSuppressionDiagnosticCount += 1;
-        send('agent', {
-            type: 'diagnostic',
-            name: 'acp_artifact_text_suppression',
-            source: 'acp-json-rpc',
-            elapsedMs: Date.now() - runStartedAt,
-            reason,
-            suppressedChars: artifactTextSuppressionSummary.suppressedChars,
-            suppressedChunks: artifactTextSuppressionSummary.suppressedChunks,
-            openedBlocks: artifactTextSuppressionSummary.openedBlocks,
-            closedBlocks: artifactTextSuppressionSummary.closedBlocks,
-            pendingCandidateChars: stats.pendingCandidateChars,
-            suppressing: stats.suppressing,
-        });
-    };
-    const emitArtifactTextSuppressionSummary = () => {
-        if (artifactTextSuppressionSummary.suppressedChars <= 0)
-            return;
-        if (executionProfile === 'filesystem') {
-            send('agent', {
+        send({ event: 'agent', payload: {
                 type: 'diagnostic',
-                name: 'unexpected_text_artifact_in_filesystem_run',
+                name: 'acp_artifact_text_suppression',
                 source: 'acp-json-rpc',
                 elapsedMs: Date.now() - runStartedAt,
+                reason,
                 suppressedChars: artifactTextSuppressionSummary.suppressedChars,
                 suppressedChunks: artifactTextSuppressionSummary.suppressedChunks,
                 openedBlocks: artifactTextSuppressionSummary.openedBlocks,
                 closedBlocks: artifactTextSuppressionSummary.closedBlocks,
-            });
+                pendingCandidateChars: stats.pendingCandidateChars,
+                suppressing: stats.suppressing,
+            } });
+    };
+    const emitArtifactTextSuppressionSummary = () => {
+        if (artifactTextSuppressionSummary.suppressedChars <= 0)
+            return;
+        if (executionProfile === 'filesystem') {
+            send({ event: 'agent', payload: {
+                    type: 'diagnostic',
+                    name: 'unexpected_text_artifact_in_filesystem_run',
+                    source: 'acp-json-rpc',
+                    elapsedMs: Date.now() - runStartedAt,
+                    suppressedChars: artifactTextSuppressionSummary.suppressedChars,
+                    suppressedChunks: artifactTextSuppressionSummary.suppressedChunks,
+                    openedBlocks: artifactTextSuppressionSummary.openedBlocks,
+                    closedBlocks: artifactTextSuppressionSummary.closedBlocks,
+                } });
         }
-        send('agent', {
-            type: 'diagnostic',
-            name: 'acp_artifact_text_suppression_summary',
-            source: 'acp-json-rpc',
-            elapsedMs: Date.now() - runStartedAt,
-            ...artifactTextSuppressionSummary,
-        });
+        send({ event: 'agent', payload: {
+                type: 'diagnostic',
+                name: 'acp_artifact_text_suppression_summary',
+                source: 'acp-json-rpc',
+                elapsedMs: Date.now() - runStartedAt,
+                ...artifactTextSuppressionSummary,
+            } });
     };
     const noteToolCallTextSuppression = (reason) => {
         const stats = toolCallTextSuppressor.stats();
@@ -691,30 +725,30 @@ export function attachAcpSession(options) {
         if (artifactSuppressionDiagnosticCount >= ACP_RAW_EVENT_SHAPE_DIAGNOSTIC_LIMIT)
             return;
         artifactSuppressionDiagnosticCount += 1;
-        send('agent', {
-            type: 'diagnostic',
-            name: 'acp_tool_call_text_suppression',
-            source: 'acp-json-rpc',
-            elapsedMs: Date.now() - runStartedAt,
-            reason,
-            suppressedChars: toolCallTextSuppressionSummary.suppressedChars,
-            suppressedChunks: toolCallTextSuppressionSummary.suppressedChunks,
-            openedBlocks: toolCallTextSuppressionSummary.openedBlocks,
-            closedBlocks: toolCallTextSuppressionSummary.closedBlocks,
-            pendingCandidateChars: stats.pendingCandidateChars,
-            suppressing: stats.suppressing,
-        });
+        send({ event: 'agent', payload: {
+                type: 'diagnostic',
+                name: 'acp_tool_call_text_suppression',
+                source: 'acp-json-rpc',
+                elapsedMs: Date.now() - runStartedAt,
+                reason,
+                suppressedChars: toolCallTextSuppressionSummary.suppressedChars,
+                suppressedChunks: toolCallTextSuppressionSummary.suppressedChunks,
+                openedBlocks: toolCallTextSuppressionSummary.openedBlocks,
+                closedBlocks: toolCallTextSuppressionSummary.closedBlocks,
+                pendingCandidateChars: stats.pendingCandidateChars,
+                suppressing: stats.suppressing,
+            } });
     };
     const emitToolCallTextSuppressionSummary = () => {
         if (toolCallTextSuppressionSummary.suppressedChars <= 0)
             return;
-        send('agent', {
-            type: 'diagnostic',
-            name: 'acp_tool_call_text_suppression_summary',
-            source: 'acp-json-rpc',
-            elapsedMs: Date.now() - runStartedAt,
-            ...toolCallTextSuppressionSummary,
-        });
+        send({ event: 'agent', payload: {
+                type: 'diagnostic',
+                name: 'acp_tool_call_text_suppression_summary',
+                source: 'acp-json-rpc',
+                elapsedMs: Date.now() - runStartedAt,
+                ...toolCallTextSuppressionSummary,
+            } });
     };
     const sendPrompt = () => {
         state.promptRequestId = state.nextId;
@@ -723,11 +757,11 @@ export function attachAcpSession(options) {
             sessionId: state.sessionId,
             prompt: buildPromptBlocks(prompt, imagePaths),
         }, 'session/prompt');
-        send('agent', {
-            type: 'status',
-            label: 'waiting_for_first_output',
-            elapsedMs: Date.now() - runStartedAt,
-        });
+        send({ event: 'agent', payload: {
+                type: 'status',
+                label: 'waiting_for_first_output',
+                elapsedMs: Date.now() - runStartedAt,
+            } });
         state.nextId += 1;
     };
     // `finishCleanPrompt` has exactly one call site (`handlePromptResult`,
@@ -736,7 +770,7 @@ export function attachAcpSession(options) {
     // (aborted || finished) return;` guard at entry — so this function can
     // never actually be invoked once `finished` is true. The origin file
     // carried its own re-entry guard here anyway; removed per this package's
-    // coverage-driven dead-branch discipline. See source-map.md.
+    // coverage-driven dead-branch discipline. See archived provenance ledger.
     const finishCleanPrompt = (usageSource) => {
         const flushedToolText = toolCallTextSuppressor.flush();
         noteToolCallTextSuppression('tool_call_xml_flush');
@@ -751,11 +785,11 @@ export function attachAcpSession(options) {
         emitArtifactTextSuppressionSummary();
         const usage = formatUsage(usageSource);
         if (usage) {
-            send('agent', {
-                type: 'usage',
-                usage,
-                durationMs: Date.now() - runStartedAt,
-            });
+            send({ event: 'agent', payload: {
+                    type: 'usage',
+                    usage,
+                    durationMs: Date.now() - runStartedAt,
+                } });
         }
         finished = true;
         clearStageTimer();
@@ -827,7 +861,7 @@ export function attachAcpSession(options) {
     const recoverFromModelSelectionError = () => {
         state.setModelRequestId = null;
         state.activeModel = state.activeModel || 'default';
-        send('agent', { type: 'status', label: 'model', model: state.activeModel });
+        send({ event: 'agent', payload: { type: 'status', label: 'model', model: state.activeModel } });
         sendPrompt();
     };
     const effects = {
@@ -853,36 +887,36 @@ export function attachAcpSession(options) {
         mcpServers,
         envFormat,
     };
-    const parser = createJsonLineStream((raw, rawLine) => {
-        if (aborted || finished)
-            return;
-        resetStageTimer('response');
-        const obj = asObject(raw);
-        if (!obj)
-            return;
-        // First well-formed ACP JSON-RPC message = CLI ready. Caller dedupes, so
-        // re-notifying on later messages is harmless.
-        onCliReady?.();
-        const error = asObject(obj.error);
-        const params = asObject(obj.params);
-        const result = asObject(obj.result);
-        const rpcErr = rpcErrorMessage(obj);
-        if (rpcErr) {
-            handleRpcError({ state, effects, obj, error, rpcErr });
-            return;
-        }
-        if (obj.method === 'session/request_permission') {
-            replyPermission(obj);
-            return;
-        }
-        const update = asObject(params?.update);
-        if (obj.method === 'session/update' && update) {
-            handleSessionUpdate({ state, effects, update });
-            return;
-        }
-        routeResultById({ state, effects, obj, result, rawLine });
-    });
-    stdout.on('data', (chunk) => parser.feed(chunk));
+    const parser = createJsonLineStream({ onMessage: ({ message: raw, rawLine }) => {
+            if (aborted || finished)
+                return;
+            resetStageTimer('response');
+            const obj = asObject(raw);
+            if (!obj)
+                return;
+            // First well-formed ACP JSON-RPC message = CLI ready. Caller dedupes, so
+            // re-notifying on later messages is harmless.
+            onCliReady?.();
+            const error = asObject(obj.error);
+            const params = asObject(obj.params);
+            const result = asObject(obj.result);
+            const rpcErr = rpcErrorMessage(obj);
+            if (rpcErr) {
+                handleRpcError({ state, effects, obj, error, rpcErr });
+                return;
+            }
+            if (obj.method === 'session/request_permission') {
+                replyPermission(obj);
+                return;
+            }
+            const update = asObject(params?.update);
+            if (obj.method === 'session/update' && update) {
+                handleSessionUpdate({ state, effects, update });
+                return;
+            }
+            routeResultById({ state, effects, obj, result, rawLine });
+        } });
+    stdout.on('data', (chunk) => parser.feed({ chunk: chunk }));
     child.stderr?.setEncoding('utf8');
     child.stderr?.on('data', (chunk) => {
         if (!modelUnavailableErrorCode || finished)

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 {