@teaflask/assistant 0.3.0 → 0.7.0

package/dist/core/thread-dispatch-ledger.js

@@ -0,0 +1,303 @@
+import { dispatchIsPaused, dispatchIsRunning, } from "../contract/dispatches.js";
+import { listThreadDispatches } from "../transport/serving-api.js";
+import { ObservableCell } from "./observable-cell.js";
+const POLL_INTERVAL_MS = 10_000;
+const MAX_CONSECUTIVE_READ_FAILURES = 3;
+const READ_BOUND_MS = 2 * POLL_INTERVAL_MS;
+export const EMPTY_THREAD_DISPATCHES = new Map();
+export function newestRowForSession(map, childSessionId) {
+    let newest;
+    for (const dispatch of map.values()) {
+        if (dispatch.child_session_id !== childSessionId) {
+            continue;
+        }
+        if (newest === undefined || dispatch.ordinal > newest.ordinal) {
+            newest = dispatch;
+        }
+    }
+    return newest;
+}
+export class ThreadDispatchLedger {
+    session;
+    cell = new ObservableCell(null);
+    demands = new Map();
+    timer = null;
+    timerThreadId = null;
+    busy = false;
+    readThreadId = null;
+    pendingThreadId = null;
+    failedThreadId = null;
+    consecutiveFailures = 0;
+    constructor(session) {
+        this.session = session;
+    }
+    settleListeners = new Map();
+    setSettleListener(token, listener) {
+        if (listener === null) {
+            this.settleListeners.delete(token);
+        }
+        else {
+            this.settleListeners.set(token, listener);
+        }
+    }
+    pauseListeners = new Map();
+    setPauseListener(token, listener) {
+        if (listener === null) {
+            this.pauseListeners.delete(token);
+        }
+        else {
+            this.pauseListeners.set(token, listener);
+        }
+    }
+    setDemand(token, demand) {
+        const held = this.demands.get(token);
+        if (demand === null) {
+            if (held === undefined) {
+                return;
+            }
+            this.demands.delete(token);
+        }
+        else {
+            if (held?.threadId === demand.threadId &&
+                held.delegated === demand.delegated &&
+                held.stillMoving === demand.stillMoving &&
+                held.joinKey === demand.joinKey) {
+                return;
+            }
+            this.demands.set(token, demand);
+        }
+        this._reconcile();
+    }
+    noteThreadAnswered(threadId) {
+        if (this.failedThreadId !== threadId || this.consecutiveFailures === 0) {
+            return;
+        }
+        this.failedThreadId = null;
+        this.consecutiveFailures = 0;
+        this._reconcile();
+    }
+    refresh(threadId) {
+        if (!this.busy) {
+            return this._readOnce(threadId);
+        }
+        if (this.followUp === null || this.followUpThreadId !== threadId) {
+            this.followUpThreadId = threadId;
+            this.followUp = (this.flight ?? Promise.resolve()).then(() => {
+                this.followUp = null;
+                this.followUpThreadId = null;
+                return this._readOnce(threadId);
+            });
+        }
+        return this.followUp;
+    }
+    followUp = null;
+    followUpThreadId = null;
+    _reconcile() {
+        let threadId = null;
+        let delegated = false;
+        let stillMoving = false;
+        for (const demand of this.demands.values()) {
+            threadId ??= demand.threadId;
+            delegated ||= demand.delegated;
+            stillMoving ||= demand.stillMoving;
+        }
+        if (this.pendingThreadId !== null && this.pendingThreadId !== threadId) {
+            this.pendingThreadId = null;
+        }
+        if (threadId === null || !delegated) {
+            this._stopTimer();
+            return;
+        }
+        if (this.readThreadId !== threadId) {
+            void this._readOnce(threadId);
+        }
+        if (!stillMoving) {
+            this._stopTimer();
+            return;
+        }
+        if (this.timer === null || this.timerThreadId !== threadId) {
+            this._stopTimer();
+            void this._readOnce(threadId);
+            this.timerThreadId = threadId;
+            this.timer = setInterval(() => {
+                void this._readOnce(threadId);
+            }, POLL_INTERVAL_MS);
+        }
+    }
+    _sameAsCurrent(next) {
+        const current = this.cell.get();
+        if (current?.threadId !== next.threadId) {
+            return false;
+        }
+        if (current.map.size !== next.map.size) {
+            return false;
+        }
+        for (const [ordinal, dispatch] of next.map) {
+            const held = current.map.get(ordinal);
+            if (held?.status !== dispatch.status ||
+                held.error !== dispatch.error ||
+                held.updated_at !== dispatch.updated_at) {
+                return false;
+            }
+        }
+        return true;
+    }
+    _stopTimer() {
+        if (this.timer !== null) {
+            clearInterval(this.timer);
+            this.timer = null;
+            this.timerThreadId = null;
+        }
+    }
+    _readOnce(threadId) {
+        if (this.busy) {
+            if (threadId !== this.readThreadId) {
+                this.pendingThreadId = threadId;
+            }
+            return this.flight ?? Promise.resolve();
+        }
+        this.busy = true;
+        this.readThreadId = threadId;
+        this.generation += 1;
+        const generation = this.generation;
+        let settleFlight;
+        const flight = new Promise((resolve) => {
+            settleFlight = resolve;
+        });
+        this.flight = flight;
+        setTimeout(() => {
+            this._releaseBoundedOutRead(threadId, generation);
+            settleFlight();
+        }, READ_BOUND_MS);
+        void this._read(threadId, generation, settleFlight);
+        return flight;
+    }
+    flight = null;
+    generation = 0;
+    _releaseBoundedOutRead(threadId, generation) {
+        if (generation !== this.generation || !this.busy) {
+            return;
+        }
+        this.generation += 1;
+        this.busy = false;
+        this.flight = null;
+        this._noteReadFailure(threadId);
+        this._replayParkedSwitch();
+    }
+    _noteReadFailure(threadId) {
+        this.consecutiveFailures =
+            this.failedThreadId === threadId ? this.consecutiveFailures + 1 : 1;
+        this.failedThreadId = threadId;
+        if (this.consecutiveFailures >= MAX_CONSECUTIVE_READ_FAILURES &&
+            this.timerThreadId === threadId) {
+            this._stopTimer();
+        }
+        if (this.cell.get()?.threadId !== threadId) {
+            this.readThreadId = null;
+        }
+    }
+    _replayParkedSwitch() {
+        const pending = this.pendingThreadId;
+        this.pendingThreadId = null;
+        if (pending !== null && pending !== this.readThreadId) {
+            void this._readOnce(pending);
+        }
+    }
+    adoptedThrough = 0;
+    async _read(threadId, generation, settleFlight) {
+        const live = () => generation === this.generation;
+        try {
+            const dispatches = await listThreadDispatches(this.session, threadId);
+            const adopts = live() ||
+                (generation > this.adoptedThrough &&
+                    (this.readThreadId === threadId || this.readThreadId === null));
+            if (!adopts) {
+                if (this.failedThreadId === threadId) {
+                    this.failedThreadId = null;
+                    this.consecutiveFailures = 0;
+                }
+                return;
+            }
+            this.readThreadId ??= threadId;
+            this.adoptedThrough = generation;
+            const previous = this.cell.get();
+            const next = {
+                threadId,
+                map: new Map(dispatches.map((dispatch) => [dispatch.ordinal, dispatch])),
+            };
+            if (!this._sameAsCurrent(next)) {
+                this.cell.set(next);
+            }
+            this.failedThreadId = null;
+            this.consecutiveFailures = 0;
+            if (_observedASettle(previous, next)) {
+                _fireEach(this.settleListeners);
+            }
+            if (_observedAPause(previous, next)) {
+                _fireEach(this.pauseListeners);
+            }
+        }
+        catch {
+            if (!live()) {
+                return;
+            }
+            this._noteReadFailure(threadId);
+        }
+        finally {
+            if (live()) {
+                this.busy = false;
+                this.flight = null;
+                settleFlight();
+                this._replayParkedSwitch();
+            }
+        }
+    }
+}
+function _fireEach(listeners) {
+    for (const listener of new Set(listeners.values())) {
+        try {
+            listener();
+        }
+        catch {
+        }
+    }
+}
+function _observedAPause(previous, next) {
+    const comparable = previous?.threadId === next.threadId ? previous : null;
+    for (const [ordinal, dispatch] of next.map) {
+        if (!dispatchIsPaused(dispatch)) {
+            continue;
+        }
+        const held = comparable?.map.get(ordinal);
+        if (held === undefined ||
+            !dispatchIsPaused(held) ||
+            held.updated_at !== dispatch.updated_at) {
+            return true;
+        }
+    }
+    return false;
+}
+function _observedASettle(previous, next) {
+    if (previous?.threadId !== next.threadId) {
+        return false;
+    }
+    for (const [ordinal, dispatch] of next.map) {
+        if (dispatchIsRunning(dispatch)) {
+            continue;
+        }
+        const held = previous.map.get(ordinal);
+        if (held === undefined || dispatchIsRunning(held)) {
+            return true;
+        }
+    }
+    return false;
+}
+const _ledgers = new WeakMap();
+export function threadDispatchLedgerFor(session) {
+    let ledger = _ledgers.get(session);
+    if (ledger === undefined) {
+        ledger = new ThreadDispatchLedger(session);
+        _ledgers.set(session, ledger);
+    }
+    return ledger;
+}

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.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,61 +1,99 @@
-/** 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"). */
+/**
+ * Where a call is in its life. "input-streaming" means the agent is still
+ * writing the arguments, "input-available" means they are complete and the call
+ * is running or waiting for approval, "output-available" means it finished with
+ * a result, and "output-error" means it failed; "denied" means the user didn't
+ * approve it, "cancelled" means it never ran, "refused" means Teaflask declined
+ * it before it reached the tool, and "superseded" means it started but was cut
+ * off when the run restarted, so its result never arrived.
+ */
 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. */
