@jini-ai/chat 0.5.6 → 0.5.8

package/dist/react/hooks/useAnsweredCards.js

@@ -0,0 +1,23 @@
+/**
+ * @module useAnsweredCards
+ *
+ * Which of a message's cards the person has already answered, by ext-event slot. A held-open
+ * question's tool call stays open after the click while the confirmed work runs, so the event
+ * stream alone still reads "waiting for an answer"; the card reports its own delivered answer here
+ * and the activity line and countdown clear at once (owner, 2026-10-11).
+ */
+import { useCallback, useState } from 'react';
+/**
+ * @param slotOf - Maps an ext event to its render slot (`extEventSlot`).
+ * @complexity O(1) per lookup; O(answered cards) space.
+ */
+export function useAnsweredCards({ slotOf }) {
+    const [answered, setAnswered] = useState(() => new Set());
+    const markAnswered = useCallback((slot) => {
+        setAnswered((current) => (current.has(slot) ? current : new Set(current).add(slot)));
+    }, []);
+    const isAnswered = useCallback((slot) => answered.has(slot), [answered]);
+    const isAnsweredCard = useCallback((card) => answered.has(slotOf(card)), [answered, slotOf]);
+    return { isAnswered, markAnswered, isAnsweredCard };
+}
+//# sourceMappingURL=useAnsweredCards.js.map

package/dist/react/hooks/useComposer.d.ts

@@ -69,6 +69,20 @@ export interface UseComposerResult {
     canSubmit: boolean;
     /** Clears the draft and staged attachments (called after a successful send). */
     reset: () => void;
+    /**
+     * Writes a draft still waiting out {@link DRAFT_PERSIST_DEBOUNCE_MS} to storage and the host's
+     * persistence port now. `<Composer>` calls it on blur. Optional for compatibility with
+     * host-created composer controllers.
+     */
+    flushDraft?: () => void;
 }
+/**
+ * How long typing must pause before the draft reaches `localStorage` and the host's persistence
+ * port. Those writes used to run synchronously on every keystroke (owner report 2026-10-08: typing
+ * lagged in a long conversation). The in-memory cache tier still updates per keystroke, and every
+ * exit path (send, conversation switch, unmount, page hide, blur) writes or discards immediately,
+ * so the delay can only cost a draft on a hard crash inside this window.
+ */
+export declare const DRAFT_PERSIST_DEBOUNCE_MS = 800;
 export declare function useComposer(options?: UseComposerOptions): UseComposerResult;
 //# sourceMappingURL=useComposer.d.ts.map

package/dist/react/hooks/useComposer.js

@@ -29,20 +29,89 @@
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useComposerHistory } from './useComposerHistory.hooks.js';
-import { readCachedAttachments, readCachedDraft, writeCachedAttachments, writeCachedDraft, } from './composer-draft-cache.js';
+import { readCachedAttachments, readCachedDraft, rememberCachedDraft, writeCachedAttachments, writeCachedDraft, } from './composer-draft-cache.js';
 import { cacheAttachmentPreviewSource } from './attachment-preview-cache.js';
 const EMPTY_MENTION = { open: false, query: '', results: [] };
