@teaflask/assistant 0.0.0 → 0.3.0

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

@@ -0,0 +1,260 @@
+// 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;
+    }
+    const { tool_call_id: toolCallId, display } = value;
+    if (typeof toolCallId !== "string" || toolCallId === "") {
+        return null;
+    }
+    if (typeof display !== "object" || display === null) {
+        return null;
+    }
+    const { caption, progress_text, complete_text, error_text, icon, view } = display;
+    const narrowed = {};
+    const captionText = _displayTextOf(caption);
+    if (captionText !== undefined) {
+        narrowed.caption = captionText;
+    }
+    const progressText = _displayTextOf(progress_text);
+    if (progressText !== undefined) {
+        narrowed.progressText = progressText;
+    }
+    const completeText = _displayTextOf(complete_text);
+    if (completeText !== undefined) {
+        narrowed.completeText = completeText;
+    }
+    const errorText = _displayTextOf(error_text);
+    if (errorText !== undefined) {
+        narrowed.errorText = errorText;
+    }
+    const iconToken = _tokenOf(icon);
+    if (iconToken !== undefined) {
+        narrowed.icon = iconToken;
+    }
+    const viewRef = _viewRefOf(view);
+    if (viewRef !== undefined) {
+        narrowed.view = viewRef;
+    }
+    if (narrowed.caption === undefined &&
+        narrowed.progressText === undefined &&
+        narrowed.completeText === undefined &&
+        narrowed.errorText === undefined &&
+        narrowed.icon === undefined &&
+        narrowed.view === undefined) {
+        return null;
+    }
+    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) {
+        const next = new Map(previous);
+        next.set(toolCallId, display);
+        return next;
+    }
+    if ((existing.caption !== undefined || display.caption === undefined) &&
+        (existing.progressText !== undefined ||
+            display.progressText === undefined) &&
+        (existing.completeText !== undefined ||
+            display.completeText === undefined) &&
+        (existing.errorText !== undefined || display.errorText === undefined) &&
+        (existing.icon !== undefined || display.icon === undefined) &&
+        (existing.view !== undefined || display.view === undefined)) {
+        return previous;
+    }
+    const merged = {};
+    const caption = existing.caption ?? display.caption;
+    if (caption !== undefined) {
+        merged.caption = caption;
+    }
+    const progressText = existing.progressText ?? display.progressText;
+    if (progressText !== undefined) {
+        merged.progressText = progressText;
+    }
+    const completeText = existing.completeText ?? display.completeText;
+    if (completeText !== undefined) {
+        merged.completeText = completeText;
+    }
+    const errorText = existing.errorText ?? display.errorText;
+    if (errorText !== undefined) {
+        merged.errorText = errorText;
+    }
+    const icon = existing.icon ?? display.icon;
+    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;
+    }
+    const next = new Map(previous);
+    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)) {
+            continue;
+        }
+        seeded.set(toolCallId, display);
+    }
+    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)) {
+        return anchors;
+    }
+    for (const [toolCallId, display] of Object.entries(value)) {
+        const anchor = toolCallDisplayAnchorOf({
+            tool_call_id: toolCallId,
+            display,
+        });
+        if (anchor !== null) {
+            anchors.set(anchor.toolCallId, anchor.display);
+        }
+    }
+    return anchors;
+}
+/** Records each annotated call's toolCallId → display envelope. */
+export function toolCallDisplayRecorder(onDisplayAnchored) {
+    return {
+        onCustomEvent({ event }) {
+            if (event.name !== TOOL_CALL_ANNOTATED_EVENT_NAME) {
+                return;
+            }
+            const anchor = toolCallDisplayAnchorOf(event.value);
+            if (anchor !== null) {
+                onDisplayAnchored(anchor.toolCallId, anchor.display);
+            }
+        },
+    };
+}
+function _displayTextOf(text) {
+    if (typeof text !== "string" || text.trim() === "") {
+        return undefined;
+    }
+    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;
+    }
+    const { key, version } = view;
+    if (typeof key !== "string" ||
+        key.trim() === "" ||
+        key.length > VIEW_KEY_MAX_CHARS) {
+        return undefined;
+    }
+    if (typeof version !== "number" ||
+        !Number.isInteger(version) ||
+        version < 1) {
+        return undefined;
+    }
+    return { key, version };
+}
+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") &&
+        (completeText === undefined || typeof completeText === "string") &&
+        (errorText === undefined || typeof errorText === "string") &&
+        (icon === undefined || typeof icon === "string") &&
+        (view === undefined || _viewRefOf(view) !== undefined);
+    return (fieldsAreWellTypedOrAbsent &&
+        (caption !== undefined ||
+            progressText !== undefined ||
+            completeText !== undefined ||
+            errorText !== undefined ||
+            icon !== undefined ||
+            view !== undefined));
+}
+//# sourceMappingURL=tool-call-display-anchors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-display-anchors.js","sourceRoot":"","sources":["../../src/core/tool-call-display-anchors.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,61 @@
+/** 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;
+    };
+}
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-display.d.ts","sourceRoot":"","sources":["../../src/core/tool-call-display.ts"],"names":[],"mappings":"AAKA;;;8CAG8C;AAC9C,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB,iBAAiB,GACjB,kBAAkB,GAClB,cAAc,GACd,QAAQ,GACR,WAAW,GACX,SAAS,GACT,YAAY,CAAC;AAEjB;qEACqE;AACrE,MAAM,WAAW,eAAe;IAC9B;4EACwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;wEACoE;IACpE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;iFAC6E;IAC7E,IAAI,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB;;8EAE0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;oFACgF;IAChF,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;2EACuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B;0GACsG;IACtG,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,gEAAgE;IAChE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC;AAED;kEACkE;AAClE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;8EAG8E;AAC9E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CA4BjE"}

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

@@ -0,0 +1,86 @@
+// 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) {
+        return _captionedHeadlineOf(caption, view.state);
+    }
+    const displayText = _displayTextFor(view);
+    if (displayText !== undefined) {
+        return displayText;
+    }
+    const name = humanizedToolName(view.toolName);
+    switch (view.state) {
+        case "input-streaming":
+            return name;
+        case "input-available":
+            return `Running ${name}…`;
+        case "output-available":
+            return `Ran ${name}`;
+        case "output-error":
+            return `${name} failed`;
+        case "denied":
+            return `You didn't approve ${name}`;
+        case "cancelled":
+            return `Didn't run ${name}`;
+        case "refused":
+            return `Didn't ${name}`;
+        case "superseded":
+            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":
+        case "input-available":
+        case "output-available":
+            return caption;
+        case "output-error":
+            return `${caption} · failed`;
+        case "denied":
+            return `${caption} · not approved`;
+        case "cancelled":
+            return `${caption} · didn't run`;
+        case "refused":
+            return `${caption} · declined`;
+        case "superseded":
+            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":
+        case "input-available":
+            return view.display?.progressText;
+        case "output-available":
+            return view.display?.completeText;
+        case "output-error":
+            return view.display?.errorText;
+        case "denied":
+            return undefined;
+        case "cancelled":
+            return undefined;
+        case "refused":
+            return undefined;
+        case "superseded":
+            return undefined;
+    }
+}
+//# sourceMappingURL=tool-call-display.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-display.js","sourceRoot":"","sources":["../../src/core/tool-call-display.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,uEAAuE;AACvE,uEAAuE;AACvE,8EAA8E;AA8D9E;kEACkE;AAClE,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;AAC5C,CAAC;AAED;;;8EAG8E;AAC9E,MAAM,UAAU,iBAAiB,CAAC,IAAuB;IACvD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC;IACtC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IACnD,CAAC;IACD,MAAM,WAAW,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IAC1C,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO,WAAW,CAAC;IACrB,CAAC;IACD,MAAM,IAAI,GAAG,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC9C,QAAQ,IAAI,CAAC,KAAK,EAAE,CAAC;QACnB,KAAK,iBAAiB;YACpB,OAAO,IAAI,CAAC;QACd,KAAK,iBAAiB;YACpB,OAAO,WAAW,IAAI,GAAG,CAAC;QAC5B,KAAK,kBAAkB;YACrB,OAAO,OAAO,IAAI,EAAE,CAAC;QACvB,KAAK,cAAc;YACjB,OAAO,GAAG,IAAI,SAAS,CAAC;QAC1B,KAAK,QAAQ;YACX,OAAO,sBAAsB,IAAI,EAAE,CAAC;QACtC,KAAK,WAAW;YACd,OAAO,cAAc,IAAI,EAAE,CAAC;QAC9B,KAAK,SAAS;YACZ,OAAO,UAAU,IAAI,EAAE,CAAC;QAC1B,KAAK,YAAY;YACf,OAAO,iBAAiB,IAAI,EAAE,CAAC;IACnC,CAAC;AACH,CAAC;AAED;0EAC0E;AAC1E,SAAS,oBAAoB,CAAC,OAAe,EAAE,KAAoB;IACjE,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,iBAAiB,CAAC;QACvB,KAAK,iBAAiB,CAAC;QACvB,KAAK,kBAAkB;YACrB,OAAO,OAAO,CAAC;QACjB,KAAK,cAAc;YACjB,OAAO,GAAG,OAAO,WAAW,CAAC;QAC/B,KAAK,QAAQ;YACX,OAAO,GAAG,OAAO,iBAAiB,CAAC;QACrC,KAAK,WAAW;YACd,OAAO,GAAG,OAAO,eAAe,CAAC;QACnC,KAAK,SAAS;YACZ,OAAO,GAAG,OAAO,aAAa,CAAC;QACjC,KAAK,YAAY;YACf,OAAO,GAAG,OAAO,kBAAkB,CAAC;IACxC,CAAC;AACH,CAAC;AAED;;;4EAG4E;AAC5E,SAAS,eAAe,CAAC,IAAuB;IAC9C,QAAQ,IAAI,CAAC,KAAK,EAAE,CAAC;QACnB,KAAK,iBAAiB,CAAC;QACvB,KAAK,iBAAiB;YACpB,OAAO,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC;QACpC,KAAK,kBAAkB;YACrB,OAAO,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC;QACpC,KAAK,cAAc;YACjB,OAAO,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC;QACjC,KAAK,QAAQ;YACX,OAAO,SAAS,CAAC;QACnB,KAAK,WAAW;YACd,OAAO,SAAS,CAAC;QACnB,KAAK,SAAS;YACZ,OAAO,SAAS,CAAC;QACnB,KAAK,YAAY;YACf,OAAO,SAAS,CAAC;IACrB,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,39 @@
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-presentation.d.ts","sourceRoot":"","sources":["../../src/core/tool-call-presentation.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAG/E,OAAO,KAAK,EAEV,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,gBAAgB,CAAC;AAIxB;0EAC0E;AAC1E,eAAO,MAAM,eAAe,yHAWlB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC;;0CAEsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,aAAa,CAAC;IACtB;;;;;;yBAMqB;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB;;sDAEkD;IAClD,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,kBAAkB,CAAC;CAC9B;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,iBAAiB,EACvB,QAAQ,CAAC,EAAE,gBAAgB,EAC3B,OAAO,CAAC,EAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE,GACvC,oBAAoB,CA+BtB"}

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

@@ -0,0 +1,191 @@
+// 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",
+    "terminal",
+    "question",
+    "memory",
+    "delegation",
+    "routine",
+    "todo",
+    "navigation",
+    "generic",
+];
+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 {
+        headline,
+        icon: _iconOf(view.display?.icon),
+        status: view.state,
+        settledSummary: headline,
+        currentWorkLabel: toolRowHeadlineOf({ ...view, state: "input-available" }),
+        toolView: {
+            views: resolved.views,
+            icons: resolved.icons,
+            get call() {
+                call ??= _toolViewCallOf(view, awaitingDecision);
+                return call;
+            },
+        },
+    };
+}
+function _iconOf(token) {
+    if (token !== undefined &&
+        TOOL_CALL_ICONS.includes(token)) {
+        return 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,
+        toolCallId: view.toolCallId ?? "",
+        status: view.state,
+        awaitingDecision,
+        args: _argsOf(view.argsText ?? view.input),
+    };
+    if (view.output !== undefined) {
+        const output = view.output;
+        call.resultText = output;
+        let structured;
+        const structure = () => (structured ??= _structuredResultOf(output));
+        Object.defineProperties(call, {
+            result: {
+                enumerable: true,
+                configurable: true,
+                get: () => structure().result,
+            },
+            truncated: {
+                enumerable: true,
+                configurable: true,
+                get: () => structure().truncated,
+            },
+        });
+    }
+    if (view.offloaded === true) {
+        call.offloaded = true;
+    }
+    if (view.errorText !== undefined) {
+        call.errorText = view.errorText;
+    }
+    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;
+    }
+    if (view.resultSchema !== undefined) {
+        call.resultSchema = view.resultSchema;
+    }
+    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) {
+        return {};
+    }
+    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)) {
+        return EMPTY_ARGS;
+    }
+    if (!(STEP_CAPTION_ARG_KEY in parsed.document)) {
+        return parsed.document;
+    }
+    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);
+    if (memoized !== undefined) {
+        return memoized;
+    }
+    const rest = withoutStepCaption(document);
+    const args = Object.keys(rest).length === 0 ? EMPTY_ARGS : rest;
+    _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) {
+        return memoized;
+    }
+    try {
+        const parsed = { document: JSON.parse(text) };
+        if (_jsonMemo.size >= JSON_MEMO_MAX_ENTRIES) {
+            _jsonMemo.clear();
+        }
+        _jsonMemo.set(text, parsed);
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function _isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=tool-call-presentation.js.map