@teaflask/assistant 0.3.0 → 0.6.0

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

@@ -6,4 +6,3 @@ 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

package/dist/core/turn-failure-copy.d.ts

@@ -2,4 +2,3 @@ import type { ServingAssistantTurn } from "../contract/threads.js";
 import type { AnchoredTurnFailReceipts } from "./turn-failed-anchors.js";
 export declare function failureSentenceOf(turns: ServingAssistantTurn[]): string | null;
 export declare function bannerFailureSentenceOf(sentence: string | null, failedReceiptAnchors: ReadonlyMap<string, AnchoredTurnFailReceipts> | undefined): string | null;
-//# sourceMappingURL=turn-failure-copy.d.ts.map

package/dist/core/turn-failure-copy.js

@@ -1,17 +1,3 @@
-// The failure banner's copy rules: which settled turn earns the failure
-// banner at all (failureSentenceOf), and when the banner yields to the
-// transcript's own durable receipt (bannerFailureSentenceOf). The pins in
-// tests/turn-stopped.test.ts and tests/turn-failed.test.ts import from
-// here.
-// Exported for the status-taxonomy pins: failed is the ONLY status that
-// earns the failure banner — parked is resumable and superseded is a
-// receipt, and neither may ever read as an error. And only a VISITOR
-// turn's failure (kind null) earns it: a failed machine turn (delivery,
-// or any future kind — the additive rule) fails in a conversation the
-// visitor isn't driving, and the fallback copy ("the last answer") would
-// be a lie about a message they never sent. Its honest record stays in
-// the activity feed (settledResultOf, deliberately) and the org-facing
-// conversations log.
 export function failureSentenceOf(turns) {
     const newestTurn = turns.at(-1);
     if (newestTurn?.status === "failed" && newestTurn.kind == null) {
@@ -19,17 +5,6 @@ export function failureSentenceOf(turns) {
     }
     return null;
 }
-// The banner's yielding rule: once the transcript itself
-// anchors the failed turn's durable receipt (the turn_failed marker),
-// the notice banner is a duplicate telling — the row IS the record, in
-// place, and it survives reload. The banner therefore renders only for
-// histories with no anchored receipt: turns that failed before the
-// marker existed, or a REST adoption that outran the stream. Matching
-// is by sentence content because the receipt is BY CONSTRUCTION the
-// same string as the turn's error (the backend writes both in one
-// settle); two distinct failed turns sharing one canned sentence would
-// suppress on the older turn's receipt, which still points the reader
-// at a true failure record.
 export function bannerFailureSentenceOf(sentence, failedReceiptAnchors) {
     if (sentence === null || failedReceiptAnchors === undefined) {
         return sentence;
@@ -42,4 +17,3 @@ export function bannerFailureSentenceOf(sentence, failedReceiptAnchors) {
     }
     return sentence;
 }
-//# sourceMappingURL=turn-failure-copy.js.map

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

@@ -1,7 +1,6 @@
 import type { AgentSubscriber } from "@ag-ui/client";
 export interface TurnUsage {
     turnId: string;
-    /** Open vocabulary: "final" is settled truth; anything else is not. */
     finality: string;
     inputTokens: number;
     outputTokens: number;
@@ -10,30 +9,8 @@ export interface TurnUsage {
     totalTokens: number;
 }
 export declare const EMPTY_TURN_USAGE_ANCHORS: ReadonlyMap<string, TurnUsage>;
-/** Whether a narrowed usage entry is settled truth. */
 export declare function usageIsFinal(usage: TurnUsage): boolean;
-/**
- * Narrow a turn_usage_recorded marker's value. Null means ignore — the
- * contract's "clients MUST ignore events and fields they do not
- * recognize": a malformed count is not honest evidence, and a usage row
- * without its turn id has no durable join.
- */
 export declare function turnUsageAnchorOf(value: unknown): TurnUsage | null;
-/**
- * Reconcile-by-id, never append: a delayed or replayed marker updates the
- * turn's existing entry. A FINAL entry is never demoted by a non-final
- * one (a replay can interleave a future partial behind its final), and
- * an identical re-delivery returns the map unchanged — identity is the
- * publish gate.
- */
 export declare function withTurnUsageAnchored(previous: ReadonlyMap<string, TurnUsage>, usage: TurnUsage): ReadonlyMap<string, TurnUsage>;
-/**
- * A defensive copy for seeding from the resume store: entries that are
- * not a well-formed usage record are dropped rather than rendered — a
- * dropped entry degrades to a hidden number until the next full replay,
- * never a crash.
- */
 export declare function wellFormedTurnUsageAnchorsOf(stored: ReadonlyMap<string, TurnUsage>): ReadonlyMap<string, TurnUsage>;
-/** Records each usage marker's turn id → narrowed totals. */
 export declare function turnUsageRecorder(onUsageAnchored: (usage: TurnUsage) => void): AgentSubscriber;
-//# sourceMappingURL=turn-usage-anchors.d.ts.map

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

@@ -1,37 +1,10 @@
-// The turn-usage anchor model, pure of React: the recorder maps each
-// turn_usage_recorded CUSTOM marker to its turn id, consumers read the
-// map to show honest token totals where a surface is entitled to them
-// (today none in the conversation chrome — slot contract §7), and the
-// resume store holds the map across remounts (the marker never becomes a
-// message, and a snapshot-seeded reconnect replays only past the cursor).
-// An absent entry means usage is UNKNOWN and the number hides cleanly —
-// the wire never carries a client-side estimate, and this module never
-// invents one. finality is an open vocabulary: only "final" reads as
-// settled truth; any other token — "partial" (a
-// call was cut short before the provider reported a count, so the sums
-// are known lower bounds), "stopped" (the member stopped a
-// segment mid-flight and its rows are still landing) or tomorrow's
-// unknowns — reads as not-final.
 import { TURN_USAGE_RECORDED_EVENT_NAME } from "../contract/events.js";
-// Vocabulary tokens are single words by contract; a runaway token is
-// retained capped and resolves to not-final downstream.
 const TOKEN_MAX_CHARS = 64;
-// The one finality token that reads as settled truth — deliberately a
-// plain string, not an enum: finality is an OPEN wire vocabulary (the
-// "open vocabularies, not wire enums" ruling), and this constant
-// exists so the schema default and the truth test can never drift apart.
 const FINAL_FINALITY = "final";
 export const EMPTY_TURN_USAGE_ANCHORS = new Map();
-/** Whether a narrowed usage entry is settled truth. */
 export function usageIsFinal(usage) {
     return usage.finality === FINAL_FINALITY;
 }
-/**
- * Narrow a turn_usage_recorded marker's value. Null means ignore — the
- * contract's "clients MUST ignore events and fields they do not
- * recognize": a malformed count is not honest evidence, and a usage row
- * without its turn id has no durable join.
- */
 export function turnUsageAnchorOf(value) {
     if (typeof value !== "object" || value === null) {
         return null;
@@ -40,10 +13,6 @@ export function turnUsageAnchorOf(value) {
     if (typeof turnId !== "string" || turnId === "") {
         return null;
     }
-    // The wire schema declares finality optional with a server-side
-    // default of "final" — an ABSENT field resolves to that default (the
-    // counts are still honest evidence), while a PRESENT-but-malformed one
-    // is a shape surprise and drops the row like any other.
     const resolvedFinality = finality === undefined ? FINAL_FINALITY : finality;
     if (typeof resolvedFinality !== "string" || resolvedFinality.trim() === "") {
         return null;
@@ -65,13 +34,6 @@ export function turnUsageAnchorOf(value) {
         totalTokens,
     };
 }
-/**
- * Reconcile-by-id, never append: a delayed or replayed marker updates the
- * turn's existing entry. A FINAL entry is never demoted by a non-final
- * one (a replay can interleave a future partial behind its final), and
- * an identical re-delivery returns the map unchanged — identity is the
- * publish gate.
- */
 export function withTurnUsageAnchored(previous, usage) {
     const existing = previous.get(usage.turnId);
     if (existing !== undefined) {
@@ -86,12 +48,6 @@ export function withTurnUsageAnchored(previous, usage) {
     next.set(usage.turnId, usage);
     return next;
 }
-/**
- * A defensive copy for seeding from the resume store: entries that are
- * not a well-formed usage record are dropped rather than rendered — a
- * dropped entry degrades to a hidden number until the next full replay,
- * never a crash.
- */
 export function wellFormedTurnUsageAnchorsOf(stored) {
     const seeded = new Map();
     const entries = stored;
@@ -103,7 +59,6 @@ export function wellFormedTurnUsageAnchorsOf(stored) {
     }
     return seeded;
 }
-/** Records each usage marker's turn id → narrowed totals. */
 export function turnUsageRecorder(onUsageAnchored) {
     return {
         onCustomEvent({ event }) {
@@ -143,4 +98,3 @@ function _isWellFormedUsage(usage) {
         _isCount(cacheWriteTokens) &&
         _isCount(totalTokens));
 }
-//# sourceMappingURL=turn-usage-anchors.js.map

package/dist/core/turns-backfill.d.ts

@@ -1,18 +1,9 @@
 export declare const TURNS_WINDOW = 200;
-/** The turns page cursor both doors' thread-detail GET accepts. */
 export interface TurnsBackfillCursor {
     before_created_at: string;
     before_id: string;
     limit: number;
 }
-/**
- * Walks the turns cursor back from a full newest window until a short
- * page, oldest first. A flaky page degrades instead of blocking: the walk
- * stops and what landed is returned — the oldest splices degrade, the
- * conversation never blocks. `isStale` is re-read after every await; a
- * walk that outlived its adoption (the user opened another thread
- * mid-drain) returns null and the caller adopts nothing.
- */
 export declare function backfilledTurnsOf<T extends {
     id: string;
     created_at: string;
@@ -21,4 +12,3 @@ export declare function backfilledTurnsOf<T extends {
 }>, opts?: {
     isStale?: () => boolean;
 }): Promise<T[] | null>;
-//# sourceMappingURL=turns-backfill.d.ts.map

package/dist/core/turns-backfill.js

@@ -1,19 +1,4 @@
-// The thread detail serves the newest window of a conversation's turns
-// (TURNS_PAGE_SIZE in the contract; a full window means earlier turns
-// exist), but the stream replay is the whole conversation — so the ledger
-// must hold every turn or old runs replay with the wrong (or no) user
-// message spliced in front. A full first window triggers a cursor walk
-// back until a short page. Both doors serve the same window shape, so the
-// widget store and the playground hook walk through this one function.
 export const TURNS_WINDOW = 200;
-/**
- * Walks the turns cursor back from a full newest window until a short
- * page, oldest first. A flaky page degrades instead of blocking: the walk
- * stops and what landed is returned — the oldest splices degrade, the
- * conversation never blocks. `isStale` is re-read after every await; a
- * walk that outlived its adoption (the user opened another thread
- * mid-drain) returns null and the caller adopts nothing.
- */
 export async function backfilledTurnsOf(newestWindow, fetchPage, opts = {}) {
     const turns = [...newestWindow];
     let oldest = turns.length >= TURNS_WINDOW ? turns[0] : undefined;
@@ -40,4 +25,3 @@ export async function backfilledTurnsOf(newestWindow, fetchPage, opts = {}) {
     }
     return turns;
 }
-//# sourceMappingURL=turns-backfill.js.map

package/dist/core/user-turn-ledger.d.ts

@@ -8,18 +8,10 @@ export interface UserTurnRecord {
     attachments: TurnAttachment[];
     createdAt: string;
 }
-/** One user message's turn-side display facts, keyed by the injected
- *  message's stable id — the transcript derivation's side table
- *  (attachments and the timestamp never ride the AG-UI Message). */
 export interface UserTurnMeta {
     attachments: TurnAttachment[];
     createdAt: string;
 }
-/** The ledger surface the injector reads (one injector over
- *  two doors). UserTurnLedger satisfies it structurally; so does the
- *  playground's ledger over the dashboard door. A turn's slice is the
- *  facts the splice needs — its id, whether it is machine-initiated
- *  (kind non-null injects no member message), and the member's text. */
 export interface InjectableTurnLedger {
     turnForRun(runId: string): {
         turnId: string;
@@ -38,10 +30,6 @@ export declare class UserTurnLedger {
     get version(): number;
     merge(turns: ServingAssistantTurn[]): void;
     record(turn: ServingAssistantTurn): void;
-    /** Every known turn's display facts keyed by the injected user
-     *  message's stable id — one side table for both joins (the
-     *  attachments map widened with the timestamp rather than a second
-     *  map of the same rows being published). */
     metaByMessageId(): ReadonlyMap<string, UserTurnMeta>;
     turnForRun(runId: string): UserTurnRecord | null;
     newestTurn(): UserTurnRecord | null;
@@ -54,14 +42,4 @@ export interface UserTurnInjectorCallbacks {
     onUserMessageInjected: (messageId: string) => void;
     onRunSettled: () => void;
 }
-/**
- * Splices each turn's user message in front of its run's replayed output.
- * Every replayed segment opens with RUN_STARTED carrying the run id the
- * turn rows also carry, and the injected id is derived from the turn id,
- * so the splice is idempotent across reconnects and full replays.
- *
- * Attached at connection-epoch construction, strictly before any connect,
- * so every run this agent ever serves carries the spliced user messages.
- */
 export declare function userTurnInjector(ledger: InjectableTurnLedger, callbacks: UserTurnInjectorCallbacks): AgentSubscriber;
-//# sourceMappingURL=user-turn-ledger.d.ts.map