@jini-ai/chat 0.6.7 → 0.6.11

package/dist/react/components/Markdown.js

@@ -428,9 +428,9 @@ function renderInline(text) {
         else if (mdLink)
             nodes.push(renderMarkdownLink(mdLink, key++));
         else if (bold)
-            nodes.push(_jsx("strong", { children: bold.slice(2, -2) }, key++));
+            nodes.push(_jsx("strong", { children: renderInline(bold.slice(2, -2)) }, key++));
         else if (italic)
-            nodes.push(_jsx("em", { children: italic.slice(1, -1) }, key++));
+            nodes.push(_jsx("em", { children: renderInline(italic.slice(1, -1)) }, key++));
         else if (link)
             nodes.push(_jsx("a", { href: link, ...NEW_TAB, children: link }, key++));
         // `whole` is `match[0]` — a successful `RegExpExecArray` always has a

package/dist/react/components/McpUiSurfaceCard.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * @module components/McpUiSurfaceCard
  *
@@ -120,8 +120,10 @@ function PendingSurfaceMirror({ uri, plan, t }) {
 }
 /** A closed card: the question's title, when the call gave one, and why it is closed. */
 function ClosedSurface({ call, label }) {
-    const title = call?.input?.title;
-    return (_jsx("div", { className: "mcpui-surface-card mcpui-surface-card-closed", role: "status", children: typeof title === 'string' && title.trim() !== '' ? `${title}: ${label}` : label }));
+    const input = call?.input;
+    const title = [input?.title, input?.question, input?.prompt]
+        .find(value => typeof value === 'string' && value.trim() !== '');
+    return (_jsx("div", { className: "mcpui-surface-card mcpui-surface-card-closed", role: "status", children: typeof title === 'string' ? `${title}: ${label}` : label }));
 }
 /** The live card's answer lifecycle: its deadline and delivery notification, using their existing owners. */
 function surfaceInteraction({ resource, answered, onToolCall, onAnswered, onAnswerText, call }, _options = {}) {
@@ -144,16 +146,17 @@ export function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLi
     const closed = single === undefined
         ? undefined
         : closedSurfaceLabel({ t, call, runStreaming, documentsForUri: events.length, expired: expiry?.expired === true });
-    const answer = answerText ?? questionAnswerFromResult({ result: call?.result, input: call?.input });
+    const answer = questionAnswerFromResult({ result: call?.result, input: call?.input }) ?? answerText;
     return _jsx(SurfaceCardContent, { resources: resources, single: single, answerRecorded: answerRecorded, answer: answer, closed: closed, call: call, t: t, sandboxProxyUrl: sandboxProxyUrl, toolCall: toolCall, onOpenLink: onOpenLink, maxHeight: maxHeight, expiry: expiry });
 }
 /** Rendering priority stays receipt, answer, closure, then the live documents. */
 function SurfaceCardContent({ resources, single, answerRecorded, answer, closed, call, t, sandboxProxyUrl, toolCall, onOpenLink, maxHeight, expiry }) {
-    // MOVE: The accepted-input receipt owns its bubble; rendering the closed card too duplicates typed answers.
+    // MOVE: The accepted-input receipt owns its bubble; the closed card retains the question's context.
     if (single !== undefined && answerRecorded)
-        return null;
+        return _jsx(ClosedSurface, { call: call, label: answer ?? closed ?? t('Answered') });
     if (single !== undefined && answer !== undefined) {
-        return _jsx(MidRunUserMessage, { events: [{ text: answer === 'Declined' ? t('Declined') : answer }] });
+        const label = answer === 'Declined' ? t('Declined') : answer;
+        return _jsxs(_Fragment, { children: [_jsx(ClosedSurface, { call: call, label: label }), _jsx(MidRunUserMessage, { events: [{ text: label }] })] });
     }
     if (closed !== undefined)
         return _jsx(ClosedSurface, { call: call, label: closed });

package/dist/react/components/MessageList.hooks.js

@@ -6,11 +6,15 @@
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { conversationUsage } from '../../core/turn-usage.js';
+import { projectAcceptedInputEvents } from '../../core/accepted-input.js';
 import { nextStickToBottom, startsNewTurn } from './MessageList.rules.js';
 const prefersReducedMotion = () => typeof window !== 'undefined' && (window.matchMedia?.('(prefers-reduced-motion: reduce)').matches ?? false);
 /** Recompute costs once per immutable transcript snapshot, including saved history on reload. */
 export function useConversationUsage({ messages }, _optional = {}) {
-    return useMemo(() => conversationUsage({ messages }), [messages]);
+    // Usage and rendering must see the same answer boundaries, including receipts rebuilt on reload.
+    return useMemo(() => conversationUsage({ messages: messages.map(message => message.events === undefined ? message : {
+            ...message, events: projectAcceptedInputEvents({ events: message.events }),
+        }) }), [messages]);
 }
 export function useMessageListAutoScroll({ messages, scrollIntent }, { onScrolled, reducedMotion = prefersReducedMotion } = {}) {
     const containerRef = useRef(null);

package/dist/react/components/MessageRow.d.ts

@@ -63,7 +63,7 @@ export interface MessageRowProps {
      * included (a host's "Done line" display choice, 2026-10-11). */
     showUsageLine?: boolean;
     /** How tool calls show (`../tool-call-display.ts`): every card (`'show'`, the default), one
-     * fold-up line per turn (`'collapsed'`), or only failed ones (`'hidden'`). */
+     * fold-up line per turn (`'collapsed'`), or compact unrecovered failures (`'hidden'`). */
     toolCallDisplay?: ToolCallDisplay;
     /** Show the model's reasoning (`thinking` events) as a fold-up block where it happened. Off by
      * default — the transcript never showed it before this option. Needs the interleaved layout; a

package/dist/react/components/MessageRow.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { projectAcceptedInputEvents } from '../../core/accepted-input.js';
 import { MidRunUserMessage, MID_RUN_USER_MESSAGE_EXT_EVENT_NAME } from './MidRunUserMessage.js';
 import { terminalMessageNotice, continuingRunNotice } from '../../core/durable-projection.js';
-import { usageLayout, usageLineMeetsActions, useMessageUsage, useUsageSummary } from './MessageRow.usage.js';
+import { usageEndLabel, usageLayout, usageLineMeetsActions, useMessageUsage, useUsageSummary } from './MessageRow.usage.js';
 /**
  * @module MessageRow
  *
@@ -54,7 +54,7 @@ import { usageLayout, usageLineMeetsActions, useMessageUsage, useUsageSummary }
  * chunk stopped arriving.
  */
 import React, { memo, useMemo } from 'react';
-import { isAwaitingAnswer, isTerminalRunStatus, splitOnQuestionForms, stripArtifact } from '../../core/index.js';
+import { assistantContentFromEvents, isAwaitingAnswer, isTerminalRunStatus, splitOnQuestionForms, stripArtifact } from '../../core/index.js';
 import { useToolTimeline } from '../hooks/useToolTimeline.js';
 import { useExtEventGroups } from '../hooks/useExtEventGroups.js';
 import { useCopyToClipboard } from '../hooks/useCopyToClipboard.js';
@@ -111,23 +111,33 @@ function isRunInProgress(runStatus) {
 /** One "Done · 6m 29s · $0.41 · total $2.50" line from reported usage, never estimated (the total is
  * left off when `showTotal` is false). Partial usage stays partial; output tokens are available to
  * assistive technology and in the tooltip. */
-function UsageSummary({ usage, showTotal }) {
+function UsageSummary({ usage, showTotal, message, awaitingAnswer }) {
     const t = useT();
-    const { text, title, ariaLabel } = useUsageSummary({ usage }, { showTotal });
+    const label = usageEndLabel({ usage, ...(message === undefined ? {} : { message }), ...(awaitingAnswer === undefined ? {} : { awaitingAnswer }) });
+    const { text, title, ariaLabel } = useUsageSummary({ usage }, { showTotal, label });
     if (!text)
         return null;
-    return (_jsxs("div", { className: "jini-message-usage", title: title, role: "note", "aria-label": ariaLabel, children: [_jsx("span", { className: "jini-message-usage-dot", "aria-hidden": true, children: "\u25CF" }), t('Done'), " \u00B7 ", text] }));
+    return (_jsxs("div", { className: "jini-message-usage", title: title, role: "note", "aria-label": ariaLabel, children: [label === 'Done' ? _jsx("span", { className: "jini-message-usage-dot", "aria-hidden": true, children: "\u25CF" }) : null, t(label), " \u00B7 ", text] }));
 }
-function messageBlocks({ visibleContent, message, rows, registry }, { toolCallDisplay = 'show', includeThinking = false } = {}) {
-    // Interleaving is skipped outright when an artifact was stripped. `stripArtifact` operates on the
-    // whole string and trims, so the surviving text no longer lines up with the per-run offsets the
-    // event walk produces, and an artifact block could legitimately span a tool call. Rather than
-    // reason about partial overlaps, an artifact-bearing message keeps the flat layout — those
-    // messages are dominated by the artifact panel anyway, so the ordering matters least there.
-    if (visibleContent !== message.content)
-        return null;
-    const blocks = interleaveMessageBlocks({ events: message.events, content: message.content, rows }, { slotOf: (ev) => registry.slot({ name: ev.name, data: ev.data }), includeThinking });
-    return blocks ? applyToolCallDisplay({ blocks, mode: toolCallDisplay }) : null;
+function messageBlocks({ message, rows, registry, content = message.content }, { toolCallDisplay = 'show', includeThinking = false } = {}) {
+    const blocks = interleaveMessageBlocks({ events: message.events, content, rows }, { slotOf: (ev) => registry.slot({ name: ev.name, data: ev.data }), includeThinking });
+    return blocks ? applyToolCallDisplay({ blocks, mode: toolCallDisplay }, { runFailed: message.runStatus === 'failed' }) : null;
+}
+/**
+ * The flat layout's tool groups. Even when host text prevents interleaving, event ordering can still
+ * prove tool recovery and reply boundaries, so hidden mode reconstructs the blocks from the events —
+ * only for this display decision; the host's text is never replaced. Otherwise one flat list.
+ * @complexity O(n) in events + rows.
+ */
+function flatToolGroups({ message, rows, registry, displayBlocks }, { toolCallDisplay }) {
+    if (toolCallDisplay === 'hidden') {
+        const recovery = displayBlocks
+            ?? messageBlocks({ message, rows, registry, content: assistantContentFromEvents({ events: message.events ?? [] }) }, { toolCallDisplay });
+        if (recovery)
+            return recovery.flatMap((block) => (block.kind === 'tools' ? [{ rows: block.rows, key: block.key }] : []));
+    }
+    const flat = toolRowsForDisplay({ rows, mode: toolCallDisplay }, { runFailed: message.runStatus === 'failed' });
+    return flat.length > 0 ? [{ rows: flat, key: 'tools' }] : [];
 }
 /** The model's reasoning, folded under a "Thinking" summary so it never crowds the answer. */
 function ThinkingBlock({ text }) {
@@ -141,7 +151,7 @@ function messageAwaitingAnswer({ runStreaming, runInProgress, events }, { isAnsw
 }
 function AssistantMessageFooter({ message, usageEvent, showUsageTotal, terminalNotice, pending, runInProgress, runStreaming, visibleContent, isAnsweredCard }, _optional = {}) {
     const t = useT();
-    return _jsxs(_Fragment, { children: [usageEvent ? _jsx(UsageSummary, { usage: usageEvent, showTotal: showUsageTotal }) : null, terminalNotice ? _jsx("div", { className: "jini-message-error", role: "status", children: t(terminalNotice) }) : null, !pending && !runInProgress ? (_jsx("div", { className: "jini-message-actions jini-message-actions--assistant", children: _jsx(CopyMessageButton, { text: visibleContent, label: t('Copy message') }) })) : null, runInProgress ? _jsx(RunActivityLine, { events: message.events, active: pending || (runStreaming === true && runInProgress), isAnsweredCard: isAnsweredCard }) : null] });
+    return _jsxs(_Fragment, { children: [usageEvent ? _jsx(UsageSummary, { usage: usageEvent, showTotal: showUsageTotal, message: message, awaitingAnswer: isAwaitingAnswer({ events: message.events }, { isAnsweredCard }) }) : null, terminalNotice ? _jsx("div", { className: "jini-message-error", role: "status", children: t(terminalNotice) }) : null, !pending && !runInProgress ? (_jsx("div", { className: "jini-message-actions jini-message-actions--assistant", children: _jsx(CopyMessageButton, { text: visibleContent, label: t('Copy message') }) })) : null, runInProgress ? _jsx(RunActivityLine, { events: message.events, active: pending || (runStreaming === true && runInProgress), isAnsweredCard: isAnsweredCard }) : null] });
 }
 /**
  * Quiet, icon-only copy affordance shared by the user- and assistant-message
@@ -191,18 +201,24 @@ function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageL
     const answeredCards = useAnsweredCards({ slotOf: registry.slot, events: message.events ?? [], groups: extGroups, runStreaming, runStatus: message.runStatus });
     const terminalNotice = terminalMessageNotice({ message }, {});
     const visibleContent = stripArtifact({ content: message.content });
-    const blocks = messageBlocks({ visibleContent, message, rows: timeline.rows, registry }, { toolCallDisplay, includeThinking: showThinking });
+    const displayBlocks = messageBlocks({ message, rows: timeline.rows, registry }, { toolCallDisplay, includeThinking: showThinking });
+    // Artifact stripping trims/replaces text, invalidating the event offsets for rendering. Keep the
+    // flat layout there; displayBlocks still supplies the recovery decision from the original events.
+    const blocks = visibleContent === message.content ? displayBlocks : null;
     const pending = isPendingWithNoContent(message, visibleContent, timeline.rows.length);
     const runInProgress = isRunInProgress(message.runStatus);
     const awaitingAnswer = messageAwaitingAnswer({ runStreaming, runInProgress, events: message.events }, { isAnsweredCard: answeredCards.isAnsweredCard });
-    const usage = usageLayout({ usage: messageUsage, interleaved: blocks !== null, runInProgress }, { runStreaming });
+    const usage = usageLayout({ usage: messageUsage, interleaved: blocks !== null, runInProgress }, {
+        runStreaming: runStreaming && !isTerminalRunStatus({ status: message.runStatus }),
+    });
     const footerUsage = showUsageLine ? usage.footer : undefined;
+    const lastFinishedReply = !runInProgress && !usage.footer ? usage.replies.findLastIndex(value => value !== undefined) : -1;
     const renderToolCard = (row) => (_jsx(ToolCard, { use: row.use, result: row.result, runStreaming: runStreaming, runSucceeded: runSucceeded, ...(projectFileNames !== undefined ? { projectFileNames } : {}), ...(onRequestOpenFile !== undefined ? { onRequestOpenFile } : {}) }, row.id));
-    // One turn's cards: a fold-up line when collapsed, the plain card list otherwise.
-    const renderTools = (rows, key) => (toolCallDisplay === 'collapsed'
-        ? _jsx(ToolCallGroup, { rows: rows, renderRow: renderToolCard }, key)
+    // Hidden mode reuses the same disclosure and card renderer for unrecovered failures.
+    const renderTools = (rows, key) => (toolCallDisplay !== 'show'
+        ? _jsx(ToolCallGroup, { rows: rows, renderRow: renderToolCard, failureOnly: toolCallDisplay === 'hidden' }, key)
         : _jsx("div", { className: "jini-message-tools", children: rows.map(renderToolCard) }, key));
-    const flatToolRows = toolRowsForDisplay({ rows: timeline.rows, mode: toolCallDisplay });
+    const flatTools = flatToolGroups({ message, rows: timeline.rows, registry, displayBlocks }, { toolCallDisplay });
     const renderExtGroup = (group) => {
         const renderer = registry.get({ name: group.name });
         if (!renderer && group.name === MID_RUN_USER_MESSAGE_EXT_EVENT_NAME)
@@ -239,7 +255,8 @@ function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageL
         }
         if (block.kind === 'reply-end') {
             const reply = usage.replies[block.index];
-            return reply && showUsageLine ? _jsx(UsageSummary, { usage: reply, showTotal: showUsageTotal }, block.key) : null;
+            // A trailing input may have no reply: its predecessor's usage belongs above that input.
+            return reply && showUsageLine ? _jsx(UsageSummary, { usage: reply, showTotal: showUsageTotal, ...(block.index === lastFinishedReply ? { message } : {}) }, block.key) : null;
         }
         if (block.kind === 'tools')
             return renderTools(block.rows, block.key);
@@ -254,7 +271,7 @@ function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageL
             ? 'jini-message jini-message-assistant jini-message-assistant--usage-actions'
             : 'jini-message jini-message-assistant', "data-message-id": message.id, "data-run-status": message.runStatus, "data-agent-element": `chat-message-${message.id}`, "data-agent-role": "region", "data-agent-label": "A reply from the assistant", children: [message.agentName ? _jsx("div", { className: "jini-message-agent", children: message.agentName }) : null, blocks
                 ? blocks.map(renderBlock)
-                : (_jsxs(_Fragment, { children: [renderTextSegments(visibleContent, 'text'), flatToolRows.length > 0 ? renderTools(flatToolRows) : null, extGroups.length > 0 ? _jsx("div", { className: "jini-message-ext-events", children: extGroups.map(renderExtGroup) }) : null] })), _jsx(AssistantMessageFooter, { message, usageEvent: footerUsage, showUsageTotal, terminalNotice, pending, runInProgress, runStreaming, visibleContent, isAnsweredCard: answeredCards.isAnsweredCard })] }));
+                : (_jsxs(_Fragment, { children: [renderTextSegments(visibleContent, 'text'), flatTools.map((group) => renderTools(group.rows, group.key)), extGroups.length > 0 ? _jsx("div", { className: "jini-message-ext-events", children: extGroups.map(renderExtGroup) }) : null] })), _jsx(AssistantMessageFooter, { message, usageEvent: footerUsage, showUsageTotal, terminalNotice, pending, runInProgress, runStreaming, visibleContent, isAnsweredCard: answeredCards.isAnsweredCard })] }));
 }
 /**
  * The live "what is it doing" line under a running reply (see `core/run-activity.ts`). Replaces the

package/dist/react/components/MessageRow.usage.d.ts

@@ -1,5 +1,12 @@
 import type { ChatMessage } from '../../core/messages.js';
 import { type ChatUsageSummary } from '../../core/turn-usage.js';
+/** A run's terminal state wins over its last model response; interrupted usage never claims success.
+ * Missing lifecycle data keeps the legacy completed label. O(n) in terminal notice events. */
+export declare function usageEndLabel({ usage, message, awaitingAnswer }: {
+    usage: ChatUsageSummary;
+    message?: ChatMessage;
+    awaitingAnswer?: boolean;
+}, _options?: {}): string;
 /** A standalone row has one turn; MessageList supplies the full conversation projection. */
 export declare function useMessageUsage({ message, summary }: {
     message: ChatMessage;
@@ -41,8 +48,9 @@ export declare function usageLineMeetsActions({ footer, terminalNotice, pending,
  * the current turn's cost is unknown. `showTotal: false` turns the total off. */
 export declare function useUsageSummary({ usage }: {
     usage: ChatUsageSummary;
-}, { showTotal }?: {
+}, { showTotal, label }?: {
     showTotal?: boolean;
+    label?: string;
 }): {
     text: string;
     title: string | undefined;

package/dist/react/components/MessageRow.usage.js

@@ -1,7 +1,24 @@
 import { useMemo } from 'react';
+import { terminalMessageNotice } from '../../core/durable-projection.js';
 import { conversationUsage } from '../../core/turn-usage.js';
 import { formatUsageCost } from '../../core/usage-format.js';
-import { useT } from '../hooks/context.js';
+import { useI18n } from '../hooks/context.js';
+/** A run's terminal state wins over its last model response; interrupted usage never claims success.
+ * Missing lifecycle data keeps the legacy completed label. O(n) in terminal notice events. */
+export function usageEndLabel({ usage, message, awaitingAnswer = false }, _options = {}) {
+    const status = message?.runStatus;
+    if (status === 'failed')
+        return 'Failed';
+    if (status === 'canceled') {
+        return /stopped/i.test(terminalMessageNotice({ message: message }) ?? '') ? 'Stopped' : 'Canceled';
+    }
+    if (awaitingAnswer)
+        return 'Waiting for your answer';
+    const reason = usage.stopReason ?? '';
+    if (/error|fail/i.test(reason))
+        return 'Failed';
+    return /abort|interrupt|cancel|max_tokens|max_tool_turns|length|tool_use/i.test(reason) ? 'Interrupted' : 'Done';
+}
 /** A standalone row has one turn; MessageList supplies the full conversation projection. */
 export function useMessageUsage({ message, summary }, _optional = {}) {
     return useMemo(() => summary ?? conversationUsage({ messages: [message] }).get(message.id), [message, summary]);
@@ -31,13 +48,13 @@ export function usageLineMeetsActions({ footer, terminalNotice, pending, runInPr
  * Each line carries the chat's running total as of that reply, "Done · 16s · $0.39 · total $3.95" (owner,
  * 2026-10-10: keep the total, always shown, even on the first turn). Known totals remain visible when
  * the current turn's cost is unknown. `showTotal: false` turns the total off. */
-export function useUsageSummary({ usage }, { showTotal = true } = {}) {
-    const t = useT();
+export function useUsageSummary({ usage }, { showTotal = true, label = 'Done' } = {}) {
+    const { t, locale } = useI18n();
     const parts = [usageDuration({ durationMs: usage.durationMs }), usageCost({ usage }, { showTotal })]
         .filter((part) => part !== undefined);
     const text = parts.join(' · ');
-    const title = usage.outputTokens === undefined ? undefined : t('{n} out', { n: usage.outputTokens });
-    return { text, title, ariaLabel: title === undefined ? undefined : `${t('Done')} · ${text} · ${title}` };
+    const title = usage.outputTokens === undefined ? undefined : t('{n} output tokens', { n: usage.outputTokens.toLocaleString(locale) });
+    return { text, title, ariaLabel: title === undefined ? undefined : `${t(label)} · ${text} · ${title}` };
 }
 function usageDuration({ durationMs }, _options = {}) {
     if (durationMs === undefined)

package/dist/react/components/ToolCallGroup.d.ts

@@ -2,11 +2,12 @@ import type { ReactNode } from 'react';
 import type { ToolDisplayRow } from '../tool-call-display.js';
 /**
  * One turn's tool cards folded into a single line ("Used 3 tools ▸") that opens on click — the
- * `toolCallDisplay: 'collapsed'` layout. Props in, JSX out; state and copy are in
- * `useToolCallGroup`.
+ * `toolCallDisplay: 'collapsed'` layout, or the compact failure notice in 'hidden'. The disclosure
+ * state lives in `useToolCallGroup`; copy uses the host's translator.
  */
-export declare function ToolCallGroup<Row extends ToolDisplayRow>({ rows, renderRow }: {
+export declare function ToolCallGroup<Row extends ToolDisplayRow>({ rows, renderRow, failureOnly }: {
     rows: readonly Row[];
+    failureOnly?: boolean;
     renderRow: (row: Row) => ReactNode;
 }): import("react").JSX.Element;
 //# sourceMappingURL=ToolCallGroup.d.ts.map

package/dist/react/components/ToolCallGroup.hooks.d.ts

@@ -3,8 +3,10 @@ export interface ToolCallGroupState {
     /** Whether the turn's tool cards are showing under the line. Starts closed. */
     open: boolean;
     toggle: () => void;
-    /** "Used 3 tools", "Used 3 tools · 1 failed", or "Running Bash…" while a tool runs. */
+    /** "Used 3 tools", or "Running Bash…" while a tool runs. */
     label: string;
+    /** The failure suffix, styled independently of the tool count. */
+    failureLabel: string | undefined;
     running: boolean;
     failed: boolean;
 }

package/dist/react/components/ToolCallGroup.hooks.js

@@ -15,7 +15,8 @@ export function useToolCallGroup({ rows }, _optional = {}) {
     return {
         open,
         toggle,
-        label: toolGroupLabel({ summary, t }),
+        label: toolGroupLabel({ summary: summary.kind === 'done' ? { ...summary, failed: 0 } : summary, t }),
+        failureLabel: summary.kind === 'done' && summary.failed > 0 ? t('{count} failed', { count: summary.failed }) : undefined,
         running: summary.kind === 'running',
         failed: summary.kind === 'done' && summary.failed > 0,
     };

package/dist/react/components/ToolCallGroup.js

@@ -1,13 +1,15 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useToolCallGroup } from './ToolCallGroup.hooks.js';
+import { useT } from '../hooks/context.js';
 import { Icon } from './Icon.js';
 /**
  * One turn's tool cards folded into a single line ("Used 3 tools ▸") that opens on click — the
- * `toolCallDisplay: 'collapsed'` layout. Props in, JSX out; state and copy are in
- * `useToolCallGroup`.
+ * `toolCallDisplay: 'collapsed'` layout, or the compact failure notice in 'hidden'. The disclosure
+ * state lives in `useToolCallGroup`; copy uses the host's translator.
  */
-export function ToolCallGroup({ rows, renderRow }) {
+export function ToolCallGroup({ rows, renderRow, failureOnly = false }) {
     const group = useToolCallGroup({ rows });
-    return (_jsxs("div", { className: "jini-tool-group", "data-failed": group.failed ? 'true' : undefined, children: [_jsxs("button", { type: "button", className: "jini-tool-group__toggle", "aria-expanded": group.open, onClick: group.toggle, children: [_jsx("span", { className: `jini-tool-group__label${group.running ? ' shimmer-text' : ''}`, children: group.label }), _jsx(Icon, { name: group.open ? 'chevron-down' : 'chevron-right', size: 12 })] }), group.open ? _jsx("div", { className: "jini-message-tools", children: rows.map(renderRow) }) : null] }));
+    const t = useT();
+    return (_jsxs("div", { className: "jini-tool-group", "data-failed": group.failed ? 'true' : undefined, children: [failureOnly ? _jsxs("span", { className: "jini-tool-group__label", children: [t('A step failed'), " "] }) : null, _jsxs("button", { type: "button", className: "jini-tool-group__toggle", "aria-expanded": group.open, onClick: group.toggle, children: [_jsx("span", { className: `jini-tool-group__label${group.running ? ' shimmer-text' : ''}`, children: failureOnly ? t('Show') : group.label }), !failureOnly && group.failureLabel ? _jsxs("span", { className: "jini-tool-group__failed", children: [" \u00B7 ", group.failureLabel] }) : null, _jsx(Icon, { name: group.open ? 'chevron-down' : 'chevron-right', size: 12 })] }), group.open ? _jsx("div", { className: "jini-message-tools", children: rows.map(renderRow) }) : null] }));
 }
 //# sourceMappingURL=ToolCallGroup.js.map

package/dist/react/features/chat-pane/create-mid-run-message-poster.d.ts

@@ -15,11 +15,11 @@
  *
  * ## Why it resolves an outcome instead of throwing
  *
- * The pane acts differently on each outcome and must never drop the text: `'unsupported'` stops the
- * run for text-only turns, or queues an attachment turn intact; `'not-running'` queues behind the
+ * The pane acts differently on each outcome and must never drop the text: `'unsupported'` queues
+ * the whole turn; `'not-running'` queues behind the
  * ending run; `'failed'` retains the draft for retry. A 404 means
  * the daemon never saw this run (a host-side run such as a BYOK API turn), so it is `'unsupported'`
- * too: no live process to steer, but an interrupt still works.
+ * too: no live process to steer. Accepted inputs retain their fallback copy until consumed.
  */
 import { type UserTextRedactionOptions } from '../../../core/user-text-redaction.js';
 import type { DeliverMidRunMessage } from './types.js';

package/dist/react/features/chat-pane/create-mid-run-message-poster.js

@@ -15,11 +15,11 @@
  *
  * ## Why it resolves an outcome instead of throwing
  *
- * The pane acts differently on each outcome and must never drop the text: `'unsupported'` stops the
- * run for text-only turns, or queues an attachment turn intact; `'not-running'` queues behind the
+ * The pane acts differently on each outcome and must never drop the text: `'unsupported'` queues
+ * the whole turn; `'not-running'` queues behind the
  * ending run; `'failed'` retains the draft for retry. A 404 means
  * the daemon never saw this run (a host-side run such as a BYOK API turn), so it is `'unsupported'`
- * too: no live process to steer, but an interrupt still works.
+ * too: no live process to steer. Accepted inputs retain their fallback copy until consumed.
  */
 import { redactUserText } from '../../../core/user-text-redaction.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -31,8 +31,11 @@ async function conflictDelivery(response) {
 }
 /** Maps the route's response onto an outcome. Only 202 is a delivery. */
 async function deliveryFor(response) {
-    if (response.status === 202)
-        return 'delivered';
+    if (response.status === 202) {
+        const body = await response.json().catch(() => null);
+        const id = body?.id;
+        return typeof id === 'string' && id.length > 0 ? { delivery: 'delivered', id } : 'delivered';
+    }
     if (response.status === 409)
         return conflictDelivery(response);
     return response.status === 404 ? 'unsupported' : 'failed';

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.js

@@ -8,6 +8,35 @@ import { readCachedAttachmentBatchId, writeCachedAttachmentBatchId, } from '../.
 import { useComposer } from '../../../hooks/useComposer.js';
 import { useConversation, } from '../../../hooks/useConversation.js';
 import { useChatPaneWorkingDirectory, } from './useChatPaneWorkingDirectory.hooks.js';
+/** Filter during render so a consumed receipt followed by end in the same batch cannot flush twice.
+ * Legacy host receipts can replace optimistic IDs; the accepted-input owner retains their aliases.
+ * @complexity O(e + q) time and space for receipt events and locally queued inputs.
+ */
+function unconsumedQueuedInputs({ inputs, messages }) {
+    const consumed = new Set();
+    for (const message of messages) {
+        for (const event of projectAcceptedInputEvents({ events: message.events ?? [] })) {
+            const receipt = acceptedInputEvent({ event });
+            if (receipt?.data.deliveryState !== 'consumed')
+                continue;
+            for (const input of [receipt.data, ...(receipt.data.inputs ?? [])]) {
+                consumed.add(input.id);
+                for (const alias of input.aliases ?? [])
+                    consumed.add(alias);
+            }
+        }
+    }
+    return inputs.filter(input => !consumed.has(input.liveMessageId ?? input.id));
+}
+/** The conversation copies run events onto its messages one effect after streaming stops, so a
+ * consumed receipt can still be missing from the transcript when the send blocker clears. A
+ * live-accepted copy therefore waits until the run's own message reaches a terminal status. */
+function awaitingRunReceipts({ inputs, messages }) {
+    if (!inputs.some(input => input.liveMessageId !== undefined))
+        return false;
+    const status = messages.at(-1)?.runStatus;
+    return status === 'queued' || status === 'running';
+}
 /** The stand-in prompt for a turn that carries only attachments. */
 const ATTACHMENTS_ONLY_PROMPT = 'Review the attached file(s).';
 /**
@@ -149,11 +178,7 @@ export function useChatPane(options) {
     const [activeUploadCount, setActiveUploadCount] = useState(0);
     const [attachmentError, setAttachmentError] = useState(null);
     // MOVE: Keep the signal with each sanitized input; re-redaction cannot detect the original paste.
-    const [queuedInputs, setQueuedInputs] = useState([]);
-    const queuedTurn = useMemo(() => queuedInputs.reduce((queued, input) => appendQueuedTurn({
-        queued, next: { text: input.text, secretRedacted: input.secretRedaction?.secretRedacted ?? false,
-            count: input.secretRedaction?.count ?? 0 },
-    }), null), [queuedInputs]);
+    const [storedQueuedInputs, setQueuedInputs] = useState([]);
     // MOVE: Uploads belong to the input that submitted them, even if a later message is queued first.
     const queuedUploadOwnersRef = useRef(new Map());
     // A send during upload resumes once pixels arrive; a rejected live delivery waits for run end.
@@ -221,6 +246,16 @@ export function useChatPane(options) {
             validateAttachments: options.validateAttachments,
         } }));
     const activity = resolveChatPaneActivity(selectedAgent, conversation);
+    const queuedInputs = useMemo(() => unconsumedQueuedInputs({ inputs: storedQueuedInputs, messages: conversation.messages }), [storedQueuedInputs, conversation.messages]);
+    const queuedTurn = useMemo(() => queuedInputs.reduce((queued, input) => appendQueuedTurn({
+        queued, next: { text: input.text, secretRedacted: input.secretRedaction?.secretRedacted ?? false,
+            count: input.secretRedaction?.count ?? 0 },
+    }), null), [queuedInputs]);
+    // Release consumed text/files locally as well as hiding them; next-turn fallback uses this same projection.
+    useEffect(() => {
+        if (queuedInputs.length !== storedQueuedInputs.length)
+            setQueuedInputs(queuedInputs);
+    }, [queuedInputs, storedQueuedInputs.length]);
     useEffect(() => {
         options.onActivityChange?.(activity);
     }, [activity, options.onActivityChange]);
@@ -363,7 +398,7 @@ export function useChatPane(options) {
         }
     }, [composer, options.conversationId, options.uploadAttachments]);
     /** Acceptance is the only writer of local recall and optimistic in-run bubbles. */
-    const recordAcceptedInput = useCallback(({ inputs, bubble }, _options = {}) => {
+    const recordAcceptedInput = useCallback(({ inputs, bubble }, { receipt = 'optimistic' } = {}) => {
         composer.history?.record({ inputs });
         submittedComposerRef.current = composer;
         if (bubble === undefined)
@@ -372,8 +407,9 @@ export function useChatPane(options) {
             const last = messages.at(-1);
             if (last?.role !== 'assistant')
                 return messages;
-            const event = acceptedInputUserEvent({ input: { id: inputs[0].id, text: bubble.text },
-                inputs, ...bubble });
+            const event = acceptedInputUserEvent({ input: { id: inputs[0].id, text: bubble.text,
+                    ...(inputs[0].deliveryState ? { deliveryState: inputs[0].deliveryState } : {}) },
+                inputs, ...bubble }, { receipt });
             return [...messages.slice(0, -1), { ...last,
                     events: projectAcceptedInputEvents({ events: [...(last.events ?? []), event] }) }];
         });
@@ -495,24 +531,37 @@ export function useChatPane(options) {
         if (inputs === undefined && latestDraftRef.current === submittedDraft)
             latestComposerRef.current.setDraft('');
     }, []);
+    /** HTTP acceptance retains fallback ownership; only an actual consumption receipt removes it. */
+    const retainAcceptedMidRunInput = useCallback(({ outcome, inputs, turn, attachments, afterInputId }, _options = {}) => {
+        const accepted = inputs ?? [{ id: createChatLocalId({}), text: turn.text, attachments,
+                ...(turn.secretRedacted ? { secretRedaction: { secretRedacted: true, count: turn.count } } : {}) }];
+        const id = typeof outcome === 'object' ? outcome.id : accepted[0].id;
+        // A known HTTP id is already authoritative. Do not let equal text reconcile an unrelated
+        // wire receipt into this bubble; legacy hosts alone still need optimistic reconciliation.
+        const retained = accepted.map((input, index) => ({ ...input,
+            ...(index === 0 ? { id, aliases: [...(input.aliases ?? []), input.id] } : {}),
+            liveMessageId: id, deliveryState: 'queued',
+        }));
+        queuedConversationIdRef.current = options.conversationId;
+        setQueuedInputs(queued => [...queued, ...retained]);
+        recordAcceptedInput({ inputs: retained,
+            bubble: { text: turn.text, ...(afterInputId === undefined ? {} : { afterInputId }) } }, typeof outcome === 'object' ? { receipt: 'accepted' } : {});
+    }, [options.conversationId, recordAcceptedInput]);
     const finishMidRunSend = useCallback(({ outcome, inputs, turn, attachments, afterInputId, submittedDraft }, _options = {}) => {
         if (outcome === 'failed') {
             restoreQueuedDraft({ inputs, text: turn.text, attachments });
             setTypedAnswerNotice('failed');
             return;
         }
-        if (outcome === 'delivered') {
-            recordAcceptedInput({ inputs: inputs ?? [{ id: createChatLocalId({}), text: turn.text }],
-                bubble: { text: turn.text, ...(afterInputId === undefined ? {} : { afterInputId }) } });
+        if (outcome === 'delivered' || typeof outcome === 'object') {
+            retainAcceptedMidRunInput({ outcome, inputs, turn, attachments, afterInputId });
             clearDeliveredDraft({ inputs, submittedDraft });
             consumeDeliveredAttachments({ attachments });
             return;
         }
         enqueueTurn({ turn, attachments, ...(inputs === undefined ? {} : { inputs }) });
         clearDeliveredDraft({ inputs, submittedDraft });
-        if (outcome === 'unsupported' && attachments.length === 0)
-            conversation.cancel();
-    }, [conversation.cancel, enqueueTurn, recordAcceptedInput, clearDeliveredDraft, consumeDeliveredAttachments, restoreQueuedDraft]);
+    }, [enqueueTurn, retainAcceptedMidRunInput, clearDeliveredDraft, consumeDeliveredAttachments, restoreQueuedDraft]);
     // A delivered steer belongs to the existing run; unsupported turns use the same accepted queue.
     // A failed delivery keeps the working draft so retry cannot silently become another run.
     const sendIntoRunningTurn = useCallback(async ({ deliver, runId, turn, inputs, attachments = composer.attachments }, _options = {}) => {
@@ -544,7 +593,7 @@ export function useChatPane(options) {
         if (uploadPending)
             queuedForUploadRef.current = queuedTurn === null || queuedForUploadRef.current;
         // MOVE: The existing queue owns its files; a later steer must join it to preserve send order.
-        const target = uploadPending || queuedTurn !== null ? null : findMidRunTarget({
+        const target = uploadPending || queuedInputs.some(input => input.liveMessageId === undefined) ? null : findMidRunTarget({
             deliver: options.deliverMidRunMessage,
             blocker: sendBlocker,
             attachmentCount: composer.attachments.length,
@@ -565,6 +614,7 @@ export function useChatPane(options) {
         enqueueTurn,
         options.deliverMidRunMessage,
         queuedTurn,
+        queuedInputs,
         sendBlocker,
         sendIntoRunningTurn,
         sendPrompt,
@@ -659,7 +709,7 @@ export function useChatPane(options) {
             deliver: options.deliverMidRunMessage,
             blocker: sendBlocker, attachmentCount: queuedInputs.flatMap(input => input.attachments).length, messages: conversation.messages,
         }) : null;
-        if (sendBlocker !== null && target === null)
+        if (target === null && (sendBlocker !== null || awaitingRunReceipts({ inputs: queuedInputs, messages: conversation.messages })))
             return;
         queuedForUploadRef.current = false;
         const inputs = queuedInputs;
@@ -712,7 +762,9 @@ export function useChatPane(options) {
         send,
         sendPrompt,
         queuedPrompt: queuedTurn?.text ?? null,
-        queuedMessages: queuedInputs,
+        // Accepted live messages already have queued bubbles in the transcript. Their private fallback
+        // copy must not create a second composer row whose Cancel button cannot revoke daemon input.
+        queuedMessages: queuedInputs.filter(input => input.liveMessageId === undefined),
         cancelQueuedMessage,
         cancelQueued,
         typedAnswerNotice,

package/dist/react/features/chat-pane/types.d.ts

@@ -176,11 +176,16 @@ export type DeliverTypedAnswer = ((input: {
 };
 /**
  * What happened to a message sent while a run streams (see {@link ChatPaneProps.deliverMidRunMessage}):
- * `'delivered'` — the live agent took it into the running turn; `'unsupported'` — this agent cannot
+ * `{delivery:'delivered', id}` — accepted by the live agent; keep the local copy until an id-matched
+ * consumed event. Legacy hosts may still return `'delivered'`; their receipts reconcile optimistic ids.
+ * `'unsupported'` — this agent cannot
  * take input mid-run (it reads one prompt per turn); `'not-running'` — the run has no live process
  * any more (it is ending); `'failed'` — the host could not tell (network error, unexpected status).
  */
-export type MidRunMessageDelivery = 'delivered' | 'unsupported' | 'not-running' | 'failed';
+export type MidRunMessageDelivery = 'delivered' | 'unsupported' | 'not-running' | 'failed' | {
+    readonly delivery: 'delivered';
+    readonly id: string;
+};
 /** Delivers a complete turn to the live agent; unsupported attachments must reject the whole turn. */
 export type DeliverMidRunMessage = (input: {
     runId: string;
@@ -312,7 +317,8 @@ export interface ChatPaneProps extends UserTextRedactionOptions {
     /**
      * Transcript display choices (a host's chat settings, 2026-10-11), passed straight to
      * `MessageList`: how tool calls show (`'show'` default, `'collapsed'` one line per turn, `'hidden'`
-     * all but failed ones — see `tool-call-display.ts`), whether the "Done · time · cost" lines show
+     * hides recovered calls and folds unrecovered failures — see `tool-call-display.ts`), whether the
+     * "Done · time · cost" lines show
      * (default `true`), and whether the model's reasoning shows (default `false`).
      */
     toolCallDisplay?: ToolCallDisplay;