+/**
+ * How long typing must pause before the draft reaches `localStorage` and the host's persistence
+ * port. Those writes used to run synchronously on every keystroke (owner report 2026-10-08: typing
+ * lagged in a long conversation). The in-memory cache tier still updates per keystroke, and every
+ * exit path (send, conversation switch, unmount, page hide, blur) writes or discards immediately,
+ * so the delay can only cost a draft on a hard crash inside this window.
+ */
+export const DRAFT_PERSIST_DEBOUNCE_MS = 800;
+/**
+ * One pending durable draft write at a time, trailing-edge debounced. Flushes on unmount and when
+ * the page is hidden (`pagehide`, or `visibilitychange` to hidden — the last event a mobile browser
+ * reliably delivers before discarding the tab).
+ * @complexity Time/space: O(1) per call.
+ */
+function useDeferredDraftWrite() {
+    const pendingRef = useRef(null);
+    const cancel = useCallback(() => {
+        const pending = pendingRef.current;
+        if (!pending)
+            return;
+        pendingRef.current = null;
+        clearTimeout(pending.timer);
+    }, []);
+    const flush = useCallback(() => {
+        const pending = pendingRef.current;
+        if (!pending)
+            return;
+        pendingRef.current = null;
+        clearTimeout(pending.timer);
+        pending.write();
+    }, []);
+    const schedule = useCallback((write) => {
+        if (pendingRef.current)
+            clearTimeout(pendingRef.current.timer);
+        const timer = setTimeout(() => {
+            pendingRef.current = null;
+            write();
+        }, DRAFT_PERSIST_DEBOUNCE_MS);
+        pendingRef.current = { timer, write };
+    }, []);
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return flush;
+        const onVisibilityChange = () => {
+            if (document.visibilityState === 'hidden')
+                flush();
+        };
+        window.addEventListener('pagehide', flush);
+        document.addEventListener('visibilitychange', onVisibilityChange);
+        return () => {
+            window.removeEventListener('pagehide', flush);
+            document.removeEventListener('visibilitychange', onVisibilityChange);
+            flush();
+        };
+    }, [flush]);
+    return useMemo(() => ({ schedule, flush, cancel }), [schedule, flush, cancel]);
+}
 export function useComposer(options = {}) {
     const { project, composerSlots, persistence, conversationId, validateAttachments } = options;
     const [draft, setDraftState] = useState(() => options.initialDraft ?? persistence?.read() ?? readCachedDraft({ conversationId: conversationId }) ?? '');
     const [attachments, setAttachments] = useState([]);
     const [agent, setAgent] = useState(options.initialAgent);
     const [mention, setMention] = useState(EMPTY_MENTION);
+    const deferredWrite = useDeferredDraftWrite();
     const commitDraft = useCallback((next) => {
         setDraftState(next);
-        persistence?.write(next);
-        writeCachedDraft({ conversationId: conversationId, draft: next });
-    }, [persistence, conversationId]);
+        rememberCachedDraft({ conversationId: conversationId, draft: next });
+        const write = () => {
+            persistence?.write(next);
+            writeCachedDraft({ conversationId: conversationId, draft: next });
+        };
+        // A cleared draft (send, reset) is written at once and drops any pending write, so a stale
+        // timer can never put the sent text back.
+        if (next.trim() === '') {
+            deferredWrite.cancel();
+            write();
+            return;
+        }
+        deferredWrite.schedule(write);
+    }, [persistence, conversationId, deferredWrite]);
     const history = useComposerHistory({ setRecalledDraft: setDraftState }, {
         ...(options.historyMessages === undefined ? {} : { messages: options.historyMessages }),
         ...(options.historyScope === undefined ? {} : { scope: options.historyScope }),
@@ -68,6 +137,8 @@ export function useComposer(options = {}) {
         if (conversationId === previousConversationIdRef.current)
             return;
         previousConversationIdRef.current = conversationId;
+        // The pending write closed over the conversation being left, so this lands under its id.
+        deferredWrite.flush();
         const restored = readCachedDraft({ conversationId: conversationId });
         // An id arriving where there was none is NOT a switch between two conversations — it is the one
         // the operator is already looking at finally getting a key (a new chat created server-side
@@ -85,7 +156,7 @@ export function useComposer(options = {}) {
         setDraftState(restored ?? '');
         setAttachments([]);
         setMention(EMPTY_MENTION);
-    }, [conversationId]);
+    }, [conversationId, deferredWrite]);
     // Held in a ref so an inline arrow from the host does not re-run the restore below on every
     // render. Reassigned each render so a host that swaps implementations still gets the new one.
     const validateAttachmentsRef = useRef(validateAttachments);
@@ -221,6 +292,7 @@ export function useComposer(options = {}) {
         selectMention,
         canSubmit,
         reset,
-    }), [draft, history, setDraft, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset]);
+        flushDraft: deferredWrite.flush,
+    }), [draft, history, setDraft, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset, deferredWrite.flush]);
 }
 //# sourceMappingURL=useComposer.js.map

package/dist/react/hooks/useConversation.d.ts

