@hheei/pi-ext-ui 0.5.2 → 0.7.0

package/dist/host-transcript-patch.js

@@ -1,8 +1,8 @@
 import { AssistantMessageComponent, InteractiveMode, ToolExecutionComponent, VERSION, } from "@earendil-works/pi-coding-agent";
-import { Container, MouseRegion, Spacer, stripTerminalSequences, Text, } from "@earendil-works/pi-tui";
-import { fitRow } from "@hheei/pi-ext-core";
+import { Container, stripTerminalSequences, Text } from "@earendil-works/pi-tui";
 import { MessageView } from "./message-view.js";
-import { renderWithoutToolRails, ToolView, toSingleRow } from "./tool-view.js";
+import { memberParts, TailUnit, ToolGroupView, } from "./tool-group-view.js";
+import { ToolView, toSingleRow } from "./tool-view.js";
 const SEAMS = ["getRegisteredToolDefinition", "showExtensionNotify"];
 function record(value) {
     return typeof value === "object" && value !== null;
@@ -28,34 +28,60 @@ function readHost(value) {
     const requestRender = tui.requestRender;
     return { chat, ui, requestRender: () => requestRender.call(tui) };
 }
+function readUsage(value) {
+    if (!record(value))
+        return undefined;
+    const { input, output, cacheRead, cacheWrite } = value;
+    if (typeof input !== "number" ||
+        typeof output !== "number" ||
+        typeof cacheRead !== "number" ||
+        typeof cacheWrite !== "number")
+        return undefined;
+    return { input, output, cacheRead, cacheWrite };
+}
 function assistantInfo(component) {
     const message = Reflect.get(component, "lastMessage");
     if (!record(message) || !Array.isArray(message.content)) {
         throw new Error("Pi assistant message shape changed");
     }
+    const hidden = Reflect.get(component, "hideThinkingBlock");
     const calls = new Set();
     let eligible = !["length", "aborted", "error"].includes(String(message.stopReason));
-    let thinking = false;
+    const thinking = [];
     for (const block of message.content) {
         if (!record(block))
             throw new Error("Pi assistant content shape changed");
         if (block.type === "toolCall" && typeof block.id === "string")
             calls.add(block.id);
-        else if (block.type === "thinking" && typeof block.thinking === "string")
-            thinking ||= block.thinking.trim() !== "";
+        else if (block.type === "thinking" && typeof block.thinking === "string") {
+            // Pi joins a thinking run with blank lines; the same separator keeps paragraphs readable here.
+            const text = block.thinking.trim();
+            if (text !== "")
+                thinking.push(text);
+        }
         else if (block.type !== "text" || typeof block.text !== "string" || block.text.trim() !== "")
             eligible = false;
     }
-    return { calls, eligible, thinking };
+    return {
+        calls,
+        eligible,
+        thinking: thinking.join("\n\n"),
+        hidden: hidden === true,
+        usage: readUsage(message.usage),
+    };
 }
 function toolMember(component, calls) {
     const id = Reflect.get(component, "toolCallId");
     const name = Reflect.get(component, "toolName");
     const partial = Reflect.get(component, "isPartial");
+    const complete = Reflect.get(component, "argsComplete");
     const result = Reflect.get(component, "result");
     const renderer = Reflect.get(component, "resultRendererComponent");
     const callRenderer = Reflect.get(component, "callRendererComponent");
-    if (typeof id !== "string" || typeof name !== "string" || typeof partial !== "boolean") {
+    if (typeof id !== "string" ||
+        typeof name !== "string" ||
+        typeof partial !== "boolean" ||
+        typeof complete !== "boolean") {
         throw new Error("Pi tool component shape changed");
     }
     if (!calls.has(id) || !(callRenderer instanceof ToolView))
@@ -66,12 +92,29 @@ function toolMember(component, calls) {
             !result.content.every((block) => record(block) && block.type === "text") ||
             !(renderer instanceof ToolView)))
         return undefined;
-    const summary = renderer instanceof ToolView
-        ? (renderer.summary ?? callRenderer.summary)
-        : callRenderer.summary;
-    if (summary === undefined)
+    // The visible view decides the facts: a hidden call renderer reports no summary of its own.
+    const view = renderer instanceof ToolView ? renderer : callRenderer;
+    if (view.summary === undefined)
         return undefined;
-    return { component, name: toSingleRow(stripTerminalSequences(name)), summary };
+    const status = !complete
+        ? "streaming"
+        : partial
+            ? "running"
+            : record(result) && result.isError === true
+                ? "error"
+                : "ok";
+    const children = view.children;
+    return {
+        kind: "tool",
+        component,
+        title: toSingleRow(stripTerminalSequences(name)),
+        status,
+        // The host keeps isPartial true until it stores a final result; argsComplete alone is not
+        // completion, and restored history never sets it. The result is the observed end fact.
+        completed: !partial && result !== undefined,
+        ...(children === undefined || children.length === 0 ? {} : { children }),
+        ...(view.childCount === undefined ? {} : { childCount: view.childCount }),
+    };
 }
 function messageView(component) {
     if (component instanceof MessageView)
@@ -84,165 +127,62 @@ function messageView(component) {
     return undefined;
 }
 /** Shared transcript notices stay in the group. The frame is the contract, not each custom type. */
-function noticeContinuation(component) {
+function noticeMember(component) {
     const view = messageView(component);
-    return view === undefined ? undefined : { component, summary: view.activitySummary };
+    if (view === undefined)
+        return undefined;
+    return {
+        kind: "notice",
+        component,
+        title: view.kind,
+        summary: view.activitySummary,
+        // Preview is visible content; only a real body opens. A preview-only notice therefore never
+        // grows a second expansion level, and the notice lays out both blocks itself.
+        content: (width) => view.previewRows(width),
+        ...(view.expandable ? { detail: (width) => view.bodyRows(width) } : {}),
+    };
 }
-class NotifyView extends Container {
+/**
+ * A captured `ui.notify`. It owns its content: one indented, width-wrapped block with the notice's
+ * semantic color. The group draws these rows once, so a plain notice has no expansion of its own.
+ */
+class NotifyView {
     #text = new Text("", 1, 0);
-    #context;
+    #ui;
     #message;
     #type;
-    constructor(message, type, context) {
-        super();
-        this.#context = context;
+    constructor(message, type, ui) {
+        this.#ui = ui;
         this.#message = message;
         this.#type = type;
-        this.addChild(new Spacer(1));
-        this.addChild(this.#text);
     }
-    get summary() {
-        return this.#context.ui.theme.fg(this.#type === "info" ? "dim" : this.#type, toSingleRow(this.#content));
+    get member() {
+        return {
+            kind: "notice",
+            component: this,
+            title: this.#type,
+            content: (width) => this.rows(width),
+        };
+    }
+    /** The notice body as it appears both in the transcript and inside the activity group. */
+    rows(width) {
+        // info is the terminal's own readable text; a warning or error keeps its status token and
+        // its written prefix, so the level never depends on color alone.
+        this.#text.setText(this.#ui.theme.fg(this.#type === "info" ? "text" : this.#type, this.#content));
+        return this.#text.render(width);
     }
     get #content() {
         const prefix = this.#type === "error" ? "Error: " : this.#type === "warning" ? "Warning: " : "";
         return `${prefix}${this.#message}`;
     }
     render(width) {
-        this.#text.setText(this.#context.ui.theme.fg(this.#type === "info" ? "dim" : this.#type, this.#content));
-        return super.render(width);
-    }
-}
-class ToolGroup extends Container {
-    #header = new Text("", 0, 0);
-    #originals = new Container();
-    #context;
-    #redraw;
-    #members = [];
-    #expanded = false;
-    #renderedExpanded = false;
-    #open = new Set();
-    #hits = [];
-    constructor(context, redraw) {
-        super();
-        this.#context = context;
-        this.#redraw = redraw;
-        const heading = new MouseRegion(this.#header, (event) => {
-            if (event.type !== "click" || event.button !== "left")
-                return undefined;
-            this.#expanded = this.#context.ui.getToolsExpanded() ? false : !this.#expanded;
-            if (!this.#expanded)
-                this.#open.clear();
-            redraw();
-            return { handled: true, render: true };
-        });
-        const body = {
-            render: (width) => this.#renderBody(width),
-            handleMouse: (event) => this.#hit(event),
-            invalidate() { },
-        };
-        this.children = [new Spacer(1), heading, body];
-    }
-    #renderBody(width) {
-        const inner = Math.max(1, width - 2);
-        const rail = this.#context.ui.theme.fg("dim", "▎");
-        const lines = [];
-        const hits = [];
-        this.#members.forEach((member, index) => {
-            const wrapper = this.#originals.children[index];
-            if (wrapper === undefined)
-                return;
-            const native = this.#renderedExpanded || this.#open.has(member.component);
-            const rows = native
-                ? renderWithoutToolRails(wrapper, inner)
-                : member.summary === undefined
-                    ? []
-                    : [member.summary];
-            if (rows.length === 0)
-                return;
-            hits.push({ component: member.component, wrapper, native, height: rows.length });
-            for (const row of rows) {
-                lines.push(fitRow(`${rail} ${row}`, Math.max(0, width), "…"));
-            }
-        });
-        this.#hits = hits;
-        return lines;
-    }
-    #hit(event) {
-        let y = event.y;
-        for (const hit of this.#hits) {
-            if (y >= hit.height) {
-                y -= hit.height;
-                continue;
-            }
-            if (!hit.native) {
-                if (event.type !== "click" || event.button !== "left")
-                    return undefined;
-                this.#open.add(hit.component);
-                this.#redraw();
-                return { handled: true, render: true };
-            }
-            // The rail belongs to the group. Content, including header fold and copy, stays with the member.
-            if (event.x < 2) {
-                if (!this.#renderedExpanded && event.type === "click" && event.button === "left") {
-                    this.#open.delete(hit.component);
-                    this.#redraw();
-                    return { handled: true, render: true };
-                }
-                return undefined;
-            }
-            return hit.wrapper.handleMouse?.({
-                ...event,
-                y,
-                height: hit.height,
-                x: event.x - 2,
-                width: Math.max(1, event.width - 2),
-            });
-        }
-        return undefined;
-    }
-    update(members) {
-        this.#members = members;
-        this.#originals.children = members.map(({ component }) => {
-            let offset = 0;
-            return {
-                render(width) {
-                    const rows = component.render(width);
-                    // Pi adds one leading separator per tool; the group supplies its own spacing.
-                    offset = rows[0] === "" ? 1 : 0;
-                    return rows.slice(offset);
-                },
-                handleMouse(event) {
-                    return component.handleMouse?.({
-                        ...event,
-                        y: event.y + offset,
-                        height: event.height + offset,
-                    });
-                },
-                invalidate() { },
-            };
-        });
+        return ["", ...this.rows(width)];
     }
     invalidate() {
-        // Original chatContainer.invalidate invalidates original members exactly once.
-        this.#header.invalidate();
-    }
-    render(width) {
-        this.#renderedExpanded = this.#expanded || this.#context.ui.getToolsExpanded();
-        const theme = this.#context.ui.theme;
-        const counts = new Map();
-        for (const member of this.#members) {
-            if (member.name !== undefined)
-                counts.set(member.name, (counts.get(member.name) ?? 0) + 1);
-        }
-        const heading = [...counts]
-            .map(([name, count]) => `${theme.fg("toolTitle", theme.bold(name))} ${theme.fg("dim", `×${count}`)}`)
-            .join(theme.fg("dim", " · "));
-        this.#header.setText(fitRow(`${theme.fg("dim", this.#renderedExpanded ? "▾" : "▸")} ${heading}`, Math.max(0, width), "…"));
-        return super.render(width);
+        this.#text.invalidate();
     }
 }
