@jini-ai/chat 0.6.6 → 0.6.10

package/dist/react/message-blocks.js

@@ -1,4 +1,84 @@
 import { assistantContentFromEvents, isReplyBoundary, legacyAssistantContentFromEvents } from '../core/index.js';
+/** Whether there is anything besides plain text to place: a tool row, an ext event, or (when asked
+ * for) non-blank thinking. With none of these the flat path is identical. */
+function hasSomethingToInterleave({ events, rows }, { includeThinking }) {
+    if (rows.length > 0)
+        return true;
+    return events.some((ev) => ev.kind === 'ext' || (includeThinking && ev.kind === 'thinking' && ev.text.trim() !== ''));
+}
+/** Whether `content` is demonstrably built from the text events. */
+function contentMatchesEvents({ events, content }) {
+    // Both producers' shapes count: today's (a paragraph break between steps, see
+    // `assistantContentFromEvents`) and the old plain concatenation older saved rows carry.
+    return content === assistantContentFromEvents({ events }) || content === legacyAssistantContentFromEvents({ events });
+}
+function flushText({ state }) {
+    if (state.buffer.length === 0)
+        return;
+    state.blocks.push({ kind: 'text', text: state.buffer, key: `text-${state.blocks.length}` });
+    state.buffer = '';
+}
+function placeThinking({ state, text }) {
+    flushText({ state });
+    const { blocks } = state;
+    const last = blocks[blocks.length - 1];
+    if (last && last.kind === 'thinking')
+        blocks[blocks.length - 1] = { kind: 'thinking', text: last.text + text, key: last.key };
+    else
+        blocks.push({ kind: 'thinking', text, key: `thinking-${blocks.length}` });
+}
+function placeReplyEnd({ state }) {
+    flushText({ state });
+    state.blocks.push({ kind: 'reply-end', index: state.replies, key: `reply-end-${state.replies}` });
+    state.replies += 1;
+}
+function placeExt({ state, ev }, { slotOf }) {
+    // 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`
+    // unless its renderer keys events into separate surfaces (see `ExtEventSlotKey`).
+    const slot = slotOf(ev);
+    if (state.emittedExtSlots.has(slot))
+        return;
+    state.emittedExtSlots.add(slot);
+    flushText({ state });
+    state.blocks.push({ kind: 'ext', name: ev.name, slot, key: `ext-${slot}` });
+}
+function placeToolUse({ state, id }) {
+    const row = state.rowById.get(id);
+    // A `tool_use` the timeline did not surface (deduped away as a repeat of one already seen).
+    // Skipping it keeps this function's output consistent with `rows`, which is the authority on
+    // what gets a card.
+    if (!row || state.emitted.has(id))
+        return;
+    state.emitted.add(id);
+    flushText({ state });
+    const { blocks } = state;
+    const last = blocks[blocks.length - 1];
+    if (last && last.kind === 'tools') {
+        blocks[blocks.length - 1] = { kind: 'tools', rows: [...last.rows, row], key: last.key };
+    }
+    else {
+        blocks.push({ kind: 'tools', rows: [row], key: `tools-${blocks.length}` });
+    }
+}
+function placeEvent({ state, ev }, { slotOf, includeThinking }) {
+    if (ev.kind === 'text') {
+        state.buffer += ev.text;
+        return;
+    }
+    if (ev.kind === 'thinking') {
+        if (includeThinking)
+            placeThinking({ state, text: ev.text });
+        return;
+    }
+    // Emitted per boundary, before any slot dedupe below, so every reply gets its own end marker.
+    if (isReplyBoundary({ event: ev }))
+        placeReplyEnd({ state });
+    if (ev.kind === 'ext')
+        placeExt({ state, ev }, { slotOf });
+    else if (ev.kind === 'tool_use')
+        placeToolUse({ state, id: ev.id });
+}
 /**
  * Rebuilds an assistant message as ordered blocks, or returns `null` if that cannot be done
  * losslessly.
@@ -17,85 +97,27 @@ import { assistantContentFromEvents, isReplyBoundary, legacyAssistantContentFrom
 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');
-    const hasThinking = includeThinking && events.some((ev) => ev.kind === 'thinking' && ev.text.trim() !== '');
-    if (rows.length === 0 && !hasExtEvent && !hasThinking)
+    if (!hasSomethingToInterleave({ events, rows }, { includeThinking }))
         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.
-    // Both producers' shapes count: today's (a paragraph break between steps, see
-    // `assistantContentFromEvents`) and the old plain concatenation older saved rows carry.
-    if (content !== assistantContentFromEvents({ events }) && content !== legacyAssistantContentFromEvents({ events: events }))
+    if (!contentMatchesEvents({ events, content }))
         return null;
-    const rowById = new Map(rows.map((row) => [row.id, row]));
-    const blocks = [];
-    const emitted = new Set();
-    const emittedExtSlots = new Set();
-    let buffer = '';
-    let replies = 0;
-    const flushText = () => {
-        if (buffer.length === 0)
-            return;
-        blocks.push({ kind: 'text', text: buffer, key: `text-${blocks.length}` });
-        buffer = '';
+    const state = {
+        rowById: new Map(rows.map((row) => [row.id, row])),
+        blocks: [],
+        emitted: new Set(),
+        emittedExtSlots: new Set(),
+        buffer: '',
+        replies: 0,
     };
-    for (const ev of events) {
-        if (ev.kind === 'text') {
-            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`
-            // unless its renderer keys events into separate surfaces (see `ExtEventSlotKey`).
-            const slot = slotOf(ev);
-            if (emittedExtSlots.has(slot))
-                continue;
-            emittedExtSlots.add(slot);
-            flushText();
-            blocks.push({ kind: 'ext', name: ev.name, slot, key: `ext-${slot}` });
-            continue;
-        }
-        if (ev.kind !== 'tool_use')
-            continue;
-        const row = rowById.get(ev.id);
-        // A `tool_use` the timeline did not surface (deduped away as a repeat of one already seen).
-        // Skipping it keeps this function's output consistent with `rows`, which is the authority on
-        // what gets a card.
-        if (!row || emitted.has(ev.id))
-            continue;
-        emitted.add(ev.id);
-        flushText();
-        const last = blocks[blocks.length - 1];
-        if (last && last.kind === 'tools') {
-            blocks[blocks.length - 1] = { kind: 'tools', rows: [...last.rows, row], key: last.key };
-        }
-        else {
-            blocks.push({ kind: 'tools', rows: [row], key: `tools-${blocks.length}` });
-        }
-    }
-    flushText();
+    for (const ev of events)
+        placeEvent({ state, ev }, { slotOf, includeThinking });
+    flushText({ state });
     // Every row must have found its place. If one did not, the message would render with a tool card
     // missing entirely — strictly worse than the flat layout it would have had.
-    if (emitted.size !== rows.length)
+    if (state.emitted.size !== rows.length)
         return null;
-    return blocks;
+    return state.blocks;
 }
 //# sourceMappingURL=message-blocks.js.map

package/dist/react/slots.d.ts

@@ -179,8 +179,8 @@ export interface ComposerSlots {
      * Host controls rendered at the START of the footer row, immediately after the attach/discovery
      * "+" trigger — for a control that belongs with the composer's other action-row buttons (e.g. a
      * push-to-talk mic button) rather than in {@link leadingAccessories}'s pinned-context zone above
-     * the input, or in {@link footerAccessories}'s trailing slot (reserved for an agent/model picker
-     * and pushed to the row's far end via `margin-left: auto`).
+     * the input, or in {@link footerAccessories}'s slot (reserved for an agent/model picker, which
+     * follows this one; only the send group is pushed to the row's far end).
      */
     footerLeadingAccessory?: ReactNode;
     onAttach?: (a: ChatAttachment) => void;

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