@@ -4,6 +4,14 @@ import type { ChatTransport, RunContext } from '../../core/index.js';
 export interface UseConversationOptions extends UserTextRedactionOptions {
     transport: ChatTransport;
     initialMessages?: ChatMessage[];
+    /** Optional host loader and browser ports, e.g. `{ loadMessages, visibility: document, focus: window }`; refresh stays passive. */
+    refreshSignal?: {
+        loadMessages: () => Promise<ChatMessage[]>;
+        visibility: EventTarget & {
+            readonly visibilityState: string;
+        };
+        focus: EventTarget;
+    };
     conversationId?: string | null;
     agentId?: string;
     /** Defaults to a `crypto.randomUUID()`-based id generator when available, else a counter. */

package/dist/react/hooks/useConversation.js

@@ -34,6 +34,40 @@ export function useConversation(options) {
     const setMessages = useCallback((updater) => {
         setMessagesState((prev) => (typeof updater === 'function' ? updater(prev) : updater));
     }, []);
+    // Map upserts preserve order in O(local + saved) time/space; cleanup fences late reads on switch/unmount/local runs.
+    useEffect(() => {
+        const source = options.refreshSignal;
+        if (!source || run.isStreaming)
+            return;
+        let disposed = false, pending = false, timer;
+        const refresh = async () => {
+            if (pending)
+                return;
+            pending = true;
+            try {
+                const saved = await source.loadMessages();
+                if (!disposed)
+                    setMessagesState(prev => [...new Map([...prev, ...saved].map(message => [message.id, message])).values()]);
+            }
+            catch (error) {
+                if (!disposed)
+                    console.error('[chat] conversation refresh failed', error);
+            }
+            finally {
+                pending = false;
+            }
+        };
+        const schedule = () => {
+            clearTimeout(timer);
+            if (source.visibility.visibilityState === 'visible')
+                timer = setTimeout(() => { void refresh(); }, 500);
+        };
+        const events = [[source.visibility, 'visibilitychange'], [source.focus, 'focus']];
+        for (const [target, event] of events)
+            target.addEventListener(event, schedule);
+        return () => { disposed = true; clearTimeout(timer); for (const [target, event] of events)
+            target.removeEventListener(event, schedule); };
+    }, [options.refreshSignal, run.isStreaming]);
     /**
      * The mount-time snapshot of `initialMessages`, captured once — the same "read once, never react
      * to a later identity change" contract `messages`'s own `useState` initializer above already has

package/dist/react/hooks/useRunActivity.d.ts

@@ -1,17 +1,19 @@
-import type { AgentEvent } from '../../core/index.js';
+import type { AgentEvent, IsAnsweredCard } from '../../core/index.js';
 /** Wall-clock source, swappable in tests. */
 export type NowFn = () => number;
 /**
  * @param events - The running message's events.
  * @param active - True while the turn is in progress; the clock only ticks while true.
  * @param now - Clock source (default `Date.now`).
+ * @param isAnsweredCard - Cards the person already answered (see `RunActivityOptions`).
  * @returns The activity line's text, or `null` when `active` is false.
- * @complexity O(n) in events per render (memoized on the events array).
+ * @complexity O(n) in events per render (memoized on the events array and the answered predicate).
  */
 export declare function useRunActivity({ events, active }: {
     events: readonly AgentEvent[] | undefined;
     active: boolean;
-}, { now }?: {
+}, { now, isAnsweredCard }?: {
     now?: (NowFn) | undefined;
+    isAnsweredCard?: IsAnsweredCard | undefined;
 }): string | null;
 //# sourceMappingURL=useRunActivity.d.ts.map

package/dist/react/hooks/useRunActivity.js

@@ -12,12 +12,13 @@ import { useT } from './context.js';
  * @param events - The running message's events.
  * @param active - True while the turn is in progress; the clock only ticks while true.
  * @param now - Clock source (default `Date.now`).
+ * @param isAnsweredCard - Cards the person already answered (see `RunActivityOptions`).
  * @returns The activity line's text, or `null` when `active` is false.
- * @complexity O(n) in events per render (memoized on the events array).
+ * @complexity O(n) in events per render (memoized on the events array and the answered predicate).
  */
-export function useRunActivity({ events, active }, { now = Date.now } = {}) {
+export function useRunActivity({ events, active }, { now = Date.now, isAnsweredCard } = {}) {
     const t = useT();
-    const state = useMemo(() => deriveRunActivity({ events: events }), [events]);
+    const state = useMemo(() => deriveRunActivity({ events: events }, { isAnsweredCard }), [events, isAnsweredCard]);
     const [, setTick] = useState(0);
     const signal = useRef(null);
     const visible = useRef(null);

package/dist/react/index.d.ts

@@ -18,8 +18,8 @@ export type { ExtEventRenderProps, ExtEventRenderer, ExtEventRendererOptions, Ex
  * This alias has no removal date scheduled yet; see `chat-pane.ts` for the canonical surface and
  * the module doc there for why the split exists.
  */
-export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './chat-pane.js';
-export type { AgentRuntimePickerProps, ByokRuntimeSummary, ChatPaneActivity, ChatPaneAgent, ChatPaneAgentBridgeAccess, ChatPaneAgentControlOptions, ChatPaneAgentOption, ChatPaneAgentSelection, ChatPaneAgentToolAction, ChatPaneAgentToolDef, ChatPaneAgentToolInputSchema, ChatPaneAgentToolRisk, ChatPaneAttachmentUploadOptions, ChatPaneComposerHandle, ChatPaneProps, ChatPaneRunContext, ChatPaneRunContextInput, ChatPaneRuntimeAccess, ChatPaneVariant, ChatPaneWorkingDirectoryAccess, CreateDaemonAttachmentUploaderOptions, CreateMcpUiToolCallerOptions, CreateTypedAnswerPosterOptions, DeliverTypedAnswer, McpUiToolCallRequest, RuntimePickerPlacement, TypedAnswerDelivery, TypedAnswerNotice, UseChatPaneAgentControlOptions, UseChatPaneOptions, UseChatPaneResult, UseChatPaneRuntimeInventoryOptions, UseChatPaneRuntimeInventoryResult, UseChatPaneWorkingDirectoryOptions, UseChatPaneWorkingDirectoryResult, } from './chat-pane.js';
+export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createMidRunMessagePoster, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './chat-pane.js';
+export type { AgentRuntimePickerProps, ByokRuntimeSummary, ChatPaneActivity, ChatPaneAgent, ChatPaneAgentBridgeAccess, ChatPaneAgentControlOptions, ChatPaneAgentOption, ChatPaneAgentSelection, ChatPaneAgentToolAction, ChatPaneAgentToolDef, ChatPaneAgentToolInputSchema, ChatPaneAgentToolRisk, ChatPaneAttachmentUploadOptions, ChatPaneComposerHandle, ChatPaneProps, ChatPaneRunContext, ChatPaneRunContextInput, ChatPaneRuntimeAccess, ChatPaneVariant, ChatPaneWorkingDirectoryAccess, CreateDaemonAttachmentUploaderOptions, CreateMcpUiToolCallerOptions, CreateMidRunMessagePosterOptions, CreateTypedAnswerPosterOptions, DeliverMidRunMessage, DeliverTypedAnswer, McpUiToolCallRequest, MidRunMessageDelivery, RuntimePickerPlacement, TypedAnswerDelivery, TypedAnswerNotice, UseChatPaneAgentControlOptions, UseChatPaneOptions, UseChatPaneResult, UseChatPaneRuntimeInventoryOptions, UseChatPaneRuntimeInventoryResult, UseChatPaneWorkingDirectoryOptions, UseChatPaneWorkingDirectoryResult, } from './chat-pane.js';
 export { useRunStream, } from './hooks/useRunStream.js';
 export type { RunStreamState, RunStreamStatus, StartRunOptions, UseRunStreamResult, } from './hooks/useRunStream.js';
 export { useConversation, } from './hooks/useConversation.js';
@@ -84,6 +84,10 @@ export { appendComposerDiscovery } from './components/composer-discovery.js';
  */
 export { interleaveMessageBlocks } from './message-blocks.js';
 export type { MessageBlock } from './message-blocks.js';
+/** Transcript display modes for tool calls (`ChatPaneProps.toolCallDisplay`, 2026-10-11) — public so
+ * a custom message row can apply the same show / collapsed / hidden rules to its own blocks. */
+export { applyToolCallDisplay, isFailedToolRow, summarizeToolGroup, toolGroupLabel, toolRowsForDisplay } from './tool-call-display.js';
+export type { ToolCallDisplay, ToolDisplayRow, ToolGroupSummary } from './tool-call-display.js';
 export { TodoCard } from './components/TodoCard.js';
 export type { TodoCardProps } from './components/TodoCard.js';
 /**
@@ -111,6 +115,8 @@ export type { A2uiAgentActionOutcome, A2uiSurfaceCardProps } from './components/
  */
 export { McpUiSurfaceCard, mcpUiSurfaceSlotKey, registerMcpUiSurfaceRenderer, MCP_UI_EXT_EVENT_NAME } from './components/McpUiSurfaceCard.js';
 export type { McpUiSurfaceCardProps } from './components/McpUiSurfaceCard.js';
+/** A message sent mid-run (`ChatPane`'s `deliverMidRunMessage`), drawn as a user bubble inside the running turn. */
+export { MidRunUserMessage, midRunUserMessageSlotKey, registerMidRunUserMessageRenderer, MID_RUN_USER_MESSAGE_EXT_EVENT_NAME } from './components/MidRunUserMessage.js';
 export { ExtEventErrorBoundary } from './components/ExtEventErrorBoundary.js';
 export type { ExtEventErrorBoundaryProps } from './components/ExtEventErrorBoundary.js';
 export { QuestionForm } from './components/QuestionForm.js';

package/dist/react/index.js

@@ -26,7 +26,7 @@ export { clearExtEventRenderers, extEventSlot, getExtEventRenderer, registerExtE
  * This alias has no removal date scheduled yet; see `chat-pane.ts` for the canonical surface and
  * the module doc there for why the split exists.
  */
-export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './chat-pane.js';
+export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createMidRunMessagePoster, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './chat-pane.js';
 export { useRunStream, } from './hooks/useRunStream.js';
 export { useConversation, } from './hooks/useConversation.js';
 export { useComposer, } from './hooks/useComposer.js';
@@ -78,6 +78,9 @@ export { appendComposerDiscovery } from './components/composer-discovery.js';
  * the one live instance §10 found of R10's documented transitive-reach scope limit.
  */
 export { interleaveMessageBlocks } from './message-blocks.js';
+/** Transcript display modes for tool calls (`ChatPaneProps.toolCallDisplay`, 2026-10-11) — public so
+ * a custom message row can apply the same show / collapsed / hidden rules to its own blocks. */
+export { applyToolCallDisplay, isFailedToolRow, summarizeToolGroup, toolGroupLabel, toolRowsForDisplay } from './tool-call-display.js';
 export { TodoCard } from './components/TodoCard.js';
 /**
  * The conversation switcher — new / select / delete / search / rename-on-double-click. Storage
@@ -99,6 +102,8 @@ export { A2uiSurfaceCard } from './components/A2uiSurfaceCard.js';
  * resources instead of A2UI surfaces.
  */
 export { McpUiSurfaceCard, mcpUiSurfaceSlotKey, registerMcpUiSurfaceRenderer, MCP_UI_EXT_EVENT_NAME } from './components/McpUiSurfaceCard.js';
+/** A message sent mid-run (`ChatPane`'s `deliverMidRunMessage`), drawn as a user bubble inside the running turn. */
+export { MidRunUserMessage, midRunUserMessageSlotKey, registerMidRunUserMessageRenderer, MID_RUN_USER_MESSAGE_EXT_EVENT_NAME } from './components/MidRunUserMessage.js';
 export { ExtEventErrorBoundary } from './components/ExtEventErrorBoundary.js';
 export { QuestionForm } from './components/QuestionForm.js';
 export { QuestionsPanel } from './components/QuestionsPanel.js';

package/dist/react/message-blocks.d.ts

@@ -35,8 +35,8 @@
  * so every check below prefers the former.
  *
  * It refuses when:
- * - there are no events, or no tool rows AND no ext events to interleave (nothing to do — the flat
- *   path is identical);
+ * - there are no events, or no tool rows AND no ext events (AND no thinking, when the caller asked
+ *   for it) to interleave (nothing to do — the flat path is identical);
  * - the concatenated text events do not reproduce `content` byte for byte. This is the load-bearing
  *   check. A message persisted before the events schema settled, one rebuilt by a host that
  *   assembles `content` some other way, or any future divergence between the two, all land here;
@@ -69,6 +69,21 @@ export type MessageBlock<Row> = {
     readonly name: string;
     readonly slot: string;
     readonly key: string;
+}
+/** Where reply `index` of a run ends: just before the mid-run user message that started the next
+ * reply (`isReplyBoundary`). `MessageRow` hangs that reply's own "Done" line here. */
+ | {
+    readonly kind: 'reply-end';
+    readonly index: number;
+    readonly key: string;
+}
+/** The model's reasoning (`kind: 'thinking'` events), where it happened. Emitted only when the
+ * caller passes `includeThinking` (a host's "show thinking" display choice, 2026-10-11);
+ * back-to-back thinking events with no text between them join into one block. */
+ | {
+    readonly kind: 'thinking';
+    readonly text: string;
+    readonly key: string;
 };
 /**
  * Rebuilds an assistant message as ordered blocks, or returns `null` if that cannot be done
@@ -79,6 +94,9 @@ export type MessageBlock<Row> = {
  * @param rows - The tool timeline rows, already deduped and paired by `useToolTimeline`. Only rows
  *   present here are emitted, so a row the timeline chose to drop stays dropped.
  * @param slotOf - The render slot an ext event belongs to (default: its `name`).
+ * @param includeThinking - Emit `thinking` blocks for the model's reasoning (default `false`: thinking
+ *   events are skipped, the layout every host had before this option). Thinking text is not part of
+ *   `content`, so it never affects the lossless check below.
  * @returns Ordered blocks, or `null` to signal "render the flat layout instead".
  * @complexity O(n + m) in the event and row counts.
  */
@@ -88,10 +106,11 @@ export declare function interleaveMessageBlocks<Row extends {
     events: readonly AgentEvent[] | undefined;
     content: string;
     rows: readonly Row[];
-}, { slotOf }?: {
+}, { slotOf, includeThinking }?: {
     slotOf?: (ev: {
         readonly name: string;
         readonly data: unknown;
     }) => string;
+    includeThinking?: boolean;
 }): MessageBlock<Row>[] | null;
 //# sourceMappingURL=message-blocks.d.ts.map

package/dist/react/message-blocks.js

@@ -1,4 +1,4 @@
-import { assistantContentFromEvents, legacyAssistantContentFromEvents } from '../core/index.js';
+import { assistantContentFromEvents, isReplyBoundary, legacyAssistantContentFromEvents } from '../core/index.js';
 /**
  * Rebuilds an assistant message as ordered blocks, or returns `null` if that cannot be done
  * losslessly.
@@ -8,14 +8,18 @@ import { assistantContentFromEvents, legacyAssistantContentFromEvents } from '..
  * @param rows - The tool timeline rows, already deduped and paired by `useToolTimeline`. Only rows
  *   present here are emitted, so a row the timeline chose to drop stays dropped.
  * @param slotOf - The render slot an ext event belongs to (default: its `name`).
+ * @param includeThinking - Emit `thinking` blocks for the model's reasoning (default `false`: thinking
+ *   events are skipped, the layout every host had before this option). Thinking text is not part of
+ *   `content`, so it never affects the lossless check below.
  * @returns Ordered blocks, or `null` to signal "render the flat layout instead".
  * @complexity O(n + m) in the event and row counts.
  */
-export function interleaveMessageBlocks({ events, content, rows }, { slotOf = (ev) => ev.name } = {}) {
+export function interleaveMessageBlocks({ events, content, rows }, { slotOf = (ev) => ev.name, includeThinking = false } = {}) {
     if (!events || events.length === 0)
         return null;
     const hasExtEvent = events.some((ev) => ev.kind === 'ext');
-    if (rows.length === 0 && !hasExtEvent)
+    const hasThinking = includeThinking && events.some((ev) => ev.kind === 'thinking' && ev.text.trim() !== '');
+    if (rows.length === 0 && !hasExtEvent && !hasThinking)
         return null;
     // The reconstruction is only trustworthy if the text events are demonstrably the source `content`
     // was built from. Anything else and the offsets below are fiction.
@@ -28,6 +32,7 @@ export function interleaveMessageBlocks({ events, content, rows }, { slotOf = (e
     const emitted = new Set();
     const emittedExtSlots = new Set();
     let buffer = '';
+    let replies = 0;
     const flushText = () => {
         if (buffer.length === 0)
             return;
@@ -39,6 +44,23 @@ export function interleaveMessageBlocks({ events, content, rows }, { slotOf = (e
             buffer += ev.text;
             continue;
         }
+        if (ev.kind === 'thinking') {
+            if (!includeThinking)
+                continue;
+            flushText();
+            const last = blocks[blocks.length - 1];
+            if (last && last.kind === 'thinking')
+                blocks[blocks.length - 1] = { kind: 'thinking', text: last.text + ev.text, key: last.key };
+            else
+                blocks.push({ kind: 'thinking', text: ev.text, key: `thinking-${blocks.length}` });
+            continue;
+        }
+        if (isReplyBoundary({ event: ev })) {
+            // Emitted per boundary, before any slot dedupe below, so every reply gets its own end marker.
+            flushText();
+            blocks.push({ kind: 'reply-end', index: replies, key: `reply-end-${replies}` });
+            replies += 1;
+        }
         if (ev.kind === 'ext') {
             // One block per SLOT, at its first occurrence — later events in the same slot fold into it
             // (`useExtEventGroups`'s job in `MessageRow.tsx`), not a second block. A slot is the `name`

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

@@ -0,0 +1,90 @@
+/**
+ * @module tool-call-display
+ *
+ * How a transcript shows tool calls (owner, 2026-10-11 — the Tovu dock's Chat settings → Display):
+ *
+ * - `'show'`      — every tool card, where it happened. The layout every host had before this.
+ * - `'collapsed'` — each turn's tool cards fold into ONE line ("Used 3 tools") that expands on
+ *   click; while a tool runs the line names it instead ("Running Bash…").
+ * - `'hidden'`    — no tool cards at all, EXCEPT a failed one: an error must never vanish from the
+ *   transcript just because the reader asked for a quieter view.
+ *
+ * Pure rules over `interleaveMessageBlocks`' output (or the flat row list when that refused), kept
+ * out of `MessageRow.tsx` so every mode is testable without rendering.
+ */
+import type { ToolStatus } from '../core/index.js';
+import type { MessageBlock } from './message-blocks.js';
+export type ToolCallDisplay = 'show' | 'collapsed' | 'hidden';
+/** The fields of a tool row these rules read — `ToolTimelineRow` satisfies it. */
+export interface ToolDisplayRow {
+    readonly id: string;
+    readonly name: string;
+    readonly status: ToolStatus;
+    readonly use?: {
+        readonly input: unknown;
+    };
+}
+/**
+ * Whether a row is a failure the reader must always see: the tool returned an error, or the run
+ * ended without the tool ever answering (`deriveToolStatus` maps both to `'error'`).
+ * @complexity O(1).
+ */
+export declare function isFailedToolRow({ row }: {
+    row: Pick<ToolDisplayRow, 'status'>;
+}): boolean;
+/**
+ * Applies a display mode to an interleaved message.
+ *
+ * `'collapsed'` merges every `tools` block of one turn into the turn's FIRST `tools` block (its
+ * position and key), so the turn shows a single fold-up line. A turn ends at a `reply-end` block —
+ * the mid-run user message that starts the next reply — so a message holding several replies keeps
+ * one line per reply. Keeping the first block's key keeps the line's open/closed state across
+ * streaming updates, since later blocks append after it.
+ *
+ * `'hidden'` keeps only failed rows and drops `tools` blocks left empty.
+ *
+ * @param input.blocks - `interleaveMessageBlocks` output.
+ * @param input.mode - The display mode.
+ * @returns New blocks; the input is never mutated. `'show'` returns `blocks` itself.
+ * @complexity O(n) in blocks + rows.
+ */
+export declare function applyToolCallDisplay<Row extends ToolDisplayRow>({ blocks, mode }: {
+    blocks: readonly MessageBlock<Row>[];
+    mode: ToolCallDisplay;
+}): readonly MessageBlock<Row>[];
+/**
+ * The flat layout's counterpart (used when `interleaveMessageBlocks` refused): `'hidden'` keeps only
+ * failed rows; the other modes keep every row (`'collapsed'` folds them into one line at render).
+ * @complexity O(n) in rows.
+ */
+export declare function toolRowsForDisplay<Row extends ToolDisplayRow>({ rows, mode }: {
+    rows: readonly Row[];
+    mode: ToolCallDisplay;
+}): readonly Row[];
+/** What a collapsed tool line says: the tool running now, or how many ran (and how many failed). */
+export type ToolGroupSummary = {
+    readonly kind: 'running';
+    readonly name: string;
+} | {
+    readonly kind: 'done';
+    readonly count: number;
+    readonly failed: number;
+};
+/**
+ * Summarises one turn's tool rows. The LAST running row wins, so a line over several in-flight calls
+ * names the newest one, matching what the run is doing now.
+ * @complexity O(n) in rows.
+ */
+export declare function summarizeToolGroup({ rows }: {
+    rows: readonly ToolDisplayRow[];
+}): ToolGroupSummary;
+/**
+ * The collapsed line's text. Each phrase is its own translation key (the English string is the key,
+ * see `slots.ts`), with `{count}`/`{name}` filled by the translator.
+ * @complexity O(1).
+ */
+export declare function toolGroupLabel({ summary, t }: {
+    summary: ToolGroupSummary;
+    t: (key: string, vars?: Record<string, string | number>) => string;
+}): string;
+//# sourceMappingURL=tool-call-display.d.ts.map

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

@@ -0,0 +1,97 @@
+import { humanizeToolName } from '../core/index.js';
+/**
+ * Whether a row is a failure the reader must always see: the tool returned an error, or the run
+ * ended without the tool ever answering (`deriveToolStatus` maps both to `'error'`).
+ * @complexity O(1).
+ */
+export function isFailedToolRow({ row }) {
+    return row.status === 'error';
+}
+/** Running = no result yet while the run streams (`'executing'`), or not started (`'inProgress'`). */
+function isRunningToolRow(row) {
+    return row.status === 'executing' || row.status === 'inProgress';
+}
+/**
+ * Applies a display mode to an interleaved message.
+ *
+ * `'collapsed'` merges every `tools` block of one turn into the turn's FIRST `tools` block (its
+ * position and key), so the turn shows a single fold-up line. A turn ends at a `reply-end` block —
+ * the mid-run user message that starts the next reply — so a message holding several replies keeps
+ * one line per reply. Keeping the first block's key keeps the line's open/closed state across
+ * streaming updates, since later blocks append after it.
+ *
+ * `'hidden'` keeps only failed rows and drops `tools` blocks left empty.
+ *
+ * @param input.blocks - `interleaveMessageBlocks` output.
+ * @param input.mode - The display mode.
+ * @returns New blocks; the input is never mutated. `'show'` returns `blocks` itself.
+ * @complexity O(n) in blocks + rows.
+ */
+export function applyToolCallDisplay({ blocks, mode }) {
+    if (mode === 'show')
+        return blocks;
+    if (mode === 'hidden') {
+        const out = [];
+        for (const block of blocks) {
+            if (block.kind !== 'tools') {
+                out.push(block);
+                continue;
+            }
+            const failed = block.rows.filter((row) => isFailedToolRow({ row }));
+            if (failed.length > 0)
+                out.push({ kind: 'tools', rows: failed, key: block.key });
+        }
+        return out;
+    }
+    const out = [];
+    let turnToolsIndex = -1;
+    for (const block of blocks) {
+        if (block.kind === 'reply-end')
+            turnToolsIndex = -1;
+        if (block.kind !== 'tools') {
+            out.push(block);
+            continue;
+        }
+        const first = turnToolsIndex === -1 ? undefined : out[turnToolsIndex];
+        if (first && first.kind === 'tools') {
+            out[turnToolsIndex] = { kind: 'tools', rows: [...first.rows, ...block.rows], key: first.key };
+            continue;
+        }
+        turnToolsIndex = out.length;
+        out.push(block);
+    }
+    return out;
+}
+/**
+ * The flat layout's counterpart (used when `interleaveMessageBlocks` refused): `'hidden'` keeps only
+ * failed rows; the other modes keep every row (`'collapsed'` folds them into one line at render).
+ * @complexity O(n) in rows.
+ */
+export function toolRowsForDisplay({ rows, mode }) {
+    return mode === 'hidden' ? rows.filter((row) => isFailedToolRow({ row })) : rows;
+}
+/**
+ * Summarises one turn's tool rows. The LAST running row wins, so a line over several in-flight calls
+ * names the newest one, matching what the run is doing now.
+ * @complexity O(n) in rows.
+ */
+export function summarizeToolGroup({ rows }) {
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+        const row = rows[i];
+        if (isRunningToolRow(row))
+            return { kind: 'running', name: humanizeToolName({ name: row.name }, { input: row.use?.input }) };
+    }
+    return { kind: 'done', count: rows.length, failed: rows.filter((row) => isFailedToolRow({ row })).length };
+}
+/**
+ * The collapsed line's text. Each phrase is its own translation key (the English string is the key,
+ * see `slots.ts`), with `{count}`/`{name}` filled by the translator.
+ * @complexity O(1).
+ */
+export function toolGroupLabel({ summary, t }) {
+    if (summary.kind === 'running')
+        return t('Running {name}…', { name: summary.name });
+    const used = summary.count === 1 ? t('Used 1 tool') : t('Used {count} tools', { count: summary.count });
+    return summary.failed > 0 ? `${used} · ${t('{count} failed', { count: summary.failed })}` : used;
+}
+//# sourceMappingURL=tool-call-display.js.map