@teaflask/assistant 0.3.0 → 0.7.0

package/dist/core/transcript-rows.d.ts

@@ -1,7 +1,7 @@
 import type { Message } from "@ag-ui/core";
 import type { TurnAttachment } from "../contract/threads.js";
 import type { UserTurnMeta } from "./user-turn-ledger.js";
-import type { MarkerAnchorsSnapshot } from "./connection-epoch.js";
+import type { TranscriptMarkers } from "./connection-epoch.js";
 import { type MemoryUpdated } from "./memory-provenance-anchors.js";
 import type { BlockTiming } from "./segment-timing.js";
 import { type SubagentGroupRow } from "./subagent-rows.js";
@@ -9,144 +9,210 @@ import type { DeliveredResult } from "./subagent-delivery-anchors.js";
 import type { AnchoredTurnFailReceipts } from "./turn-failed-anchors.js";
 import type { ToolCallDisplay, ToolCallState } from "./tool-call-display.js";
 import type { ToolCallSchemas } from "./tool-schema-anchors.js";
-/** The chassis' ReactCustomMessageRendererPosition, owned. */
 export type MarkerPosition = "before" | "after";
+/** A message the user sent. */
 export interface UserMessageRow {
+    /** Identifies a user message row. */
     kind: "user";
+    /** Stable unique key for this row, which is also the user message's id. */
     key: string;
+    /** What the user typed. Empty when the message carries only attachments. */
     text: string;
-    /** The message's attachments (upload order) — from the turn ledger's
-     *  side table, never the AG-UI Message itself. */
+    /** The files attached to the message, in upload order. */
     attachments: TurnAttachment[];
-    /** The turn's server created_at stamp (ISO-8601), from the same side
-     *  table: the wire carries no per-message timestamp, so the turn's
-     *  creation is the bubble's one honest clock — never a client's. Absent
-     *  on an optimistic echo (no turn yet) and on hosts that pass no meta
-     *  (the bench, probes). */
+    /**
+     * When the message was sent, as an ISO-8601 timestamp from the server.
+     * Absent on an optimistic row and when transcriptRowsOf was given no turn
+     * metadata.
+     */
     createdAt?: string;
-    /** The send has left the composer but replay has not injected its
-     *  authoritative user message yet. It still occupies its final place
-     *  in the transcript; this flag is presentation/accessibility state,
-     *  never a second message kind. */
+    /**
+     * True while the message has been sent but not yet confirmed by the
+     * conversation; it already sits in its final position.
+     */
     optimistic?: true;
 }
+/** A block of the assistant's reply text. */
 export interface AssistantTextRow {
+    /** Identifies an assistant reply row. */
     kind: "assistant-text";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /**
+     * The reply as Markdown. While `streaming` is true it may end mid-sentence
+     * or mid-syntax.
+     */
     text: string;
-    /** True only on the newest assistant text while the run streams — the
-     *  one row whose markdown gets the streaming repair. */
+    /**
+     * True only on the newest reply text while the assistant is still working,
+     * meaning the text is still growing.
+     */
     streaming: boolean;
-    /** The memory writes this message's run caused, in stream
-     *  order — the message-level provenance footer. Row-embedded rather
-     *  than a row kind of its own, so a write never splits a run fold and
-     *  the row count stays a function of the messages alone. Absent when
-     *  the history carries no attribution — old markers render no footer,
-     *  never a synthesized one. */
+    /**
+     * Memories the assistant saved during the run that produced this message,
+     * in the order they were saved. Absent when it saved none.
+     */
     memoryUpdates?: MemoryUpdated[];
 }
+/**
+ * The model's visible thinking before or between its replies and tool calls.
+ */
 export interface ReasoningRow {
+    /** Identifies a reasoning row. */
     kind: "reasoning";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /** The reasoning text. */
     text: string;
-    /** True while the run streams and this is the newest message — the
-     *  auto-open window; the row collapses the moment the next block
-     *  (answer text or a tool call) starts a new message. */
+    /**
+     * True while this is the newest message and the assistant is still working;
+     * turns false as soon as reply text or a tool call starts, which is a good
+     * moment to collapse it.
+     */
     streaming: boolean;
-    /** The block's observed server timing, joined from the
-     *  timing anchors by this row's message id. Absent when the history
-     *  carries no timestamps — unknown, never zero. */
+    /**
+     * When the reasoning started and ended by the server's clock. Absent when
+     * the history carries no timestamps, which means unknown rather than zero.
+     */
     timing?: BlockTiming;
 }
