@teaflask/assistant 0.3.0 → 0.6.0

package/dist/core/time-labels.d.ts

@@ -1,18 +1,7 @@
-/** The thread list's recency window (calendar days), shared verbatim. */
 export declare const RECENT_WINDOW_DAYS = 7;
-/** A local midnight counted back in CALENDAR days, not 24-hour blocks: on
- *  the two days a year the clocks move, yesterday is 23 or 25 hours long,
- *  and fixed-day subtraction would slide every boundary. The Date
- *  constructor normalises an out-of-range day across months and years. */
 export declare function startOfLocalDayMs(now: Date, daysBack: number): number;
 export interface ConversationalTime {
-    /** "Monday 7:19 PM" inside the weekday label window; "Sep 7,
-     *  7:19 PM" outside it ("Sep 7, 2025, 7:19 PM" across a year
-     *  boundary). */
     label: string;
-    /** "September 7, 2026 at 7:19 PM" (locale-shaped) — the <time>
-     *  title's full spelling. */
     full: string;
 }
 export declare function conversationalTimeOf(iso: string, nowMs?: number): ConversationalTime | null;
-//# sourceMappingURL=time-labels.d.ts.map

package/dist/core/time-labels.js

@@ -1,28 +1,8 @@
-// Clock-time labels for the conversation surface: a user bubble
-// carries its turn's created_at as "Monday 7:19 PM" inside the weekday
-// label window and as a dated form ("Sep 7, 7:19 PM"; the year added once
-// it differs from now's) outside it — a bare weekday re-read weeks later
-// reads as THIS past weekday. The recency rule is the thread list's own
-// (RECENT_WINDOW_DAYS and the DST-safe startOfLocalDayMs — one spelling,
-// never two); the weekday LABEL bound is one day tighter. A clock reading,
-// not a cost — distinct from segment-timing's DURATION register. Unparsable
-// → null (the caller renders nothing); a future stamp reads as recent.
-/** The thread list's recency window (calendar days), shared verbatim. */
 export const RECENT_WINDOW_DAYS = 7;
-/** The weekday LABEL's own bound: seven unique weekday names, so seven
- *  calendar days — D-6 … D0. Deliberately NOT derived from
- *  RECENT_WINDOW_DAYS: the bucket heading may widen, but a wider weekday
- *  window would re-admit the D-7 collision (a week-old stamp, today's name). */
 const WEEKDAY_LABEL_DAYS_BACK = 6;
-/** A local midnight counted back in CALENDAR days, not 24-hour blocks: on
- *  the two days a year the clocks move, yesterday is 23 or 25 hours long,
- *  and fixed-day subtraction would slide every boundary. The Date
- *  constructor normalises an out-of-range day across months and years. */
 export function startOfLocalDayMs(now, daysBack) {
     return new Date(now.getFullYear(), now.getMonth(), now.getDate() - daysBack).getTime();
 }
-// Module-cached: Intl.DateTimeFormat construction is the expensive
-// half, and every bubble in a long transcript formats through these.
 let recentFormat = null;
 let datedFormat = null;
 let datedWithYearFormat = null;
@@ -39,8 +19,6 @@ export function conversationalTimeOf(iso, nowMs = Date.now()) {
         timeStyle: "short",
     });
     const full = fullFormat.format(date);