@@ -6,8 +6,8 @@
  * - `'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.
+ * - `'hidden'`    — recovered failures disappear with successful calls. Unrecovered failures stay
+ *   behind one compact disclosure per reply: work that stopped must never vanish silently.
  *
  * 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.
@@ -25,7 +25,7 @@ export interface ToolDisplayRow {
     };
 }
 /**
- * Whether a row is a failure the reader must always see: the tool returned an error, or the run
+ * Whether a row failed: the tool returned an error, or the run
  * ended without the tool ever answering (`deriveToolStatus` maps both to `'error'`).
  * @complexity O(1).
  */
@@ -41,7 +41,8 @@ export declare function isFailedToolRow({ row }: {
  * 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.
+ * `'hidden'` keeps unrecovered failures in one block per reply. Later assistant text or a successful
+ * tool proves recovery; running tools and reasoning do not. An errored final reply keeps its failures.
  *
  * @param input.blocks - `interleaveMessageBlocks` output.
  * @param input.mode - The display mode.
@@ -51,15 +52,20 @@ export declare function isFailedToolRow({ row }: {
 export declare function applyToolCallDisplay<Row extends ToolDisplayRow>({ blocks, mode }: {
     blocks: readonly MessageBlock<Row>[];
     mode: ToolCallDisplay;
+}, { runFailed }?: {
+    runFailed?: boolean;
 }): 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).
+ * Row-level recovery scan, also used by the flat fallback. Without trustworthy text ordering,
+ * only later successful rows prove recovery. Other modes keep every row.
  * @complexity O(n) in rows.
  */
 export declare function toolRowsForDisplay<Row extends ToolDisplayRow>({ rows, mode }: {
     rows: readonly Row[];
     mode: ToolCallDisplay;
+}, { recovered, runFailed }?: {
+    recovered?: boolean;
+    runFailed?: boolean;
 }): readonly Row[];
 /** What a collapsed tool line says: the tool running now, or how many ran (and how many failed). */
 export type ToolGroupSummary = {

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

@@ -1,6 +1,6 @@
 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
+ * Whether a row failed: the tool returned an error, or the run
  * ended without the tool ever answering (`deriveToolStatus` maps both to `'error'`).
  * @complexity O(1).
  */
@@ -20,55 +20,84 @@ function isRunningToolRow(row) {
  * 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.
+ * `'hidden'` keeps unrecovered failures in one block per reply. Later assistant text or a successful
+ * tool proves recovery; running tools and reasoning do not. An errored final reply keeps its failures.
  *
  * @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 }) {
+export function applyToolCallDisplay({ blocks, mode }, { runFailed = false } = {}) {
     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 mode === 'hidden' ? hideToolCalls({ blocks, runFailed }) : collapseToolCalls({ blocks });
+}
+/**
+ * Scan backwards so only later content in the SAME reply can prove recovery. Failures stay visible
+ * while streaming until that evidence arrives. This is a display filter, never a deletion from the
+ * durable events: see assistant-client/transport.ts's forensics rationale.
+ * @complexity O(n) in blocks + rows, excluding the shared grouping pass.
+ */
+function hideToolCalls({ blocks, runFailed }) {
+    const out = [];
+    let recovered = false;
+    let failedReply = runFailed;
+    for (let i = blocks.length - 1; i >= 0; i -= 1) {
+        const block = blocks[i];
+        if (block.kind === 'reply-end') {
+            recovered = false;
+            failedReply = false;
+        }
+        if (block.kind === 'text' && block.text.trim())
+            recovered = true;
+        if (block.kind !== 'tools') {
+            out.push(block);
+            continue;
         }
-        return out;
+        const rows = toolRowsForDisplay({ rows: block.rows, mode: 'hidden' }, { recovered, runFailed: failedReply });
+        if (rows.length > 0)
+            out.push({ ...block, rows });
+        if (block.rows.some((row) => row.status === 'complete'))
+            recovered = true;
     }
+    return collapseToolCalls({ blocks: out.reverse() });
+}
+/** `'collapsed'`: merges every `tools` block of a turn into the turn's first one (see above). */
+function collapseToolCalls({ blocks }) {
     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') {
+        if (block.kind === 'tools' && first?.kind === 'tools') {
             out[turnToolsIndex] = { kind: 'tools', rows: [...first.rows, ...block.rows], key: first.key };
             continue;
         }
-        turnToolsIndex = out.length;
+        if (block.kind === 'tools')
+            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).
+ * Row-level recovery scan, also used by the flat fallback. Without trustworthy text ordering,
+ * only later successful rows prove recovery. Other modes keep every row.
  * @complexity O(n) in rows.
  */
-export function toolRowsForDisplay({ rows, mode }) {
-    return mode === 'hidden' ? rows.filter((row) => isFailedToolRow({ row })) : rows;
+export function toolRowsForDisplay({ rows, mode }, { recovered = false, runFailed = false } = {}) {
+    if (mode !== 'hidden')
+        return rows;
+    const failed = [];
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+        const row = rows[i];
+        if (isFailedToolRow({ row }) && (runFailed || !recovered))
+            failed.push(row);
+        if (row.status === 'complete')
+            recovered = true;
+    }
+    return failed.reverse();
 }
 /**
  * Summarises one turn's tool rows. The LAST running row wins, so a line over several in-flight calls