+/**
+ * One tool or action call the agent made, with its arguments, state and result.
+ */
 export interface ToolCallRow {
+    /** Identifies a tool call row. */
     kind: "tool-call";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /** The call's id, which also keys this call in the markerAnchors maps. */
     toolCallId: string;
+    /**
+     * The name of the tool the agent called; an action appears as
+     * `action__<slug>`.
+     */
     toolName: string;
+    /**
+     * Where the call stands. output-available means the result arrived,
+     * output-error it failed, denied the user declined its approval, cancelled
+     * it was stopped before it ran, refused the tool declined the request,
+     * superseded a retry abandoned it, input-available it awaits its result
+     * while the assistant works, and input-streaming it has no result while the
+     * assistant is not working (for example, paused for an approval).
+     */
     state: ToolCallState;
-    /** The raw streamed arguments (JSON text, possibly mid-stream). */
+    /**
+     * The arguments as raw JSON text, which may be incomplete while they are
+     * still streaming.
+     */
     argsText: string;
+    /**
+     * The result text exactly as the agent received it. Undefined until it
+     * arrives.
+     */
     result?: string;
-    /** True when the wire's result is the context offloader's model-facing
-     *  replacement, not the tool's output — the Result pane renders a quiet
-     *  shortened-result line instead of the content. */
+    /**
+     * True when the tool's output was too large and `result` holds a shortened
+     * stand-in rather than the actual output; show a "result shortened" note
+     * instead of the content.
+     */
     offloaded: boolean;
-    /** The failure sentence, present only on output-error rows. */
+    /** Why the call failed. Present only when state is output-error. */
     errorText?: string;
-    /** The door's refusal sentence, present only on refused rows. */
+    /**
+     * The tool's explanation for declining the request. Present only when state
+     * is refused.
+     */
     refusalText?: string;
-    /** The backend-authored display copy, when the wire annotated the call. */
+    /**
+     * Captions, status text, an icon and a tool view reference supplied by the
+     * server for this call. Absent when it supplied none.
+     */
     display?: ToolCallDisplay;
-    /** The tool's registered schemas, joined from the schema
-     *  anchors by this row's tool call id. Absent when none were declared
-     *  or the history predates the channel — never `{}`. */
+    /**
+     * The JSON Schemas declared for this tool's arguments and result. Absent
+     * when the tool declared none.
+     */
     schemas?: ToolCallSchemas;
-    /** The block's observed server timing, joined from the
-     *  timing anchors by this row's tool call id. Absent when the history
-     *  carries no timestamps — unknown, never zero. */
+    /**
+     * When the call started and finished by the server's clock. Absent when the
+     * history carries no timestamps, which means unknown rather than zero.
+     */
     timing?: BlockTiming;
-    /** True when a member decision rode this call: an
-     *  approval_requested or member-answerable execution marker named it —
-     *  the DURABLE evidence the placement hold's decision arm reads, so
-     *  the hold survives the card stores' pruning (the gated call's
-     *  result, RUN_ERROR, the turn's settle) and a reload of a
-     *  settled thread. Absent on histories with no such marker. */
+    /**
+     * True when the user was asked to approve this call or answer a question
+     * for it; it stays true after the decision and after a reload.
+     */
     decisionBearing?: boolean;
 }
+/**
+ * A notice shown after the last message of a turn that failed for a reason
+ * outside any single tool call, such as the model provider, usage limits or a
+ * lost connection.
+ */
 export interface TurnFailedReceiptsRow {
+    /** Identifies a failed-turn notice row. */
     kind: "turn-failed-receipts";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
-    /** The reader-aware sentences the failed settle recorded —
-     *  the turn-level terminal state, distinct from any single
-     *  operation's failure. */
+    /**
+     * Sentences explaining the failure, written to be shown to the user as they
+     * are.
+     */
     receipts: AnchoredTurnFailReceipts[MarkerPosition];
 }