-    // Inside the weekday label window (future included — recent, honestly):
-    // the register's own cap, never arithmetic on the bucket constant (D-7).
     if (parsed >= startOfLocalDayMs(now, WEEKDAY_LABEL_DAYS_BACK)) {
         recentFormat ??= new Intl.DateTimeFormat(undefined, {
             weekday: "long",
@@ -67,4 +45,3 @@ export function conversationalTimeOf(iso, nowMs = Date.now()) {
     });
     return { label: datedWithYearFormat.format(date), full };
 }
-//# sourceMappingURL=time-labels.js.map

package/dist/core/tool-call-display-anchors.d.ts

@@ -1,49 +1,11 @@
 import type { AgentSubscriber } from "@ag-ui/client";
 import type { ToolCallDisplay } from "./tool-call-display.js";
 export declare const EMPTY_TOOL_CALL_DISPLAY_ANCHORS: ReadonlyMap<string, ToolCallDisplay>;
-/**
- * Narrow a tool_call_annotated marker's value. Null means ignore — the
- * contract's "clients MUST ignore events and fields they do not
- * recognize": a blank text is no sentence, and a display carrying no
- * recognized field annotates nothing. `kind` left the wire and the
- * client model: it is no longer a recognized field
- * of this contract, so a present `kind` of any value is ignored like
- * any other unrecognized field — never a display-blanking gate. A
- * future display variant arrives as a new field or marker; views are
- * the generative-UI door.
- */
 export declare function toolCallDisplayAnchorOf(value: unknown): {
     toolCallId: string;
     display: ToolCallDisplay;
 } | null;
-/**
- * Idempotent per-field merge: one call's copy legitimately arrives as
- * more than one marker (the progress sentence at start-of-run, the
- * completion sentence at finish, a tool body's richer completion first),
- * and every replay re-delivers them all. First non-absent value per
- * field wins — re-applying the same sequence changes nothing, and a
- * no-op merge returns the map unchanged: identity is the publish gate.
- */
 export declare function withToolCallDisplayAnchored(previous: ReadonlyMap<string, ToolCallDisplay>, toolCallId: string, display: ToolCallDisplay): ReadonlyMap<string, ToolCallDisplay>;
-/**
- * A defensive copy for seeding transcript state from the resume store:
- * entries that are not a string keyed text display are dropped rather
- * than rendered (or crashed on). The store is in-memory today, so every
- * entry passed the narrower — this seam is where any future persisted
- * form of the store must degrade gracefully: a dropped display falls
- * back to the mechanical headline until the next full replay.
- */
 export declare function wellFormedToolCallDisplayAnchorsOf(stored: ReadonlyMap<string, ToolCallDisplay>): ReadonlyMap<string, ToolCallDisplay>;
-/**
- * Narrow the turn record's `pending_approval_displays` map —
- * the REST recovery read's display annotations, keyed by tool call id,
- * the same `tool_call_annotated` content the stream replays. Distrusts
- * the wire exactly as the stream recorder does by reusing its narrower
- * (REST nulls become absent fields, so downstream `undefined` semantics
- * — an absent icon resolves generic — stay sound); a malformed entry is
- * dropped, never rendered or crashed on.
- */
 export declare function restDisplayAnchorsOf(value: unknown): ReadonlyMap<string, ToolCallDisplay>;
-/** Records each annotated call's toolCallId → display envelope. */
 export declare function toolCallDisplayRecorder(onDisplayAnchored: (toolCallId: string, display: ToolCallDisplay) => void): AgentSubscriber;
-//# sourceMappingURL=tool-call-display-anchors.d.ts.map

package/dist/core/tool-call-display-anchors.js

@@ -1,38 +1,8 @@
-// The tool-call display anchor model, pure of React: the recorder maps
-// each tool_call_annotated CUSTOM marker to its toolCallId, the
-// transcript reads the map to headline the call with the backend's own
-// copy, and the resume store holds the map across remounts. The
-// indirection exists because a CUSTOM marker never becomes a message —
-// like the tool-error anchors, this map is the copy's only home on the
-// client, and it must outlive the epoch: a snapshot-seeded reconnect
-// replays only past the cursor, so historical rows keep their copy from
-// here alone.
 import { TOOL_CALL_ANNOTATED_EVENT_NAME } from "../contract/events.js";
-// The sentences are backend-authored (already clipped at the source),
-// but the narrower distrusts the wire by contract; a runaway sentence is
-// retained capped, never unbounded.
 const DISPLAY_TEXT_MAX_CHARS = 500;
-// Vocabulary tokens (icon) are single words by contract; a
-// runaway token is retained capped like a sentence, and an unknown
-// token resolves to its documented fallback downstream.
 const TOKEN_MAX_CHARS = 64;
-// A view key is an opaque registry handle (the tool-views contract);
-// one this long could never have been registered, so an over-cap key
-// drops the whole ref rather than clipping into a key that matches
-// nothing.
 const VIEW_KEY_MAX_CHARS = 128;
 export const EMPTY_TOOL_CALL_DISPLAY_ANCHORS = new Map();
-/**
- * Narrow a tool_call_annotated marker's value. Null means ignore — the
- * contract's "clients MUST ignore events and fields they do not
- * recognize": a blank text is no sentence, and a display carrying no
- * recognized field annotates nothing. `kind` left the wire and the
- * client model: it is no longer a recognized field
- * of this contract, so a present `kind` of any value is ignored like
- * any other unrecognized field — never a display-blanking gate. A
- * future display variant arrives as a new field or marker; views are
- * the generative-UI door.
- */
 export function toolCallDisplayAnchorOf(value) {
     if (typeof value !== "object" || value === null) {
         return null;
@@ -80,14 +50,6 @@ export function toolCallDisplayAnchorOf(value) {
     }
     return { toolCallId, display: narrowed };
 }
-/**
- * Idempotent per-field merge: one call's copy legitimately arrives as
- * more than one marker (the progress sentence at start-of-run, the
- * completion sentence at finish, a tool body's richer completion first),
- * and every replay re-delivers them all. First non-absent value per
- * field wins — re-applying the same sequence changes nothing, and a
- * no-op merge returns the map unchanged: identity is the publish gate.
- */
 export function withToolCallDisplayAnchored(previous, toolCallId, display) {
     const existing = previous.get(toolCallId);
     if (existing === undefined) {
@@ -126,9 +88,6 @@ export function withToolCallDisplayAnchored(previous, toolCallId, display) {
     if (icon !== undefined) {
         merged.icon = icon;
     }
-    // The view ref merges ATOMICALLY: the first non-absent whole
-    // {key, version} wins — a key from one marker must never weld to a
-    // version from another.
     const view = existing.view ?? display.view;
     if (view !== undefined) {
         merged.view = view;
@@ -137,18 +96,8 @@ export function withToolCallDisplayAnchored(previous, toolCallId, display) {
     next.set(toolCallId, merged);
     return next;
 }
-/**
- * A defensive copy for seeding transcript state from the resume store:
- * entries that are not a string keyed text display are dropped rather
- * than rendered (or crashed on). The store is in-memory today, so every
- * entry passed the narrower — this seam is where any future persisted
- * form of the store must degrade gracefully: a dropped display falls
- * back to the mechanical headline until the next full replay.
- */
 export function wellFormedToolCallDisplayAnchorsOf(stored) {
     const seeded = new Map();
-    // The narrowing deliberately distrusts the map's own types: this seam
-    // is what turns a stale shape into a missing display, never a crash.
     const entries = stored;
     for (const [toolCallId, display] of entries) {
         if (typeof toolCallId !== "string" || !_isWellFormedDisplay(display)) {
@@ -158,15 +107,6 @@ export function wellFormedToolCallDisplayAnchorsOf(stored) {
     }
     return seeded;
 }
-/**
- * Narrow the turn record's `pending_approval_displays` map —
- * the REST recovery read's display annotations, keyed by tool call id,
- * the same `tool_call_annotated` content the stream replays. Distrusts
- * the wire exactly as the stream recorder does by reusing its narrower
- * (REST nulls become absent fields, so downstream `undefined` semantics
- * — an absent icon resolves generic — stay sound); a malformed entry is
- * dropped, never rendered or crashed on.
- */
 export function restDisplayAnchorsOf(value) {
     const anchors = new Map();
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -183,7 +123,6 @@ export function restDisplayAnchorsOf(value) {
     }
     return anchors;
 }
-/** Records each annotated call's toolCallId → display envelope. */
 export function toolCallDisplayRecorder(onDisplayAnchored) {
     return {
         onCustomEvent({ event }) {
@@ -203,19 +142,12 @@ function _displayTextOf(text) {
     }
     return text.slice(0, DISPLAY_TEXT_MAX_CHARS);
 }
-/** A vocabulary token (icon): a non-blank string, retained capped.
- *  Unknown tokens survive verbatim — the presentation resolver owns the
- *  fallback, so an older build's store never destroys a newer wire
- *  value. */
 function _tokenOf(token) {
     if (typeof token !== "string" || token.trim() === "") {
         return undefined;
     }
     return token.slice(0, TOKEN_MAX_CHARS);
 }
-/** The view ref narrows whole or not at all — key and version are
- *  meaningless apart, so any malformed half drops the entire ref (the
- *  package default rendering takes over, never a mismatched pair). */
 function _viewRefOf(view) {
     if (typeof view !== "object" || view === null) {
         return undefined;
@@ -237,11 +169,6 @@ function _isWellFormedDisplay(display) {
     if (typeof display !== "object" || display === null) {
         return false;
     }
-    // This predicate asserts the CLIENT model — every recognized field
-    // well-typed or absent, at least one present. Extra properties (a
-    // future persisted store's stale `kind`, say) are tolerated exactly
-    // as the wire narrower tolerates unrecognized fields; a malformed
-    // recognized field drops the entry fail-closed.
     const { caption, progressText, completeText, errorText, icon, view } = display;
     const fieldsAreWellTypedOrAbsent = (caption === undefined || typeof caption === "string") &&
         (progressText === undefined || typeof progressText === "string") &&
@@ -257,4 +184,3 @@ function _isWellFormedDisplay(display) {
             icon !== undefined ||
             view !== undefined));
 }
-//# sourceMappingURL=tool-call-display-anchors.js.map

package/dist/core/tool-call-display.d.ts

@@ -1,23 +1,10 @@
-/** Protocol states from the AG-UI event trail — the AI SDK vocabulary
- *  minus the approval states, plus four the SDK never names: cancelled,
- *  superseded, refused and denied
- *  (docs/tool-call-contract.md, "States"). */
 export type ToolCallState = "input-streaming" | "input-available" | "output-available" | "output-error" | "denied" | "cancelled" | "refused" | "superseded";
-/** Backend-authored display metadata for one tool call — the client mirror
- *  of the wire's six-field envelope; absent on unannotated tools. */
 export interface ToolCallDisplay {
-    /** The model's own words for the step: the row's label in
-     *  every state; the shimmer or a quiet state word carries the state. */
     caption?: string;
     progressText?: string;
     completeText?: string;
-    /** Authored failure copy for output-error; never success copy. */
     errorText?: string;
-    /** Semantic icon token, verbatim from the wire's open vocabulary; unknown
-     *  values resolve to "generic" at presentation time, never here. */
     icon?: string;
-    /** The tool-view reference (tool-views.md): an opaque key plus the
-     *  contract version it targets — meaningless apart, so merged atomically. */
     view?: {
         key: string;
         version: number;
@@ -26,36 +13,16 @@ export interface ToolCallDisplay {
 export interface ToolCallViewModel {
     toolName: string;
     state: ToolCallState;
-    /** The wire's tool call id; optional because presentation-only callers
-     *  (subagent presence) have none — the tool-view call carries "" then,
-     *  and the row stamps its data-tf-tool-call-id hook only when present. */
     toolCallId?: string;
-    /** The streamed arguments, pretty-printed by the caller. */
     input: string;
-    /** The raw streamed argument JSON text, for the tool-view call's `args`. */
     argsText?: string;
-    /** The tool result, verbatim from the wire; absent until it lands. */
     output?: string;
-    /** True when the wire's result was the context offloader's model-facing
-     *  replacement: `output` is withheld; the row says the result was shortened. */
     offloaded?: boolean;
     errorText?: string;
-    /** The door's own refusal sentence, present only on refused
-     *  rows — the row's reason in neutral ink, never in the Error pane. */
     refusalText?: string;
     display?: ToolCallDisplay;
-    /** The tool's registered argument schema, verbatim from the wire; absent when none
-     *  was declared, never `{}`. Forwarded to the tool-view call's argsSchema, never interpreted here. */
     argsSchema?: Record<string, unknown>;
-    /** The registered success-result schema; same absence rules. */
     resultSchema?: Record<string, unknown>;
 }
-/** "create_support_ticket" → "create support ticket": mechanical, never
- *  title-cased — reads the name's SPELLING, never its meaning. */
 export declare function humanizedToolName(name: string): string;
-/** The row's headline by the fallback ladder: the backend's display text
- *  when the wire sent one → the humanized tool name in a protocol-state verb
- *  frame ("Running X…", "Ran X", "X failed"). The frame comes from the STATE,
- *  never the tool's meaning. Per-state frames: docs/tool-call-contract.md. */
 export declare function toolRowHeadlineOf(view: ToolCallViewModel): string;
-//# sourceMappingURL=tool-call-display.d.ts.map

package/dist/core/tool-call-display.js

@@ -1,16 +1,6 @@
-// The tool-call rendering contract: tool NAME, PROTOCOL state, raw I/O and
-// an optional backend-authored display envelope. The package knows the
-// protocol, never a CUSTOMER's tool catalog: no tool-name switch lives
-// client-side; per-tool parsing exists only inside the rung-3 built-in views.
-/** "create_support_ticket" → "create support ticket": mechanical, never
- *  title-cased — reads the name's SPELLING, never its meaning. */
 export function humanizedToolName(name) {
     return name.replace(/[-_]+/g, " ").trim();
 }
-/** The row's headline by the fallback ladder: the backend's display text
- *  when the wire sent one → the humanized tool name in a protocol-state verb
- *  frame ("Running X…", "Ran X", "X failed"). The frame comes from the STATE,
- *  never the tool's meaning. Per-state frames: docs/tool-call-contract.md. */
 export function toolRowHeadlineOf(view) {
     const caption = view.display?.caption;
     if (caption !== undefined) {
@@ -40,8 +30,6 @@ export function toolRowHeadlineOf(view) {
             return `Didn't finish ${name}`;
     }
 }
-/** A caption is intent, not a claim, so it stays the label in every state;
- *  off the running/done path the state rides as a quiet word after it. */
 function _captionedHeadlineOf(caption, state) {
     switch (state) {
         case "input-streaming":
@@ -60,10 +48,6 @@ function _captionedHeadlineOf(caption, state) {
             return `${caption} · didn't finish`;
     }
 }
-/** The display slot per state: completion copy only for a call that
- *  completed; output-error takes authored error copy, else the "X failed"
- *  frame. Denied, cancelled, refused and superseded refuse copy — the
- *  progress sentence predates the decision (docs/tool-call-contract.md). */
 function _displayTextFor(view) {
     switch (view.state) {
         case "input-streaming":
@@ -83,4 +67,3 @@ function _displayTextFor(view) {
             return undefined;
     }
 }
-//# sourceMappingURL=tool-call-display.js.map

package/dist/core/tool-call-presentation.d.ts

@@ -1,39 +1,15 @@
 import type { ToolCallState, ToolCallViewModel } from "./tool-call-display.js";
 import type { ToolViewRegistry, ToolViewResolution } from "./tool-view.js";
-/** The semantic icon vocabulary — operational meaning, never a brand or
- *  a tool name. Open on the wire; unknown values resolve to "generic". */
 export declare const TOOL_CALL_ICONS: readonly ["search", "file", "terminal", "question", "memory", "delegation", "routine", "todo", "navigation", "generic"];
 export type ToolCallIcon = (typeof TOOL_CALL_ICONS)[number];
-/**
- * One tool call's resolved presentation — every consumer's single source.
- * Slots, and who reads them: the transcript row takes headline, icon and
- * status; resolved-action and provenance summaries take settledSummary;
- * subagent presence takes currentWorkLabel; toolView is the resolution
- * ladder's answer (tool-views.md) and the row's whole body — no raw
- * payload disclosure exists. The approval banner reads no slot.
- */
 export interface ToolCallPresentation {
-    /** The transcript row's words — the fallback ladder's answer:
-     *  backend copy when the wire sent it, the mechanical
-     *  protocol-state frame otherwise. */
     headline: string;
     icon: ToolCallIcon;
     status: ToolCallState;
-    /** The line a settled call leaves behind — BY DEFINITION the resolved
-     *  headline (the ladder's settled arms are the summary: completion
-     *  copy, error copy or the failed frame, the refusal frame, the
-     *  not-approved frame). The slot is named separately so summary
-     *  consumers bind here, not to the row's wording; if the two are ever
-     *  meant to differ, the divergence lands in this one resolver, never
-     *  in a consumer. */
     settledSummary: string;
-    /** The present-progressive "what it is doing now" line — the
-     *  ladder's RUNNING arm regardless of the view's own state, so
-     *  consumers need no state guard of their own. */
     currentWorkLabel: string;
     toolView: ToolViewResolution;
 }
 export declare function toolCallPresentationOf(view: ToolCallViewModel, registry?: ToolViewRegistry, options?: {
     awaitingDecision?: boolean;
 }): ToolCallPresentation;
-//# sourceMappingURL=tool-call-presentation.d.ts.map

package/dist/core/tool-call-presentation.js

@@ -1,16 +1,7 @@
-// One presenter, many consumers: the transcript row, the
-// resolved-action summary, the subagent current-work label and the
-// tool-view slot all read ONE resolved presentation — consumers select
-// slots, none reinterprets the raw display envelope (that would fork the
-// fallback ladder). Unknown wire vocabulary collapses to the documented
-// fallbacks here and only here, so a stored display survives a vocabulary
-// the build predates. React-free by design.
 import { toolRowHeadlineOf } from "./tool-call-display.js";
 import { toolResultEnvelopePayloadOf } from "./tool-result-envelope.js";
 import { STEP_CAPTION_ARG_KEY, withoutStepCaption } from "./step-caption.js";
 import { resolvedToolViewsOf } from "./tool-view.js";
-/** The semantic icon vocabulary — operational meaning, never a brand or
- *  a tool name. Open on the wire; unknown values resolve to "generic". */
 export const TOOL_CALL_ICONS = [
     "search",
     "file",
@@ -26,13 +17,6 @@ export const TOOL_CALL_ICONS = [
 export function toolCallPresentationOf(view, registry, options) {
     const headline = toolRowHeadlineOf(view);
     const resolved = resolvedToolViewsOf(view.display?.view, view.toolName, registry);
-    // The call is assembled LAZILY, memoized per presentation, and its
-    // RESULT structures lazier still (see _toolViewCallOf): the row's slot
-    // reads the call on every render, the default view reads args alone,
-    // and a transcript re-renders every row per streamed token — so a
-    // rung-4 row never structures its result, and the parse memo holds
-    // only what a mounted view read. The getters keep the single-
-    // resolution-point law: assembly still happens only here, on first read.
     let call;
     const awaitingDecision = options?.awaitingDecision === true;
     return {
@@ -58,20 +42,6 @@ function _iconOf(token) {
     }
     return "generic";
 }
-/**
- * The tool-view call, assembled once here: parsing wire text into
- * renderable data is resolution, and it must not fork per consumer.
- * `context.themeMode` is deliberately NOT assembled here — it is the
- * slot's ambient fact (use-resolved-theme-mode.ts), not replay data.
- * `result` and `truncated` are lazy accessors over the verbatim
- * resultText: a settled result can run to the door's 20k and most rows
- * (rung 4, whose default view reads args alone) never look at it, so
- * the structuring parse happens on first read and once per call.
- * IDENTITY LAW: every value on the call is identity-stable across a
- * re-render with unchanged source, because the mount slot's structural
- * delivery guard rests on it. The member-by-member census:
- * docs/tool-call-contract.md, "The identity law".
- */
 function _toolViewCallOf(view, awaitingDecision) {
     const call = {
         toolName: view.toolName,
@@ -107,8 +77,6 @@ function _toolViewCallOf(view, awaitingDecision) {
     if (view.refusalText !== undefined) {
         call.refusalText = view.refusalText;
     }
-    // Absent stays absent: a tool with no declared schema hands
-    // the view `undefined`, never `{}` and never an invented one.
     if (view.argsSchema !== undefined) {
         call.argsSchema = view.argsSchema;
     }
@@ -117,11 +85,6 @@ function _toolViewCallOf(view, awaitingDecision) {
     }
     return call;
 }
-/** The tool-result/v1 envelope unwrap (core/tool-result-envelope.ts): a
- *  {payload} box structures, null refuses — the wire's bytes were
- *  degraded to fit the size cap, and a complete-looking `result` over a
- *  cut payload would be a wrong claim; the honest flag rides instead,
- *  beside the verbatim resultText. Non-JSON output structures nothing. */
 function _structuredResultOf(output) {
     const parsed = _jsonDocumentOf(output);
     if (parsed === undefined) {
@@ -130,11 +93,7 @@ function _structuredResultOf(output) {
     const box = toolResultEnvelopePayloadOf(parsed.document);
     return box === null ? { truncated: true } : { result: box.payload };
 }
-/** The one shared empty-args identity (see the identity law above). */
 const EMPTY_ARGS = Object.freeze({});
-/** The streamed arguments, parsed whole: a JSON record when complete,
- *  EMPTY_ARGS while the tail is still arriving or when the text is not
- *  a record — a view must never see half an argument object. */
 function _argsOf(argsText) {
     const parsed = _jsonDocumentOf(argsText);
     if (parsed === undefined || !_isRecord(parsed.document)) {
@@ -145,9 +104,6 @@ function _argsOf(argsText) {
     }
     return _captionlessArgsOf(parsed.document);
 }
-// The reserved-key strip keeps the identity law: keyed on the memoized
-// document, one caption-less copy per source text, the shared document
-// itself never mutated.
 const _captionlessArgs = new WeakMap();
 function _captionlessArgsOf(document) {
     const memoized = _captionlessArgs.get(document);
@@ -159,15 +115,8 @@ function _captionlessArgsOf(document) {
     _captionlessArgs.set(document, args);
     return args;
 }
-// The parse memo: identity by construction, keyed on the source text, so
-// "same source text" and "same object" are one fact. The memoized document
-// is SHARED across readers (never mutate what a call hands you); failures
-// are not memoized; the cap is a wholesale reset, not an LRU
-// (docs/tool-call-contract.md, "The parse memo").
 const JSON_MEMO_MAX_ENTRIES = 512;
 const _jsonMemo = new Map();
-/** JSON.parse behind a box, so a legitimately-null document stays
- *  distinguishable from "not JSON". */
 function _jsonDocumentOf(text) {
     const memoized = _jsonMemo.get(text);
     if (memoized !== undefined) {
@@ -188,4 +137,3 @@ function _jsonDocumentOf(text) {
 function _isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=tool-call-presentation.js.map

package/dist/core/tool-cancel-anchors.d.ts

@@ -3,4 +3,3 @@ export declare const toolCallCancelledOf: (event: unknown) => boolean;
 export declare const withToolCancelAnchored: (previous: ReadonlySet<string>, toolCallId: string) => ReadonlySet<string>;
 export declare const wellFormedToolCancelAnchorsOf: (stored: ReadonlySet<string>) => ReadonlySet<string>;
 export declare const toolCancelRecorder: (onAnchored: (toolCallId: string) => void) => import("@ag-ui/client").AgentSubscriber;
-//# sourceMappingURL=tool-cancel-anchors.d.ts.map

package/dist/core/tool-cancel-anchors.js

@@ -1,8 +1,3 @@
-// The tool-cancel anchor set: a cancelled TOOL_CALL_RESULT's content is
-// the model-facing cancellation text, so the transcript reads this set to
-// light the call's cancelled state and keep that text off the Result
-// pane. One binding of the shared boolean-flag family — see
-// tool-flag-anchors.ts for the model and the strip-and-lift rationale.
 import { toolFlagAnchorsOf } from "./tool-flag-anchors.js";
 const anchors = toolFlagAnchorsOf("cancelled");
 export const EMPTY_TOOL_CANCEL_ANCHORS = anchors.empty;
@@ -10,4 +5,3 @@ export const toolCallCancelledOf = anchors.flagOf;
 export const withToolCancelAnchored = anchors.withAnchored;
 export const wellFormedToolCancelAnchorsOf = anchors.wellFormedOf;
 export const toolCancelRecorder = anchors.recorderOf;
-//# sourceMappingURL=tool-cancel-anchors.js.map

package/dist/core/tool-decision-anchors.d.ts

@@ -1,26 +1,6 @@
 import type { AgentSubscriber } from "@ag-ui/client";
 export declare const EMPTY_TOOL_DECISION_ANCHORS: ReadonlySet<string>;
-/**
- * Narrow a CUSTOM event to the tool call id it marks as decision-bearing,
- * or null: an approval_requested with a tool_call_id, or a
- * tool_execution_requested whose request.kind is member-answerable. Anything malformed is ignored — the contract's
- * "clients MUST ignore events and fields they do not recognize". An
- * unanchored ask (tool_call_id null — a wire that named no call) marks
- * nothing: there is no row to hold open.
- */
 export declare function toolDecisionAnchorOf(name: string, value: unknown): string | null;
-/**
- * Idempotent anchor merge: every connection replays the stream from its
- * boundary (and StrictMode aborts and reruns the first connection), so
- * the same marker can arrive more than once per mount. A repeat returns
- * the set unchanged — identity is the publish gate.
- */
 export declare function withToolDecisionAnchored(previous: ReadonlySet<string>, toolCallId: string): ReadonlySet<string>;
-/**
- * A defensive copy for seeding transcript state from the resume store:
- * non-string members are dropped rather than rendered (or crashed on) —
- * a dropped anchor reappears on the next full replay.
- */
 export declare function wellFormedToolDecisionAnchorsOf(stored: ReadonlySet<string>): ReadonlySet<string>;
 export declare function toolDecisionRecorder(onDecisionAnchored: (toolCallId: string) => void): AgentSubscriber;
-//# sourceMappingURL=tool-decision-anchors.d.ts.map

package/dist/core/tool-decision-anchors.js

@@ -1,22 +1,6 @@
-// The tool-decision anchor set: the durable record that a call
-// carried a member decision, keyed by tool_call_id. The placement hold
-// reads THIS, never the pruned live card stores — the hold window is the
-// TURN. A pure fold over replayed CUSTOM markers: docs/decision-anchors.md.
 import { APPROVAL_REQUESTED_EVENT_NAME, TOOL_EXECUTION_REQUESTED_EVENT_NAME, } from "../contract/events.js";
-// The kinds leaf, never execution-handlers: this module is a value
-// export of the ./transcript projection entry, and the handlers module
-// drags the transport/reader/affordance layers that entry's law bans
-// (tests/bundle-closure.test.ts pins it).
 import { MEMBER_ANSWERABLE_KINDS } from "./execution-kinds.js";
 export const EMPTY_TOOL_DECISION_ANCHORS = new Set();
-/**
- * Narrow a CUSTOM event to the tool call id it marks as decision-bearing,
- * or null: an approval_requested with a tool_call_id, or a
- * tool_execution_requested whose request.kind is member-answerable. Anything malformed is ignored — the contract's
- * "clients MUST ignore events and fields they do not recognize". An
- * unanchored ask (tool_call_id null — a wire that named no call) marks
- * nothing: there is no row to hold open.
- */
 export function toolDecisionAnchorOf(name, value) {
     if (typeof value !== "object" || value === null) {
         return null;
@@ -37,21 +21,12 @@ export function toolDecisionAnchorOf(name, value) {
             return null;
         }
         const kind = request.kind;
-        // MEMBER_ANSWERABLE_KINDS, not the single ask kind: the anchor marks
-        // "a member decision rode this call", and a future member-answerable
-        // kind must hold its row without a second edit here.
         return typeof kind === "string" && MEMBER_ANSWERABLE_KINDS.has(kind)
             ? toolCallId
             : null;
     }
     return null;
 }
-/**
- * Idempotent anchor merge: every connection replays the stream from its
- * boundary (and StrictMode aborts and reruns the first connection), so
- * the same marker can arrive more than once per mount. A repeat returns
- * the set unchanged — identity is the publish gate.
- */
 export function withToolDecisionAnchored(previous, toolCallId) {
     if (previous.has(toolCallId)) {
         return previous;
@@ -60,11 +35,6 @@ export function withToolDecisionAnchored(previous, toolCallId) {
     next.add(toolCallId);
     return next;
 }
-/**
- * A defensive copy for seeding transcript state from the resume store:
- * non-string members are dropped rather than rendered (or crashed on) —
- * a dropped anchor reappears on the next full replay.
- */
 export function wellFormedToolDecisionAnchorsOf(stored) {
     const seeded = new Set();
     for (const toolCallId of stored) {
@@ -84,4 +54,3 @@ export function toolDecisionRecorder(onDecisionAnchored) {
         },
     };
 }
-//# sourceMappingURL=tool-decision-anchors.js.map