@automatalabs/acp-agents 2.0.0 → 3.0.0

package/dist/agent/errors.d.ts

@@ -2,12 +2,22 @@ import { WorkflowError } from "@automatalabs/shared-types";
 import { type ErrorMapContext } from "../errors-map.js";
 import type { TypedSessionFailure } from "../typed-failures.js";
 import type { AcpAgentTurn, AcpAgentTurnError } from "./types.js";
-/** A deterministic caller error (bad option, misuse): SCRIPT_VALIDATION_ERROR, non-recoverable. */
+/** A deterministic caller error (bad option, misuse): INVALID_ARGUMENT, non-recoverable. */
 export declare function agentValidationError(message: string, label?: string): WorkflowError;
 /** Every method except `close()`/`cancel()`/getters after the agent closed, aborted, or its process died. */
 export declare function agentClosedError(label: string | undefined, backendId: string, detail?: string): WorkflowError;
+/** Re-code a shared validator's SCRIPT_VALIDATION_ERROR as the SDK's INVALID_ARGUMENT, keeping the
+ *  message, `recoverable=false`, `agentLabel`, and `details`. Anything else is returned untouched
+ *  — the runner and `InteractiveSession` keep SCRIPT_VALIDATION_ERROR; only the AcpAgent boundary
+ *  speaks INVALID_ARGUMENT. */
+export declare function asAgentArgumentError(error: unknown): unknown;
+/** Run a synchronous validation block; a shared validator's SCRIPT_VALIDATION_ERROR surfaces as
+ *  INVALID_ARGUMENT, everything else propagates as thrown. */
+export declare function validateArguments<T>(validate: () => T): T;
 /** Map a thrown wire/lifecycle error onto the seam contract — unless `signal` aborted, in which
- *  case the error is returned untouched so the caller can rethrow `signal.reason` itself. */
+ *  case the error is returned untouched so the caller can rethrow `signal.reason` itself. A
+ *  validation error the client raised on the agent's behalf (mode selection, a lifecycle
+ *  capability the agent does not advertise) is re-coded as INVALID_ARGUMENT. */
 export declare function mapAgentError(error: unknown, ctx: ErrorMapContext, signal?: AbortSignal): unknown;
 /** The `prompt()` rejection for a walled turn: `mapTypedSessionFailure` (codes/recoverable/details
  *  unchanged) with the complete `AcpAgentTurn` attached as `error.turn`. */

package/dist/agent/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/agent/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAsC,MAAM,4BAA4B,CAAC;AAC/F,OAAO,EAA0C,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAChG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAElE,mGAAmG;AACnG,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa,CAKnF;AAED,6GAA6G;AAC7G,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,CAM7G;AAED;6FAC6F;AAC7F,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAGjG;AAED;4EAC4E;AAC5E,wBAAgB,cAAc,CAC5B,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,eAAe,GACnB,iBAAiB,CAInB;AAED,8FAA8F;AAC9F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAM9E"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/agent/errors.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,aAAa,EAAsC,MAAM,4BAA4B,CAAC;AAC/F,OAAO,EAA0C,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAChG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAElE,4FAA4F;AAC5F,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa,CAKnF;AAED,6GAA6G;AAC7G,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,CAM7G;AAED;;;+BAG+B;AAC/B,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAO5D;AAED;8DAC8D;AAC9D,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAMzD;AAED;;;gFAGgF;AAChF,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAGjG;AAED;4EAC4E;AAC5E,wBAAgB,cAAc,CAC5B,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,eAAe,GACnB,iBAAiB,CAInB;AAED,8FAA8F;AAC9F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAM9E"}

package/dist/agent/errors.js

@@ -1,26 +1,55 @@
-// AcpAgent error helpers: SDK misuse is uniformly a WorkflowError(SCRIPT_VALIDATION_ERROR); wire
-// failures go through the same `mapThrownError` ladder the runner uses; an abort is never mapped
-// (the affected promise rejects with `signal.reason` untouched); a typed session failure rejects
-// with the runner's mapped error carrying the complete turn.
+// AcpAgent error helpers: SDK misuse is uniformly a WorkflowError(INVALID_ARGUMENT) — the SDK's
+// own guards raise it directly, and a shared validator's SCRIPT_VALIDATION_ERROR (cwd, the reserved
+// "model" config id, the registry, client handlers, systemPrompt support, prompt images, the
+// client's mode-selection and lifecycle-capability gates) is re-coded at the agent boundary with
+// its message, `recoverable=false`, `agentLabel`, and `details` preserved; wire failures go through
+// the same `mapThrownError` ladder the runner uses; an abort is never mapped (the affected promise
+// rejects with `signal.reason` untouched); a typed session failure rejects with the runner's
+// mapped error carrying the complete turn.
 import { WorkflowError, WorkflowErrorCode, isWorkflowError } from "@automatalabs/shared-types";
 import { mapThrownError, mapTypedSessionFailure } from "../errors-map.js";