+/**
+ * A divider shown before the assistant's reply in a turn it started on its own
+ * to report finished sub-agent results; such turns have no user message.
+ */
 export interface SubagentDeliveryRow {
+    /** Identifies a sub-agent delivery divider row. */
     kind: "subagent-delivery";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
-    /** The settled dispatches the machine-started delivery run pushed
-     *  — the divider names them before the run's first prose. */
+    /** The finished sub-agents whose results this turn reports. */
     results: DeliveredResult[];
 }
+/** One row of the transcript. Switch on `kind` to pick how to render it. */
 export type TranscriptRow = UserMessageRow | AssistantTextRow | ReasoningRow | ToolCallRow | SubagentGroupRow | TurnFailedReceiptsRow | SubagentDeliveryRow;
+/**
+ * A message the user has just sent that the transcript does not contain yet,
+ * shown optimistically until it arrives.
+ */
 export interface PendingUserEcho {
+    /**
+     * Temporary id for the message; it switches to the message's real id once
+     * the send succeeds, so the echo is dropped when that row arrives.
+     */
     messageId: string;
+    /** What the user typed. */
     text: string;
+    /** The files attached to the message, in upload order. */
     attachments: TurnAttachment[];
 }
-export declare function transcriptRowsOf(messages: readonly Message[], anchors: MarkerAnchorsSnapshot, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>): TranscriptRow[];
-/** Paint a submitted user message at the transcript tail while replay is
- *  catching up. Once the POST lands the echo adopts the authoritative
- *  message id, so an already-injected row wins without a duplicate. */
+/**
+ * Builds the transcript rows from the raw message list and its extra facts,
+ * exactly as useTranscript does. Pure; call it only when you need to derive
+ * rows from your own inputs.
+ */
+export declare function transcriptRowsOf(messages: readonly Message[], anchors: TranscriptMarkers, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>): TranscriptRow[];
+/**
+ * Appends the just-sent user message to the rows as an optimistic user row,
+ * unless a user row with the same key is already present. Returns the rows
+ * unchanged when `echo` is null.
+ */
 export declare function withPendingUserEcho(rows: readonly TranscriptRow[], echo: PendingUserEcho | null): readonly TranscriptRow[];
-/** True when the newest row is itself live streamed content — the window
- *  where a typing dot underneath would double-announce what is already
- *  animating. */
 export declare function trailingRowIsStreaming(rows: readonly TranscriptRow[]): boolean;
-/** The Error pane's sentence: the recorded error, or — when the wire sent
- *  an empty one — the result text the failure arrived as. */
 export declare function errorTextOf(recordedError: string | undefined, result: string | undefined): string | undefined;
-/** The message ids that render a host marker row, by which side of their
- *  block the marker draws on. Markers aren't block rows here (the host's
- *  marker composite renders them from its own anchor state), so the
- *  cross-block grouping walk can't see them — the host hands their
- *  positions in, and a marker splits two delegation moments exactly the
- *  way any visible row does. */
 export interface MarkerBoundaries {
     before: ReadonlySet<string>;
     after: ReadonlySet<string>;
 }
 export declare const EMPTY_MARKER_BOUNDARIES: MarkerBoundaries;
-/** One entry per deduped message id, rows possibly empty. */
 export interface TranscriptBlock {
     messageId: string;
     rows: TranscriptRow[];
 }