-function attach(host, context) {
+function attach(host, run) {
     const chat = host.chat;
     const original = {
         render: chat.render,
@@ -261,32 +201,134 @@ function attach(host, context) {
     const projection = new Container();
     let groups = new Map();
     let active = true;
+    const disposeGroups = () => {
+        for (const group of groups.values())
+            group.dispose();
+        groups.clear();
+    };
+    /**
+     * Record first observation time for new components during a live loop. Restored history stays
+     * unknown until live content joins its block.
+     */
+    const claim = (child) => {
+        if (run.observed.has(child))
+            return;
+        const current = run.current;
+        run.observed.set(child, current !== undefined && current.run.endedAt === undefined
+            ? { at: performance.now(), run: current.run }
+            : undefined);
+    };
+    const observe = () => {
+        for (const child of chat.children)
+            claim(child);
+    };
+    /** Create or recover one clock for each live continuous block. */
+    const clockOf = (members, endedAt) => {
+        const parts = members.flatMap(memberParts);
+        let clock;
+        for (const part of parts) {
+            clock = run.clocks.get(part);
+            if (clock !== undefined)
+                break;
+        }
+        if (clock === undefined) {
+            const origin = parts
+                .map((part) => run.observed.get(part))
+                .find((value) => value !== undefined);
+            if (origin === undefined)
+                return undefined;
+            clock = { startedAt: origin.at };
+            if (origin.run.endedAt !== undefined)
+                clock.endedAt = origin.run.endedAt;
+            else
+                run.activeClocks.add(clock);
+        }
+        if (endedAt !== undefined && clock.endedAt === undefined) {
+            clock.endedAt = endedAt;
+            run.activeClocks.delete(clock);
+        }
+        for (const part of parts)
+            if (run.clocks.get(part) === undefined)
+                run.clocks.set(part, clock);
+        return clock;
+    };
     const rebuild = () => {
         const next = new Map();
         const children = [];
+        const blocks = [];
         let calls = new Set();
         let members = [];
-        const flush = () => {
+        /** Every request this pending block owns, in transcript order, whether or not it is displayed. */
+        let requests = [];
+        /**
+         * Closes the pending block. `ended` is false only for the block still open at the transcript tail:
+         * that one keeps its last visible unit outside the group, and its facts still count here.
+         */
+        const flush = (ended, boundary) => {
             const first = members[0]?.component;
-            if (first !== undefined && members.filter((member) => member.name !== undefined).length > 1) {
-                const group = groups.get(first) ?? new ToolGroup(context, host.requestRender);
-                group.update(members);
+            let weight = 0;
+            for (const member of members) {
+                if (member.kind === "tool")
+                    weight += 1;
+                else if (member.kind === "notice" ||
+                    (member.thinking !== undefined && member.thinking !== ""))
+                    weight += 0.5;
+            }
+            if (first !== undefined && weight >= 2) {
+                const group = groups.get(first) ?? new ToolGroupView(host.ui, host.requestRender);
+                const tail = ended ? undefined : members.at(-1);
+                const inside = tail === undefined ? members : members.slice(0, -1);
+                const boundaryTime = ended && boundary !== undefined
+                    ? (run.observed.get(boundary)?.at ?? performance.now())
+                    : undefined;
+                blocks.push({
+                    group,
+                    members: inside,
+                    tail,
+                    requests,
+                    clock: clockOf(members, boundaryTime),
+                });
                 next.set(first, group);
                 children.push(group);
+                if (tail !== undefined)
+                    children.push(new TailUnit(tail));
             }
             else
-                children.push(...members.map((member) => member.component));
+                children.push(...members.flatMap(memberParts));
             members = [];
+            requests = [];
         };
         for (const child of chat.children) {
+            claim(child);
             if (child instanceof AssistantMessageComponent) {
                 const info = assistantInfo(child);
                 calls = info.calls;
+                // The request belongs to the block whose work it answers, even when its text is native
+                // content the aggregate never shows.
+                requests.push(info.usage === undefined ? {} : { usage: info.usage });
                 if (info.eligible) {
-                    members.push({
-                        component: child,
-                        ...(info.thinking ? { summary: context.ui.theme.fg("thinkingText", "thinking…") } : {}),
-                    });
+                    const thinking = info.thinking;
+                    const previous = members.at(-1);
+                    if (thinking !== "" && previous?.kind === "thinking") {
+                        // One continuous run: consecutive thinking blocks are one item, paragraphs kept.
+                        members[members.length - 1] = {
+                            ...previous,
+                            thinking: `${previous.thinking ?? ""}\n\n${thinking}`,
+                            parts: [...memberParts(previous), child],
+                            ...(previous.thinkingHidden === true || info.hidden ? { thinkingHidden: true } : {}),
+                        };
+                    }
+                    else {
+                        members.push({
+                            kind: "thinking",
+                            component: child,
+                            // The host's hide setting is a display preference, not a content filter: the text
+                            // stays available to the group's preview and expansion, and is never written back.
+                            ...(thinking === ""
+                                ? {}
+                                : { thinking, ...(info.hidden ? { thinkingHidden: true } : {}) }),
+                        });
+                    }
                     continue;
                 }
             }
@@ -298,20 +340,28 @@ function attach(host, context) {
                 }
             }
             else if (child instanceof NotifyView) {
-                members.push({ component: child, summary: child.summary });
+                members.push(child.member);
                 continue;
             }
             else {
-                const continuation = noticeContinuation(child);
+                const continuation = noticeMember(child);
                 if (continuation !== undefined) {
                     members.push(continuation);
                     continue;
                 }
             }
-            flush();
+            flush(true, child);
             children.push(child);
         }
-        flush();
+        flush(false);
+        for (const block of blocks) {
+            block.group.update(block.members, block.tail, block.requests, block.clock);
+        }
+        // A block the new projection does not reuse is gone: its hold timer must go with it.
+        for (const [key, group] of groups) {
+            if (next.get(key) !== group)
+                group.dispose();
+        }
         groups = next;
         projection.children = children;
     };
@@ -324,9 +374,9 @@ function attach(host, context) {
             }
             catch (error) {
                 active = false;
-                groups.clear();
+                disposeGroups();
                 projection.clear();
-                context.ui.notify(`Tool grouping disabled: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                host.ui.notify(`Tool grouping disabled: ${error instanceof Error ? error.message : String(error)}`, "warning");
                 return original.render.call(chat, width);
             }
             // Real renderer errors propagate; never hide a tool-rendering failure.
@@ -348,16 +398,17 @@ function attach(host, context) {
         notify(message, type) {
             if (!active)
                 return false;
-            chat.addChild(new NotifyView(message, type, context));
+            chat.addChild(new NotifyView(message, type, host.ui));
             host.requestRender();
             return true;
         },
+        observe,
         dispose() {
             if (disposed)
                 return;
             disposed = true;
             active = false;
-            groups.clear();
+            disposeGroups();
             projection.clear();
             let conflict = false;
             for (const key of ["render", "handleMouse", "invalidate"]) {
@@ -372,7 +423,7 @@ function attach(host, context) {
                     Object.defineProperty(chat, key, descriptor);
             }
             if (conflict)
-                context.ui.notify("Tool grouping patch changed by another extension; restart Pi to fully unload it.", "warning");
+                host.ui.notify("Tool grouping patch changed by another extension; restart Pi to fully unload it.", "warning");
             host.requestRender();
         },
     };
@@ -385,7 +436,7 @@ function connect(owner, host) {
     }
     catch (error) {
         owner.failed.add(host.chat);
-        owner.context.ui.notify(`Tool grouping unavailable: ${error instanceof Error ? error.message : String(error)}`, "warning");
+        owner.ui.notify(`Tool grouping unavailable: ${error instanceof Error ? error.message : String(error)}`, "warning");
     }
 }
 function patchState() {
@@ -426,7 +477,7 @@ function patchState() {
             if (record(instance))
                 failed.add(instance);
             for (const owner of owners.values())
-                owner.context.ui.notify(`Tool grouping unavailable: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                owner.ui.notify(`Tool grouping unavailable: ${error instanceof Error ? error.message : String(error)}`, "warning");
             return undefined;
         }
         if (record(instance) && !seen.has(instance)) {
@@ -469,7 +520,8 @@ export function installHostToolGroups(context) {
         !(major > 1 || (major === 1 && (minor > 0 || (minor === 0 && patch >= 1)))))
         throw new Error(`Tool grouping requires Pi >=1.0.1; running ${VERSION}`);
     const state = patchState();
-    if (state.owners.has(context.ui))
+    const ui = context.ui;
+    if (state.owners.has(ui))
         throw new Error("Tool grouping already owns this UI runtime");
     if (state.owners.size === 0) {
         for (const seam of SEAMS) {
@@ -483,13 +535,18 @@ export function installHostToolGroups(context) {
                 value: state.wrappers[seam],
             });
     }
+    const run = {
+        observed: new WeakMap(),
+        clocks: new WeakMap(),
+        activeClocks: new Set(),
+    };
     const owner = {
-        context,
+        ui,
         hosts: new Map(),
         failed: new WeakSet(),
-        attach: (host) => attach(host, context),
+        attach: (host) => attach(host, run),
     };
-    state.owners.set(context.ui, owner);
+    state.owners.set(ui, owner);
     // Reload rebuilds history before session_start; reconnect already discovered instances.
     for (const reference of state.hosts) {
         const instance = reference.deref();
@@ -499,7 +556,7 @@ export function installHostToolGroups(context) {
         }
         try {
             const host = readHost(instance);
-            if (host.ui === context.ui)
+            if (host.ui === ui)
                 connect(owner, host);
         }
         catch {
@@ -512,11 +569,31 @@ export function installHostToolGroups(context) {
             for (const host of owner.hosts.values())
                 host.requestRender();
         },
+        beginRun() {
+            // History may not have rendered yet. Claim it before opening the new live run.
+            for (const host of owner.hosts.values())
+                host.observe();
+            run.current = { run: {} };
+        },
+        endRun() {
+            // Mark unseen transcript children before ending the run so later renders treat them as history.
+            for (const host of owner.hosts.values())
+                host.observe();
+            const endedAt = performance.now();
+            const current = run.current;
+            if (current !== undefined && current.run.endedAt === undefined)
+                current.run.endedAt = endedAt;
+            for (const clock of run.activeClocks)
+                clock.endedAt = endedAt;
+            run.activeClocks.clear();
+        },
         dispose() {
             if (disposed)
                 return;
             disposed = true;
-            state.owners.delete(context.ui);
+            run.current = undefined;
+            run.activeClocks.clear();
+            state.owners.delete(ui);
             for (const host of owner.hosts.values())
                 host.dispose();
             owner.hosts.clear();
@@ -527,7 +604,7 @@ export function installHostToolGroups(context) {
                     state.wrappers[seam])
                     Object.defineProperty(InteractiveMode.prototype, seam, state.originals[seam]);
                 else
-                    context.ui.notify("Tool grouping seam changed by another extension; restart Pi to fully unload it.", "warning");
+                    ui.notify("Tool grouping seam changed by another extension; restart Pi to fully unload it.", "warning");
             }
         },
     };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { type DiffHunk, type DiffLine, type DiffSource, type DiffStats, DiffView, type DiffViewOptions, diffStats, } from "./diff-view.js";
 export { createMessageView, type MessageRows, type MessageTone, MessageView, type MessageViewHeader, type MessageViewSpec, } from "./message-view.js";
-export { extractChildToolCopyText, NestedCallsView, type NestedCallsViewProps, } from "./nested-calls-view.js";
-export { type CollapsibleToolRendererOptions, createCollapsibleToolRendererResolver, estimateStreamingTokens, inlinePresentation, isMcpTool, type NestedCallRecord, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, type SpecializedToolRendererName, type ToolRenderContext, } from "./renderer.js";
-export { type Collapsible, createToolView, type FoldLevel, formatStatusGlyph, formatToolHeaderText, isCollapsible, type RailColorToken, type RailSection, type ToolStatusKind, ToolView, type ToolViewCopySpec, type ToolViewHeaderSpec, type ToolViewSpec, transitionFoldLevel, } from "./tool-view.js";
-export { type CapturedToolCall, clearCapturedNestedCalls, getCapturedNestedCalls, recordToolExecutionEnd, recordToolExecutionStart, } from "./tracker.js";
+export { extractChildToolCopyText, inlinePresentation } from "./native-tools.js";
+export { NestedCallsView, type NestedCallsViewProps, } from "./nested-calls-view.js";
+export { type CollapsibleToolRendererOptions, createCollapsibleToolRendererResolver, estimateStreamingTokens, isMcpTool, type NestedCallRecord, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, type SpecializedToolRendererName, type ToolRenderContext, } from "./renderer.js";
+export { ToolUiRuntime } from "./runtime.js";
+export { type Collapsible, createToolView, type FoldLevel, formatStatusGlyph, formatToolHeaderText, isCollapsible, type RailColorToken, type RailSection, type ToolStatusKind, ToolView, type ToolViewChild, type ToolViewCopySpec, type ToolViewHeaderSpec, type ToolViewSpec, transitionFoldLevel, } from "./tool-view.js";
+export { type CapturedToolCall, type NestedCallArgsFact, NestedCallArgsIndex, ToolExecutionTracker, } from "./tracker.js";

package/dist/index.js

@@ -1,6 +1,8 @@
 export { DiffView, diffStats, } from "./diff-view.js";
 export { createMessageView, MessageView, } from "./message-view.js";
-export { extractChildToolCopyText, NestedCallsView, } from "./nested-calls-view.js";
-export { createCollapsibleToolRendererResolver, estimateStreamingTokens, inlinePresentation, isMcpTool, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, } from "./renderer.js";
+export { extractChildToolCopyText, inlinePresentation } from "./native-tools.js";
+export { NestedCallsView, } from "./nested-calls-view.js";
+export { createCollapsibleToolRendererResolver, estimateStreamingTokens, isMcpTool, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, } from "./renderer.js";
+export { ToolUiRuntime } from "./runtime.js";
 export { createToolView, formatStatusGlyph, formatToolHeaderText, isCollapsible, ToolView, transitionFoldLevel, } from "./tool-view.js";
-export { clearCapturedNestedCalls, getCapturedNestedCalls, recordToolExecutionEnd, recordToolExecutionStart, } from "./tracker.js";
+export { NestedCallArgsIndex, ToolExecutionTracker, } from "./tracker.js";

package/dist/message-view.d.ts

@@ -12,6 +12,12 @@ export declare class MessageView implements Component {
     render(width: number): string[];
     invalidate(): void;
     handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
+    /** Provider-declared notice type, used to group notices without reading their text. */
+    get kind(): string;
+    /** Preview rows inside an activity group: visible content below the summary, folded or not. */
+    previewRows(width: number): string[];
+    /** Body rows inside an activity group: what opening this notice reveals. */
+    bodyRows(width: number): string[];
     /** Single-row label used when this notice sits inside an activity group. */
     get activitySummary(): string;
 }