-/** A deterministic caller error (bad option, misuse): SCRIPT_VALIDATION_ERROR, non-recoverable. */
+/** A deterministic caller error (bad option, misuse): INVALID_ARGUMENT, non-recoverable. */
 export function agentValidationError(message, label) {
-    return new WorkflowError(message, WorkflowErrorCode.SCRIPT_VALIDATION_ERROR, {
+    return new WorkflowError(message, WorkflowErrorCode.INVALID_ARGUMENT, {
         recoverable: false,
         agentLabel: label,
     });
 }
 /** Every method except `close()`/`cancel()`/getters after the agent closed, aborted, or its process died. */
 export function agentClosedError(label, backendId, detail) {
-    return new WorkflowError(`AcpAgent (${backendId}) is closed${detail ? `: ${detail}` : ""}`, WorkflowErrorCode.SCRIPT_VALIDATION_ERROR, { recoverable: false, agentLabel: label });
+    return new WorkflowError(`AcpAgent (${backendId}) is closed${detail ? `: ${detail}` : ""}`, WorkflowErrorCode.INVALID_ARGUMENT, { recoverable: false, agentLabel: label });
+}
+/** Re-code a shared validator's SCRIPT_VALIDATION_ERROR as the SDK's INVALID_ARGUMENT, keeping the
+ *  message, `recoverable=false`, `agentLabel`, and `details`. Anything else is returned untouched
+ *  — the runner and `InteractiveSession` keep SCRIPT_VALIDATION_ERROR; only the AcpAgent boundary
+ *  speaks INVALID_ARGUMENT. */
+export function asAgentArgumentError(error) {
+    if (!isWorkflowError(error) || error.code !== WorkflowErrorCode.SCRIPT_VALIDATION_ERROR)
+        return error;
+    return new WorkflowError(error.message, WorkflowErrorCode.INVALID_ARGUMENT, {
+        recoverable: false,
+        agentLabel: error.agentLabel,
+        details: error.details,
+    });
+}
+/** Run a synchronous validation block; a shared validator's SCRIPT_VALIDATION_ERROR surfaces as
+ *  INVALID_ARGUMENT, everything else propagates as thrown. */
+export function validateArguments(validate) {
+    try {
+        return validate();
+    }
+    catch (error) {
+        throw asAgentArgumentError(error);
+    }
 }
 /** Map a thrown wire/lifecycle error onto the seam contract — unless `signal` aborted, in which
- *  case the error is returned untouched so the caller can rethrow `signal.reason` itself. */
+ *  case the error is returned untouched so the caller can rethrow `signal.reason` itself. A
+ *  validation error the client raised on the agent's behalf (mode selection, a lifecycle
+ *  capability the agent does not advertise) is re-coded as INVALID_ARGUMENT. */
 export function mapAgentError(error, ctx, signal) {
     if (signal?.aborted)
         return error;
-    return mapThrownError(error, ctx);
+    return asAgentArgumentError(mapThrownError(error, ctx));
 }
 /** The `prompt()` rejection for a walled turn: `mapTypedSessionFailure` (codes/recoverable/details
  *  unchanged) with the complete `AcpAgentTurn` attached as `error.turn`. */

package/dist/agent/fork.d.ts

@@ -1,4 +1,4 @@
-import type { AcpSessionOptions, PooledConnection, SessionHandle } from "../acp-client.js";
+import type { AcpSessionOptions, PooledConnection, ReattachPreference, SessionHandle } from "../acp-client.js";
 import type { Backend } from "../backend.js";
 import { type ForkSessionTraitRow } from "../protocol-coverage.js";
 import type { BackendRegistry } from "../registry.js";
@@ -18,10 +18,12 @@ export interface AcquiredFork {
  *   - `live`: the fork response IS the session.
  *   - `id-only`: the response names a persisted copy that is not live; release the fork handle
  *     with `keepOpen` (unregister only — no `session/close`, so the reattach's `register()` never
- *     replaces a live state and the slot count stays at one), then reattach it (resume preferred,
- *     load fallback). The catalog/modes come from the reattach response; the bare fork response is
- *     never read for them.
+ *     replaces a live state and the slot count stays at one), then reattach it by `reattach` —
+ *     `resume` preferred with `load` as the fallback (the live `agent.fork()`, whose child is
+ *     seeded from the parent's snapshot), or `load` preferred with `resume` as the fallback (the
+ *     cold `AcpAgent.fork(ref)`, which has no parent to seed from and wants the replay). The
+ *     catalog/modes come from the reattach response; the bare fork response is never read for them.
  * `prepare` is re-evaluated for the reattach so it sees the same options the fork carried.
  */
-export declare function acquireForkedSession(connection: PooledConnection, sourceSessionId: string, opts: AcpSessionOptions, trait: ForkSessionTraitRow): Promise<AcquiredFork>;
+export declare function acquireForkedSession(connection: PooledConnection, sourceSessionId: string, opts: AcpSessionOptions, trait: ForkSessionTraitRow, reattach?: ReattachPreference): Promise<AcquiredFork>;
 //# sourceMappingURL=fork.d.ts.map

package/dist/agent/fork.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fork.d.ts","sourceRoot":"","sources":["../../src/agent/fork.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC3F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAoB,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACrF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEtD;;0FAE0F;AAC1F,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,eAAe,GAAG,mBAAmB,CAG7F;AAED,MAAM,WAAW,YAAY;IAC3B,+FAA+F;IAC/F,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC7C;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,gBAAgB,EAC5B,eAAe,EAAE,MAAM,EACvB,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,YAAY,CAAC,CAOvB"}
+{"version":3,"file":"fork.d.ts","sourceRoot":"","sources":["../../src/agent/fork.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC/G,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAoB,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACrF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEtD;;0FAE0F;AAC1F,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,eAAe,GAAG,mBAAmB,CAG7F;AAED,MAAM,WAAW,YAAY;IAC3B,+FAA+F;IAC/F,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC7C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,gBAAgB,EAC5B,eAAe,EAAE,MAAM,EACvB,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,mBAAmB,EAC1B,QAAQ,GAAE,kBAA6B,GACtC,OAAO,CAAC,YAAY,CAAC,CAOvB"}

package/dist/agent/fork.js

@@ -12,17 +12,19 @@ export function forkTraitFor(backend, registry) {
  *   - `live`: the fork response IS the session.
  *   - `id-only`: the response names a persisted copy that is not live; release the fork handle
  *     with `keepOpen` (unregister only — no `session/close`, so the reattach's `register()` never
- *     replaces a live state and the slot count stays at one), then reattach it (resume preferred,
- *     load fallback). The catalog/modes come from the reattach response; the bare fork response is
- *     never read for them.
+ *     replaces a live state and the slot count stays at one), then reattach it by `reattach` —
+ *     `resume` preferred with `load` as the fallback (the live `agent.fork()`, whose child is
+ *     seeded from the parent's snapshot), or `load` preferred with `resume` as the fallback (the
+ *     cold `AcpAgent.fork(ref)`, which has no parent to seed from and wants the replay). The
+ *     catalog/modes come from the reattach response; the bare fork response is never read for them.
  * `prepare` is re-evaluated for the reattach so it sees the same options the fork carried.
  */
-export async function acquireForkedSession(connection, sourceSessionId, opts, trait) {
+export async function acquireForkedSession(connection, sourceSessionId, opts, trait, reattach = "resume") {
     const forkHandle = await connection.forkSession(sourceSessionId, opts);
     if (trait.disposition !== "id-only")
         return { handle: forkHandle, method: "fork" };
     const forkedId = forkHandle.sessionId;
     await forkHandle.release({ keepOpen: true });
-    const { handle, method } = await connection.openPreparedReattachedSession(forkedId, () => opts);
+    const { handle, method } = await connection.openPreparedReattachedSession(forkedId, () => opts, undefined, reattach);
     return { handle, method };
 }

package/dist/agent/messages.d.ts

@@ -0,0 +1,42 @@
+import type { ToolCallContent, ToolCallLocation, ToolCallStatus, ToolKind } from "@agentclientprotocol/sdk";
+import type { AcpSessionUpdate } from "../events.js";
+import type { AcpAgentMessage, AcpAgentToolCall, AcpAgentUpdateRecord } from "./types.js";
+export interface MutableToolCall {
+    toolCallId: string;
+    name?: string;
+    title: string;
+    kind?: ToolKind;
+    status: ToolCallStatus;
+    rawInput?: unknown;
+    rawOutput?: unknown;
+    content?: ToolCallContent[];
+    locations?: ToolCallLocation[];
+    meta?: Record<string, unknown>;
+}
+type ToolCallUpdate = Extract<AcpSessionUpdate, {
+    sessionUpdate: "tool_call" | "tool_call_update";
+}>;
+/** Fold one `tool_call` / `tool_call_update` into `existing` (a fresh entry when undefined):
+ *  every field the update carries replaces the last seen one, `_meta` merges shallowly, and
+ *  `status` stays `pending` until the agent sends one. */
+export declare function foldToolCall(existing: MutableToolCall | undefined, update: ToolCallUpdate): MutableToolCall;
+/** A fresh, shallow copy of a message (blocks and tool calls copied one level deep). */
+export declare function copyMessage(message: AcpAgentMessage): AcpAgentMessage;
+export declare class MessageFolder {
+    #private;
+    /** Mirror `SessionState.beginTurn()`: a boundary, no message in progress, and — like the
+     *  accumulator under `retainSessionLog: false` — a cleared transcript when `retain` is false.
+     *  A thought left over from the previous turn becomes its own assistant message first. */
+    beginTurn(retain: boolean): void;
+    apply(update: AcpSessionUpdate, receivedAt: number): void;
+    /** Every folded tool call in first-seen order (copies) — the flattening of the messages'
+     *  `toolCalls`, which is the same order because a call attaches to the message in progress. */
+    get toolCalls(): AcpAgentToolCall[];
+    /** The messages so far (copies). A thought still waiting for the content it precedes is
+     *  reported as a trailing assistant message with no text. */
+    snapshot(): AcpAgentMessage[];
+}
+/** Fold verbatim update records (a turn's `updates`, a `replay`) into messages. */
+export declare function foldMessages(records: readonly AcpAgentUpdateRecord[]): AcpAgentMessage[];
+export {};
+//# sourceMappingURL=messages.d.ts.map

package/dist/agent/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/agent/messages.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAgB,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAC1H,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE1F,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,KAAK,cAAc,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,aAAa,EAAE,WAAW,GAAG,kBAAkB,CAAA;CAAE,CAAC,CAAC;AAgBrG;;0DAE0D;AAC1D,wBAAgB,YAAY,CAAC,QAAQ,EAAE,eAAe,GAAG,SAAS,EAAE,MAAM,EAAE,cAAc,GAAG,eAAe,CAiB3G;AAYD,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,eAAe,CAQrE;AAED,qBAAa,aAAa;;IAgBxB;;8FAE0F;IAC1F,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAchC,KAAK,CAAC,MAAM,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IA6DzD;mGAC+F;IAC/F,IAAI,SAAS,IAAI,gBAAgB,EAAE,CAElC;IAED;iEAC6D;IAC7D,QAAQ,IAAI,eAAe,EAAE;CAmE9B;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,oBAAoB,EAAE,GAAG,eAAe,EAAE,CAIxF"}

package/dist/agent/messages.js

@@ -0,0 +1,225 @@
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+/** Fold one `tool_call` / `tool_call_update` into `existing` (a fresh entry when undefined):
+ *  every field the update carries replaces the last seen one, `_meta` merges shallowly, and
+ *  `status` stays `pending` until the agent sends one. */
+export function foldToolCall(existing, update) {
+    const meta = record(update._meta);
+    const entry = existing ?? {
+        toolCallId: update.toolCallId,
+        title: typeof update.title === "string" ? update.title : "",
+        status: "pending",
+    };
+    if (typeof update.title === "string")
+        entry.title = update.title;
+    if (typeof update.name === "string")
+        entry.name = update.name;
+    if (update.kind !== undefined && update.kind !== null)
+        entry.kind = update.kind;
+    if (update.status !== undefined && update.status !== null)
+        entry.status = update.status;
+    if (update.rawInput !== undefined)
+        entry.rawInput = update.rawInput;
+    if (update.rawOutput !== undefined)
+        entry.rawOutput = update.rawOutput;
+    if (update.content !== undefined && update.content !== null)
+        entry.content = update.content;
+    if (update.locations !== undefined && update.locations !== null)
+        entry.locations = update.locations;
+    if (meta)
+        entry.meta = { ...(entry.meta ?? {}), ...meta };
+    return entry;
+}
+/** Append `block` to `blocks`, concatenating a text block onto a trailing text block. */
+function appendBlock(blocks, block) {
+    const last = blocks[blocks.length - 1];
+    if (block.type === "text" && last?.type === "text") {
+        blocks[blocks.length - 1] = { ...last, text: last.text + block.text };
+        return;
+    }
+    blocks.push({ ...block });
+}
+/** A fresh, shallow copy of a message (blocks and tool calls copied one level deep). */
+export function copyMessage(message) {
+    return {
+        role: message.role,
+        content: message.content.map((block) => ({ ...block })),
+        toolCalls: message.toolCalls.map((call) => ({ ...call })),
+        thoughts: message.thoughts.map((block) => ({ ...block })),
+        receivedAt: message.receivedAt,
+    };
+}
+export class MessageFolder {
+    #messages = [];
+    /** The assistant message tool calls and non-text blocks attach to; unset after a user message or
+     *  a turn boundary. */
+    #assistant;
+    /** The open run of `user_message_chunk`s. */
+    #user;
+    /** Thoughts waiting for the assistant content they precede. */
+    #pendingThoughts = [];
+    #pendingThoughtsAt;
+    /** `SessionState.assistantMessageBoundaryPending`: the next text chunk opens a new message. */
+    #boundaryPending = true;
+    /** `SessionState.activeAssistantMessageId`: a changed ACP `messageId` is a boundary. */
+    #activeMessageId;
+    #toolCallsById = new Map();
+    /** Mirror `SessionState.beginTurn()`: a boundary, no message in progress, and — like the
+     *  accumulator under `retainSessionLog: false` — a cleared transcript when `retain` is false.
+     *  A thought left over from the previous turn becomes its own assistant message first. */
+    beginTurn(retain) {
+        if (retain) {
+            this.#flushPendingThoughts();
+        }
+        else {
+            this.#messages.length = 0;
+            this.#toolCallsById.clear();
+            this.#pendingThoughts = [];
+            this.#pendingThoughtsAt = undefined;
+        }
+        this.#assistant = undefined;
+        this.#user = undefined;
+        this.#markBoundary();
+    }
+    apply(update, receivedAt) {
+        switch (update.sessionUpdate) {
+            case "agent_message_chunk": {
+                this.#user = undefined;
+                this.#applyMessageId(update.messageId);
+                // A pending boundary opens a new message for ANY block. The text fold consumes it only on
+                // a text chunk, but a non-text block consuming it here never moves a text chunk between
+                // messages: the message it opens holds no earlier text, so the next text chunk is its
+                // first either way.
+                const target = this.#boundaryPending || !this.#assistant ? this.#openAssistant(receivedAt) : this.#assistant;
+                this.#boundaryPending = false;
+                appendBlock(target.content, update.content);
+                return;
+            }
+            case "agent_thought_chunk": {
+                this.#user = undefined;
+                this.#markBoundary();
+                appendBlock(this.#pendingThoughts, update.content);
+                this.#pendingThoughtsAt ??= receivedAt;
+                return;
+            }
+            case "tool_call":
+            case "tool_call_update": {
+                this.#user = undefined;
+                this.#markBoundary();
+                const existing = this.#toolCallsById.get(update.toolCallId);
+                if (existing) {
+                    foldToolCall(existing, update);
+                    return;
+                }
+                const target = this.#assistant ?? this.#openAssistant(receivedAt);
+                this.#adoptPendingThoughts(target);
+                const entry = foldToolCall(undefined, update);
+                target.toolCalls.push(entry);
+                this.#toolCallsById.set(entry.toolCallId, entry);
+                return;
+            }
+            case "user_message_chunk": {
+                this.#markBoundary();
+                this.#assistant = undefined;
+                this.#flushPendingThoughts();
+                if (!this.#user) {
+                    this.#user = { role: "user", content: [], toolCalls: [], thoughts: [], receivedAt };
+                    this.#messages.push(this.#user);
+                }
+                appendBlock(this.#user.content, update.content);
+                return;
+            }
+            case "plan":
+            case "plan_update":
+            case "plan_removed": {
+                this.#user = undefined;
+                this.#markBoundary();
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    /** Every folded tool call in first-seen order (copies) — the flattening of the messages'
+     *  `toolCalls`, which is the same order because a call attaches to the message in progress. */
+    get toolCalls() {
+        return this.#messages.flatMap((message) => message.toolCalls.map((call) => ({ ...call })));
+    }
+    /** The messages so far (copies). A thought still waiting for the content it precedes is
+     *  reported as a trailing assistant message with no text. */
+    snapshot() {
+        const messages = this.#messages.map(copyMessage);
+        if (this.#pendingThoughts.length > 0) {
+            messages.push({
+                role: "assistant",
+                content: [],
+                toolCalls: [],
+                thoughts: this.#pendingThoughts.map((block) => ({ ...block })),
+                receivedAt: this.#pendingThoughtsAt,
+            });
+        }
+        return messages;
+    }
+    #markBoundary() {
+        this.#boundaryPending = true;
+        this.#activeMessageId = undefined;
+    }
+    /** `SessionState.beginAssistantMessageChunk`'s id rule: a chunk whose `messageId` differs from
+     *  the active one marks a boundary; an id is remembered whether or not the chunk carries text. */
+    #applyMessageId(messageId) {
+        const id = messageId ?? undefined;
+        if (id !== undefined && this.#activeMessageId !== undefined && id !== this.#activeMessageId) {
+            this.#boundaryPending = true;
+        }
+        if (id !== undefined)
+            this.#activeMessageId = id;
+    }
+    /** Open a new assistant message (adopting any pending thoughts, which then date it). The
+     *  boundary flag is the caller's: a text or non-text block consumes it, a tool call does not
+     *  (text after a tool call is always a new message, exactly like the text fold). */
+    #openAssistant(receivedAt) {
+        const message = {
+            role: "assistant",
+            content: [],
+            toolCalls: [],
+            thoughts: [],
+            receivedAt: this.#pendingThoughtsAt ?? receivedAt,
+        };
+        this.#adoptPendingThoughts(message);
+        this.#messages.push(message);
+        this.#assistant = message;
+        return message;
+    }
+    #adoptPendingThoughts(message) {
+        if (this.#pendingThoughts.length === 0)
+            return;
+        message.thoughts.push(...this.#pendingThoughts);
+        this.#pendingThoughts = [];
+        this.#pendingThoughtsAt = undefined;
+    }
+    /** A thought that no assistant content followed (a user message or a turn boundary came first)
+     *  is an assistant message of its own; it is never the attach target for later content. */
+    #flushPendingThoughts() {
+        if (this.#pendingThoughts.length === 0)
+            return;
+        this.#messages.push({
+            role: "assistant",
+            content: [],
+            toolCalls: [],
+            thoughts: this.#pendingThoughts,
+            receivedAt: this.#pendingThoughtsAt,
+        });
+        this.#pendingThoughts = [];
+        this.#pendingThoughtsAt = undefined;
+    }
+}
+/** Fold verbatim update records (a turn's `updates`, a `replay`) into messages. */
+export function foldMessages(records) {
+    const folder = new MessageFolder();
+    for (const { update, receivedAt } of records)
+        folder.apply(update, receivedAt);
+    return folder.snapshot();
+}

package/dist/agent/probe.d.ts

@@ -8,7 +8,7 @@ import type { AcpAgentCatalog, AcpAgentProbeOptions } from "./types.js";
 export declare function createAgentProbeRunner(backends: Record<string, CustomBackendConfig> | undefined): ValidateProbeRunner;
 /** The catalog behind `AcpAgent.probe` (see the file header). Per-target failures never throw
  *  (`probed: false` with a redacted `error`); a bad `modelFilter`, `probeTimeoutMs`, or
- *  `probeConcurrency` throws a TypeError and a malformed registry a SCRIPT_VALIDATION_ERROR — all
+ *  `probeConcurrency` throws a TypeError and a malformed registry an INVALID_ARGUMENT — all
  *  before any process spawns. */
 export declare function probeCatalog(options?: AcpAgentProbeOptions): Promise<AcpAgentCatalog>;
 //# sourceMappingURL=probe.d.ts.map

package/dist/agent/probe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probe.d.ts","sourceRoot":"","sources":["../../src/agent/probe.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAA2B,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAInF,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAExE;;;wEAGwE;AACxE,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,GAAG,SAAS,GAAG,mBAAmB,CAuCrH;AAED;;;iCAGiC;AACjC,wBAAsB,YAAY,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,eAAe,CAAC,CA8B/F"}
+{"version":3,"file":"probe.d.ts","sourceRoot":"","sources":["../../src/agent/probe.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAA2B,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAKnF,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAExE;;;wEAGwE;AACxE,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,GAAG,SAAS,GAAG,mBAAmB,CA0CrH;AAED;;;iCAGiC;AACjC,wBAAsB,YAAY,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,eAAe,CAAC,CA8B/F"}

package/dist/agent/probe.js

@@ -3,6 +3,7 @@ import { buildHarnessModelsView, buildModelFilter, probeHarnessConfig, } from ".
 import { mapThrownError } from "../errors-map.js";
 import { registryWithRunBackends } from "../registry.js";
 import { resolveModelRoute } from "../routing.js";
+import { describeBackendTraits } from "../traits.js";
 import { releaseOnExit, retainOnExit } from "./process-registry.js";
 import { resolveAgentRegistry } from "./routing.js";
 /** A `ValidateProbeRunner` over a dedicated connection per probe: spawn, initialize, one no-prompt
@@ -34,6 +35,9 @@ export function createAgentProbeRunner(backends) {
                     ...(route.backend.defaultModeId === undefined ? {} : { defaultModeId: route.backend.defaultModeId }),
                     options: handle.advertisedConfigOptions,
                     modes: handle.modes ?? null,
+                    // The live refinement: pi and the Codex fork advertise their system-prompt channel and the
+                    // two vendor extensions at initialize; Claude advertises nothing and reports the tables.
+                    traits: describeBackendTraits(route.backend, registry, connection.capabilities),
                 };
             }
             finally {
@@ -54,7 +58,7 @@ export function createAgentProbeRunner(backends) {
 }
 /** The catalog behind `AcpAgent.probe` (see the file header). Per-target failures never throw
  *  (`probed: false` with a redacted `error`); a bad `modelFilter`, `probeTimeoutMs`, or
- *  `probeConcurrency` throws a TypeError and a malformed registry a SCRIPT_VALIDATION_ERROR — all
+ *  `probeConcurrency` throws a TypeError and a malformed registry an INVALID_ARGUMENT — all
  *  before any process spawns. */
 export async function probeCatalog(options = {}) {
     // Validation only: a bad regex must surface BEFORE any spawn (the MCP handler does the same).

package/dist/agent/queue.js

@@ -1,5 +1,5 @@
-// The per-agent FIFO. `prompt`, `fork`, `setMode`, `setConfigOptions`, `close` and the implicit
-// open all run through one SerialQueue so no two of them ever overlap (a second concurrent
+// The per-agent FIFO. `prompt`, `fork`, `setModel`, `setMode`, `setConfigOptions`, `close` and the
+// implicit open all run through one SerialQueue so no two of them ever overlap (a second concurrent
 // `SessionHandle.prompt` would clobber the handle's active turn; pi rejects a fork while the
 // source has a turn in flight; Claude would copy a partial transcript). Pure: no ACP imports.
 export class SerialQueue {

package/dist/agent/routing.d.ts

@@ -4,7 +4,8 @@ import { type BackendRegistry, type CustomBackendConfig } from "../registry.js";
 import { type ModelRoute } from "../routing.js";
 import type { AcpAgentOptions } from "./types.js";
 /** The custom-backend registry for an agent: `backends` merged over `AGENTPRISM_BACKENDS`. A
- *  malformed registry is a caller error (SCRIPT_VALIDATION_ERROR), mirroring the runner's wrap. */
+ *  malformed registry is a caller error (INVALID_ARGUMENT; the runner's wrap says
+ *  SCRIPT_VALIDATION_ERROR for the same condition). */
 export declare function resolveAgentRegistry(backends: Record<string, CustomBackendConfig> | undefined, label?: string): BackendRegistry;
 /** The runner's routing grammar applied to `new AcpAgent({ model })`. */
 export declare function resolveAgentRoute(options: Pick<AcpAgentOptions, "model">, registry: BackendRegistry): ModelRoute;
@@ -17,6 +18,23 @@ export declare function resolveAgentRoute(options: Pick<AcpAgentOptions, "model"
  * VERBATIM to the ref's backend (the same unrouted rule as the runner, applied to this backend).
  */
 export declare function resolveRefRoute(ref: AgentSessionRef, model: string | undefined, registry: BackendRegistry, label?: string): ModelRoute;
+/**
+ * The model rule `fork()`, `setModel()` and a per-turn `model` share: `spec` goes through the
+ * runner's grammar (`resolveModelRoute` — a registered name wins, an unrouted spec goes to the
+ * default backend) and the route must land on THIS agent's backend, poolKey-equal; otherwise
+ * INVALID_ARGUMENT naming both backends. The remainder is the verbatim model id (`undefined` for a
+ * backend-only spec — `fork()` reads that as "no selection"; a switch rejects it, see
+ * `resolveModelSwitch`).
+ */
+export declare function resolveSameBackendModel(spec: string, backend: Backend, registry: BackendRegistry, label: string | undefined, method: string): ModelRoute;
+/** What a mid-session switch selects: `spec` resolved with `resolveSameBackendModel`, with a
+ *  blank spec or a backend-only spec (`"claude"`, `"claude/"`) rejected — there is no wire form
+ *  for "unselect", so a switch always names a model id. Returns the verbatim id to send and the
+ *  routed `<backendId>/<id>` form the agent's `model` takes once it applied. */
+export declare function resolveModelSwitch(spec: unknown, backend: Backend, registry: BackendRegistry, label: string | undefined, method: string): {
+    modelSpec: string;
+    model: string;
+};
 /** A fresh `Backend` instance with the same identity as `backend` (a registered name wins, as in
  *  routing; else the built-in of that id). A fork child must own its own instance — pooling identity
  *  is `poolKey ?? id`, never the object. */

package/dist/agent/routing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/agent/routing.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7C,OAAO,EAA0B,KAAK,eAAe,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACxG,OAAO,EAAqC,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAEnF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;mGACmG;AACnG,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,GAAG,SAAS,EACzD,KAAK,CAAC,EAAE,MAAM,GACb,eAAe,CAMjB;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,EAAE,QAAQ,EAAE,eAAe,GAAG,UAAU,CAEhH;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,EAAE,eAAe,EACzB,KAAK,CAAC,EAAE,MAAM,GACb,UAAU,CA4BZ;AAED;;4CAE4C;AAC5C,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,eAAe,GAAG,OAAO,CAEpF;AAQD;kFACkF;AAClF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,IAAI,MAAM,CAiB/G"}
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/agent/routing.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7C,OAAO,EAA0B,KAAK,eAAe,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACxG,OAAO,EAAqC,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAEnF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;uDAEuD;AACvD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,GAAG,SAAS,EACzD,KAAK,CAAC,EAAE,MAAM,GACb,eAAe,CAMjB;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,EAAE,QAAQ,EAAE,eAAe,GAAG,UAAU,CAEhH;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,EAAE,eAAe,EACzB,KAAK,CAAC,EAAE,MAAM,GACb,UAAU,CA4BZ;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,EAAE,MAAM,GACb,UAAU,CAYZ;AAED;;;gFAGgF;AAChF,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,EAAE,MAAM,GACb;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAYtC;AAED;;4CAE4C;AAC5C,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,eAAe,GAAG,OAAO,CAEpF;AAQD;kFACkF;AAClF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,IAAI,MAAM,CAiB/G"}

package/dist/agent/routing.js

@@ -1,7 +1,8 @@
-// Agent-facing routing over ../routing.js: the registry read (malformed → SCRIPT_VALIDATION_ERROR),
+// Agent-facing routing over ../routing.js: the registry read (malformed → INVALID_ARGUMENT),
 // the runner's model-spec grammar for `new AcpAgent({ model })`, the ref-driven route the cold
-// statics use (never the default backend), cwd validation that fails BEFORE a process spawns, and
-// the fresh-Backend-instance rule a fork child needs.
+// statics use (never the default backend), the same-backend rule a fork override and a
+// mid-session model switch (`setModel`, a per-turn `model`) must satisfy, cwd validation that
+// fails BEFORE a process spawns, and the fresh-Backend-instance rule a fork child needs.
 import { isAbsolute } from "node:path";
 import { statSync } from "node:fs";
 import { builtinBackend } from "../backends/builtins.js";
@@ -10,7 +11,8 @@ import { resolveBackendRegistry } from "../registry.js";
 import { asciiLowercase, resolveModelRoute } from "../routing.js";
 import { agentValidationError } from "./errors.js";
 /** The custom-backend registry for an agent: `backends` merged over `AGENTPRISM_BACKENDS`. A
- *  malformed registry is a caller error (SCRIPT_VALIDATION_ERROR), mirroring the runner's wrap. */
+ *  malformed registry is a caller error (INVALID_ARGUMENT; the runner's wrap says
+ *  SCRIPT_VALIDATION_ERROR for the same condition). */
 export function resolveAgentRegistry(backends, label) {
     try {
         return resolveBackendRegistry(backends);
@@ -52,6 +54,41 @@ export function resolveRefRoute(ref, model, registry, label) {
     }
     return { backend, modelSpec: model };
 }
+/**
+ * The model rule `fork()`, `setModel()` and a per-turn `model` share: `spec` goes through the
+ * runner's grammar (`resolveModelRoute` — a registered name wins, an unrouted spec goes to the
+ * default backend) and the route must land on THIS agent's backend, poolKey-equal; otherwise
+ * INVALID_ARGUMENT naming both backends. The remainder is the verbatim model id (`undefined` for a
+ * backend-only spec — `fork()` reads that as "no selection"; a switch rejects it, see
+ * `resolveModelSwitch`).
+ */
+export function resolveSameBackendModel(spec, backend, registry, label, method) {
+    const route = resolveModelRoute(spec, registry);
+    const routedPool = route.backend.poolKey ?? route.backend.id;
+    const ownPool = backend.poolKey ?? backend.id;
+    if (route.backend.id !== backend.id || routedPool !== ownPool) {
+        // Same id, different pool (a registry entry shadowing this built-in's name): say which pool.
+        const pooled = route.backend.id === backend.id;
+        const routed = `backend "${route.backend.id}"${pooled ? ` (pool "${routedPool}")` : ""}`;
+        const own = `backend "${backend.id}"${pooled ? ` (pool "${ownPool}")` : ""}`;
+        throw agentValidationError(`${method}: model "${spec}" routes to ${routed} but must stay on ${own}`, label);
+    }
+    return route;
+}
+/** What a mid-session switch selects: `spec` resolved with `resolveSameBackendModel`, with a
+ *  blank spec or a backend-only spec (`"claude"`, `"claude/"`) rejected — there is no wire form
+ *  for "unselect", so a switch always names a model id. Returns the verbatim id to send and the
+ *  routed `<backendId>/<id>` form the agent's `model` takes once it applied. */
+export function resolveModelSwitch(spec, backend, registry, label, method) {
+    if (typeof spec !== "string" || spec.trim() === "") {
+        throw agentValidationError(`${method} requires a non-empty model spec ("${backend.id}/<model id>")`, label);
+    }
+    const { modelSpec } = resolveSameBackendModel(spec, backend, registry, label, method);
+    if (modelSpec === undefined || modelSpec.trim() === "") {
+        throw agentValidationError(`${method}: model "${spec}" names backend "${backend.id}" but no model id; use "${backend.id}/<model id>"`, label);
+    }
+    return { modelSpec, model: `${backend.id}/${modelSpec}` };
+}
 /** A fresh `Backend` instance with the same identity as `backend` (a registered name wins, as in
  *  routing; else the built-in of that id). A fork child must own its own instance — pooling identity
  *  is `poolKey ?? id`, never the object. */

package/dist/agent/stream.d.ts

@@ -0,0 +1,21 @@
+import type { AcpAgentStream, AcpAgentStreamEvent } from "./types.js";
+type Result = IteratorResult<AcpAgentStreamEvent, undefined>;
+export declare class TurnStream implements AcpAgentStream {
+    #private;
+    /** `stop` aborts the turn and resolves once it settled; called at most once. */
+    constructor(stop: () => Promise<void>);
+    /** Buffer an event, or hand it straight to a waiting `next()`. Ignored once closed. */
+    push(event: AcpAgentStreamEvent): void;
+    /** The turn resolved; the terminal event is already buffered. */
+    end(): void;
+    /** The turn rejected: buffered events are still delivered, then `error` is thrown once. */
+    fail(error: unknown): void;
+    next(): Promise<Result>;
+    /** The consumer left early: abort the turn, wait for it to settle, then report `done`. */
+    return(): Promise<Result>;
+    /** Same as `return()`, then rethrow `error` to the caller (async-generator semantics). */
+    throw(error?: unknown): Promise<Result>;
+    [Symbol.asyncIterator](): AcpAgentStream;
+}
+export {};
+//# sourceMappingURL=stream.d.ts.map

package/dist/agent/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/agent/stream.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtE,KAAK,MAAM,GAAG,cAAc,CAAC,mBAAmB,EAAE,SAAS,CAAC,CAAC;AAS7D,qBAAa,UAAW,YAAW,cAAc;;IAU/C,gFAAgF;gBACpE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC;IAIrC,uFAAuF;IACvF,IAAI,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI;IAOtC,iEAAiE;IACjE,GAAG,IAAI,IAAI;IAMX,2FAA2F;IAC3F,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAO1B,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IASvB,0FAA0F;IACpF,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC;IAK/B,0FAA0F;IACpF,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAK7C,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc;CAkCzC"}