+/**
+ * Server-supplied display details for one tool call, namely its row's label,
+ * icon and view.
+ */
 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. */
+    /**
+     * A few words the agent wrote saying what the step is for. When present it
+     * is the row's label in every state, followed by a short state word if the
+     * call failed, was not approved, didn't run, was declined or didn't finish.
+     */
     caption?: string;
+    /** The row's label while the call runs, used when there is no caption. */
     progressText?: string;
+    /**
+     * The row's label once the call succeeds, used when there is no caption.
+     */
     completeText?: string;
-    /** Authored failure copy for output-error; never success copy. */
+    /** The row's label when the call fails, used when there is no caption. */
     errorText?: string;
-    /** Semantic icon token, verbatim from the wire's open vocabulary; unknown
-     *  values resolve to "generic" at presentation time, never here. */
+    /**
+     * The kind of work the call is, one of TOOL_CALL_ICONS. Any other value
+     * shows the generic icon.
+     */
     icon?: string;
-    /** The tool-view reference (tool-views.md): an opaque key plus the
-     *  contract version it targets — meaningless apart, so merged atomically. */
+    /**
+     * The view the server names for this call, as a key and version. A registry
+     * entry under that exact key with the same version is preferred over a
+     * match by tool name; Teaflask's own tools name built-in views with keys
+     * starting `teaflask.`.
+     */
     view?: {
         key: string;
         version: number;
     };
 }