-export declare function transcriptBlocksOf(messages: readonly Message[], anchors: MarkerAnchorsSnapshot, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>, options?: {
+export declare function transcriptBlocksOf(messages: readonly Message[], anchors: TranscriptMarkers, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>, options?: {
     markerBoundaries?: MarkerBoundaries;
-    /** Attachments joined by message id for hosts without a turn ledger —
-     *  like meta.attachments, but carrying no createdAt (no stamp is ever
-     *  synthesized). Consulted only when the id has no turn meta. */
     attachmentsByMessageId?: ReadonlyMap<string, TurnAttachment[]>;
 }): TranscriptBlock[];
-//# sourceMappingURL=transcript-rows.d.ts.map

package/dist/core/transcript-rows.js

@@ -10,18 +10,11 @@ export function transcriptRowsOf(messages, anchors, running, metaByMessageId = N
     const lastAssistantTextId = newestAssistantProseIdOf(messages);
     const lastMessageId = messages.at(-1)?.id ?? null;
     const memoryFooters = memoryFootersOf(anchors.memoryProvenanceAnchors, anchors.memoryAttributionAnchors);
-    // A run_resumed marker anchors to the retry's FIRST message
-    // (stream-resume.ts), so a message strictly before it in the SAME turn
-    // is a prior attempt's — its open tool calls can never receive a
-    // result and must not read as running.
     const severed = _severedFlagsOf(messages, anchors);
     for (const [index, message] of messages.entries()) {
         _pushMarkersAt(rows, anchors, message.id, "before");
         _pushMessageRows(rows, message, results, {
             streamingMessageId: running ? lastAssistantTextId : null,
-            // Reasoning streams only while it is the newest message of a live
-            // run: the next block (answer text, a tool call) starts a new
-            // message and thereby closes the window.
             streamingReasoningId: running ? lastMessageId : null,
             running,
             superseded: severed[index],
@@ -39,15 +32,8 @@ export function transcriptRowsOf(messages, anchors, running, metaByMessageId = N
         });
         _pushMarkersAt(rows, anchors, message.id, "after");
     }
-    // Dispatch calls fold into subagent group rows at their exact spot in the
-    // flat interleave — over the WHOLE list, because the wire puts every
-    // streamed call in its own assistant message, so one parallel fan-out
-    // arrives as adjacent single-call messages; any visible row still splits.
     return withSubagentGroups(rows, _asDispatchCall, (row) => row.key);
 }
-/** Paint a submitted user message at the transcript tail while replay is
- *  catching up. Once the POST lands the echo adopts the authoritative
- *  message id, so an already-injected row wins without a duplicate. */
 export function withPendingUserEcho(rows, echo) {
     if (echo === null ||
         rows.some((row) => row.kind === "user" && row.key === echo.messageId)) {
@@ -64,9 +50,6 @@ export function withPendingUserEcho(rows, echo) {
         },
     ];
 }
-/** True when the newest row is itself live streamed content — the window
- *  where a typing dot underneath would double-announce what is already
- *  animating. */
 export function trailingRowIsStreaming(rows) {
     const last = rows.at(-1);
     if (last === undefined) {
@@ -75,13 +58,10 @@ export function trailingRowIsStreaming(rows) {
     return ((last.kind === "assistant-text" || last.kind === "reasoning") &&
         last.streaming);
 }
-// --- message rows -------------------------------------------------------------
 function _pushMessageRows(rows, message, results, context) {
     if (message.role === "user") {
         const meta = context.turnMeta.get(message.id);
         const attachments = meta?.attachments ?? context.sideAttachments?.get(message.id) ?? [];
-        // An attachment-only turn has empty text and must still render its
-        // chips; a genuinely empty message stays dropped.
         if (typeof message.content === "string" &&
             (message.content !== "" || attachments.length > 0)) {
             rows.push({
@@ -89,8 +69,6 @@ function _pushMessageRows(rows, message, results, context) {
                 key: message.id,
                 text: message.content,
                 attachments,
-                // Spread-conditional, not always-on: hosts that pass no meta
-                // (the bench, probes, child transcripts) render no stamp.
                 ...(meta !== undefined ? { createdAt: meta.createdAt } : {}),
             });
         }
@@ -109,8 +87,6 @@ function _pushMessageRows(rows, message, results, context) {
         return;
     }
     if (message.role !== "assistant") {
-        // Tool results render under their call's row; system/activity
-        // messages have no standalone rendering in the transcript.
         return;
     }
     if (typeof message.content === "string" && message.content !== "") {
@@ -120,8 +96,6 @@ function _pushMessageRows(rows, message, results, context) {
             key: message.id,
             text: message.content,
             streaming: message.id === context.streamingMessageId,
-            // Present only when attributed writes exist: the footer is
-            // provenance on the message it explains, never a default slot.
             ...(memoryUpdates !== undefined ? { memoryUpdates } : {}),
         });
     }
@@ -138,43 +112,23 @@ function _pushMessageRows(rows, message, results, context) {
             state,
             argsText: toolCall.function.arguments,
             result,
-            // An offloaded call settled normally — the state ladder is
-            // untouched; only the Result pane's content decision changes.
             offloaded: context.offloads.has(toolCall.id),
             errorText: errorTextOf(recordedError, result),
-            // The reason rides only the refused state: a higher rung (a
-            // recorded error, a cancel) owns its own story.
             ...(state === "refused" ? { refusalText: recordedRefusal } : {}),
             display: context.displays.get(toolCall.id),
             schemas: context.schemas.get(toolCall.id),
             timing: context.timings.get(toolCall.id),
-            // Present only when the durable marker named this call — hand-built
-            // rows and old histories simply omit it.
             ...(context.decisions.has(toolCall.id) ? { decisionBearing: true } : {}),
         });
     }
 }
-// The package's row shape, normalized to the shared grouping module's
-// contract — this tree keeps the raw args text on the row, so no
-// round-trip is needed.
 function _asDispatchCall(row) {
     if (row.kind !== "tool-call" ||
         row.toolName !== DISPATCH_SUBAGENT_TOOL_NAME ||
-        // A refused dispatch launched no child: there is no
-        // coworker to group, so the row stays a plain declined tool row with
-        // its reason line — never a group entry wearing a child's word. A
-        // denied dispatch likewise: the member declined it before
-        // it ran, so it stays a plain not-approved row.
         row.state === "refused" ||
         row.state === "denied") {
         return null;
     }
-    // Superseded counts as settled AND cancelled: the dispatch tool answers
-    // immediately (its receipt is the launch acknowledgment, never the child's
-    // report), so a resultless dispatch row is only ever the severed shape.
-    // Behind a later resume marker that receipt can never land, and with no
-    // receipt there is no ordinal for the ledger join — an unsettled read
-    // would spin the group's "Working" forever.
     return {
         toolCallId: row.toolCallId,
         settled: row.state === "output-available" ||
@@ -188,21 +142,12 @@ function _asDispatchCall(row) {
         argsText: row.argsText,
     };
 }
-/** The Error pane's sentence: the recorded error, or — when the wire sent
- *  an empty one — the result text the failure arrived as. */
 export function errorTextOf(recordedError, result) {
     if (recordedError === undefined) {
         return undefined;
     }
     return recordedError !== "" ? recordedError : result;
 }
-/** role:"tool" messages carry each call's result, keyed by toolCallId —
- *  and the NEWEST one wins (an intended delta from the chassis' first-wins
- *  accident). Two distinct tool messages can carry one tool_call_id across
- *  an approval-pause round boundary (message ids carry the round infix,
- *  tool-call ids deliberately do not), and there the LATER record is the
- *  call's outcome. One join rule for every surface; pinned by the
- *  projection suite's last-record-wins case. */
 function _toolResultsOf(messages) {
     const results = new Map();
     for (const message of messages) {
@@ -212,53 +157,6 @@ function _toolResultsOf(messages) {
     }
     return results;
 }
-// A recorded error → the call failed; result present → settled; no
-// result before a retry's resume anchor in the same turn → severed by
-// that retry, its result can never arrive; no result while
-// the run streams → running; no result on a settled run → the call
-// never finished (a pause or an interruption ended the run) —
-// presented as still pending,
-// because the truthful story (an approval card, a receipt row, the
-// failure banner) renders alongside and owns the explanation, exactly
-// as the chassis presented it.
-//
-// The failure signal rides TOOL_CALL_RESULT as an `error` field, but
-// @ag-ui/client 1.0 strips unknown top-level fields before any subscriber
-// (the transport lifts them into metadata, core/tool-outcome.ts) — so
-// errored calls arrive via the anchors map the recorder fills, not via
-// the message list. A cancelled tool (a stop, a steering
-// guide — and, AT THE WIRE, a member's denial, which the mapper stamps
-// cancelled before the denied rung below reclassifies it) never carries
-// the field: only a tool that ran and broke is a failure. Its
-// `cancelled` stamp rides the same lift into its own anchor set —
-// checked before the result, because a cancelled call DOES have a result
-// message (the model-facing cancellation text, which must not read as an
-// outcome). A refused call rides its `refused` stamp the same
-// way and ranks next: the
-// door answered and declined, and its result message is the refusal
-// envelope the model read — never an outcome either; the mapper stamps
-// refused INSTEAD of error, so the two rungs are exclusive by
-// construction and the order merely states the priority. Supersession
-// ranks below all three anchors and below a landed result: a
-// prior-attempt call that settled stays settled — only its open calls
-// are severed.
-//
-// The denied rung sits between errored and cancelled, and
-// both neighbours are deliberate:
-// - Below errored, because a recorded FAILURE outranks everything: a
-//   call that ran and broke is never reclassified by a later decision
-//   marker (TVC-037's posture for supersession, kept for denial).
-// - Above cancelled, because the wire carries a denial AS a cancel —
-//   the mapper stamps the denied call's receipt `cancelled` like any
-//   tool that never ran — so the rung exists precisely to reclassify
-//   that stamp; below it, the state could never show.
-// - Above refused by chronology, and the two are exclusive BY
-//   CONSTRUCTION: a denied call never ran, so no door ever answered it
-//   (the door's `refused` sentence is a tool result, and a denial's
-//   only result is the cancellation sentinel). If a history ever
-//   carried both stamps on one call the ladder would read it denied —
-//   the member's decision came first — and the refusal sentence would
-//   drop with its rung, as it does under a cancel today.
 function _toolStateOf(result, errored, denied, cancelled, refused, superseded, running) {
     if (errored) {
         return "output-error";
@@ -280,15 +178,6 @@ function _toolStateOf(result, errored, denied, cancelled, refused, superseded, r
     }
     return running ? "input-available" : "input-streaming";
 }
-/** Which messages a resume anchor severs — two scopings, both from the
- *  marker's mechanism (docs/transcript-rows-and-folds.md, "Resume severance
- *  scoping"): per turn, never thread-wide (a retry only re-streams its own
- *  turn, whose window starts at its first visible row — the user message or
- *  the delivery divider), and every resume anchor severs (there is no
- *  non-severing shape). Boundary resets apply BEFORE the same message's
- *  severance check, so a shared first message severs nothing — the safe
- *  direction: a missed severance stays pending, a false one asserts an
- *  interruption that never happened. */
 function _severedFlagsOf(messages, anchors) {
     const flags = messages.map(() => false);
     let turnStart = 0;
@@ -308,7 +197,6 @@ function _severedFlagsOf(messages, anchors) {
     }
     return flags;
 }
-// --- marker rows ---------------------------------------------------------------
 function _pushMarkersAt(rows, anchors, messageId, position) {
     if (position === "before") {
         const delivered = anchors.subagentDeliveryAnchors.get(messageId);
@@ -320,11 +208,6 @@ function _pushMarkersAt(rows, anchors, messageId, position) {
             });
         }
     }
-    // The meta-receipt markers (resume, voided, approval) push no rows here:
-    // the transcript renders no standalone narration for them. Resume anchors
-    // still sever prior-attempt calls (_severedFlagsOf); the approval outcome
-    // shows on the decision card's footer and the operation row's state. Only
-    // the turn-level failure receipt remains a rendered marker row.
     const failed = anchors.turnFailedAnchors.get(messageId)?.[position];
     if (failed !== undefined && failed.length > 0) {
         rows.push({
@@ -369,20 +252,11 @@ export function transcriptBlocksOf(messages, anchors, running, metaByMessageId =
         _pushMarkersAt(rows, anchors, message.id, "after");
         return {
             messageId: message.id,
-            // Per block first, merged across blocks below — the same two-step
-            // the flat walk collapses into one withSubagentGroups pass. The
-            // merged group's key equals the flat pass's (the first dispatch
-            // row's), so on a duplicate-free history with empty boundaries the
-            // flattened blocks deep-equal transcriptRowsOf's list.
             rows: withSubagentGroups(rows, _asDispatchCall, (row) => row.key),
         };
     });
     return _withCrossBlockGroups(blocks, options.markerBoundaries ?? EMPTY_MARKER_BOUNDARIES);
 }
-// A reconnect replays onto the agent's uncleared message list (StrictMode's
-// double-mount does the same), so every id can appear twice. The dedupe:
-// first-seen position kept, later occurrence wins, assistant entries recover
-// content/toolCalls from the earlier one when the later is empty.
 function _dedupedById(messages) {
     const byId = new Map();
     for (const message of messages) {
@@ -393,7 +267,6 @@ function _dedupedById(messages) {
             byId.set(message.id, {
                 ...existing,
                 ...message,
-                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- an empty string is exactly the case to recover from: the re-delivered entry streams "" before its content arrives, and ?? would let it erase the recovered text
                 content: message.content || existing.content,
                 toolCalls: message.toolCalls ?? existing.toolCalls,
             });
@@ -404,12 +277,6 @@ function _dedupedById(messages) {
     }
     return [...byId.values()];
 }
-// The wire puts every streamed tool call in its own assistant message
-// (TOOL_CALL_START carries no parent id), so one parallel fan-out arrives as
-// adjacent single-call messages. Uninterrupted delegation reads as ONE
-// moment: a group swallows the groups of the blocks after it until any
-// visible row intervenes — a block row, or a host-declared marker. Swallowed
-// blocks keep their place and marker anchors; row-less blocks never break it.
 function _withCrossBlockGroups(blocks, markerBoundaries) {
     let standing = null;
     return blocks.map((block) => {
@@ -424,8 +291,6 @@ function _withCrossBlockGroups(blocks, markerBoundaries) {
                 continue;
             }
             if (standing === null) {
-                // Copied, not aliased: the merge grows the entry list, and the
-                // per-message group this derives from must stay pure.
                 standing = { ...row, entries: [...row.entries] };
                 rows.push(standing);
                 continue;
@@ -438,4 +303,3 @@ function _withCrossBlockGroups(blocks, markerBoundaries) {
         return { messageId: block.messageId, rows };
     });
 }
-//# sourceMappingURL=transcript-rows.js.map

package/dist/core/turn-failed-anchors.d.ts

@@ -1,9 +1,12 @@
 import { receiptOf, wellFormedReceiptAnchorsOf, withReceiptAnchored, type AnchoredReceipts } from "./receipt-anchors.js";
 import type { AgentSubscriber } from "@ag-ui/client";
+/**
+ * The failure sentences for a failed turn, split by whether they are shown
+ * before or after the message they belong to.
+ */
 export type AnchoredTurnFailReceipts = AnchoredReceipts;
 export declare const EMPTY_TURN_FAILED_ANCHORS: ReadonlyMap<string, AnchoredTurnFailReceipts>;
 export declare const turnFailedReceiptOf: typeof receiptOf;
 export declare const withTurnFailedAnchored: typeof withReceiptAnchored;
 export declare const wellFormedFailAnchorsOf: typeof wellFormedReceiptAnchorsOf;
 export declare function turnFailedMarkerRecorder(onReceiptAnchored: (failedRunId: string, messageId: string, position: keyof AnchoredTurnFailReceipts, receipts: string[]) => void): AgentSubscriber;
-//# sourceMappingURL=turn-failed-anchors.d.ts.map

package/dist/core/turn-failed-anchors.js

@@ -1,13 +1,3 @@
-// The failure-receipt anchor model: a turn_failed CUSTOM event is the
-// durable record that this turn ended in failure outside any single tool
-// — quota, provider, transport, orchestration, or a sweep —
-// carrying the wire's own reader-aware sentence (the same string as the
-// turn's `error`). It is the failed turn's only replay-stable record:
-// the run's live RUN_ERROR demotes to RUN_FINISHED on replay. The
-// mechanics — narrow, merge, seed, record — are the shared
-// string-receipt family's (receipt-anchors.ts); this module binds them
-// to the turn_failed event under the failure vocabulary its consumers
-// speak.
 import { receiptMarkerRecorder, receiptOf, wellFormedReceiptAnchorsOf, withReceiptAnchored, } from "./receipt-anchors.js";
 import { TURN_FAILED_EVENT_NAME } from "../contract/events.js";
 export const EMPTY_TURN_FAILED_ANCHORS = new Map();
@@ -17,4 +7,3 @@ export const wellFormedFailAnchorsOf = wellFormedReceiptAnchorsOf;
 export function turnFailedMarkerRecorder(onReceiptAnchored) {
     return receiptMarkerRecorder(TURN_FAILED_EVENT_NAME, onReceiptAnchored);
 }
-//# sourceMappingURL=turn-failed-anchors.js.map