+/**
+ * One tool or action call as a transcript row renders it. A custom `toolRow`
+ * receives it as `view`, and toolCallPresentationOf takes it.
+ */
 export interface ToolCallViewModel {
+    /** The tool's name. For an action, `action__<slug>`. */
     toolName: string;
+    /** Where the call is in its life. See ToolCallState. */
     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. */
+    /** Unique id of the call, when known. */
     toolCallId?: string;
-    /** The streamed arguments, pretty-printed by the caller. */
+    /**
+     * The arguments as pretty-printed JSON, or the raw text while it is still
+     * streaming in.
+     */
     input: string;
-    /** The raw streamed argument JSON text, for the tool-view call's `args`. */
+    /** The arguments as raw JSON text, exactly as streamed. */
     argsText?: string;
-    /** The tool result, verbatim from the wire; absent until it lands. */
+    /**
+     * The raw result text. Undefined until the call finishes, and withheld for
+     * calls that failed, were not approved, didn't run, were declined or had
+     * their result replaced by a preview.
+     */
     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. */
+    /**
+     * True when the result was too large for the agent and was replaced by a
+     * shortened preview. `output` is then withheld.
+     */
     offloaded?: boolean;
+    /** Why the call failed, set when it failed. */
     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. */
+    /**
+     * Teaflask's reason for declining the call, set only when `state` is
+     * "refused".
+     */
     refusalText?: string;
+    /**
+     * The server's display details for the call (label text, icon, view), when
+     * it sent any.
+     */
     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. */
+    /**
+     * The JSON Schema of the tool's arguments, when it declared one. Undefined
+     * otherwise, never `{}`.
+     */
     argsSchema?: Record<string, unknown>;
-    /** The registered success-result schema; same absence rules. */
+    /**
+     * The JSON Schema of the tool's successful result, when it declared one.
+     * Undefined otherwise.
+     */
     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