@jini-ai/chat 0.6.6 → 0.6.10

package/dist/react/components/MessageList.js

@@ -10,25 +10,49 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * scroll-anchoring state lives in `useMessageListAutoScroll`
  * (`MessageList.hooks.ts`); see that file for why it is presentational.
  */
-import { memo } from 'react';
+import { memo, useMemo } from 'react';
+import { projectAcceptedInputMessages } from '../../core/accepted-input.js';
 import { isTerminalRunStatus } from '../../core/index.js';
 import { useT } from '../hooks/context.js';
 import { useMessageListAutoScroll, useConversationUsage } from './MessageList.hooks.js';
 import { MessageRow } from './MessageRow.js';
+import { SentAttachmentButton } from './SentAttachment.js';
+import { AttachmentPreviewModal } from './AttachmentPreviewModal.js';
+import { useAttachmentGallery } from './AttachmentGallery.hooks.js';
+function renderMessageRow({ message, isLast, isStreaming, usageSummary }, { activeQuestionFormMessageId, questionFormSubmittedAnswersByMessageId, onQuestionFormSubmit, ...rowProps } = {}) {
+    const runStreaming = isLast && isStreaming && !isTerminalRunStatus({ status: message.runStatus });
+    return (_jsx(MessageRow, { message: message, ...rowProps, ...(usageSummary === undefined ? {} : { usageSummary }), runStreaming: runStreaming, runSucceeded: message.runStatus === 'succeeded', questionFormInteractive: message.id === activeQuestionFormMessageId, ...(questionFormSubmittedAnswersByMessageId?.[message.id] !== undefined ? { questionFormSubmittedAnswers: questionFormSubmittedAnswersByMessageId[message.id] } : {}), ...(onQuestionFormSubmit !== undefined ? { onQuestionFormSubmit: (text, answers) => onQuestionFormSubmit(message.id, text, answers) } : {}) }, message.id));
+}
 /**
  * Memoized: the pane re-renders on every composer keystroke, and re-rendering a long transcript
  * (hundreds of tool rows, MCP-UI cards, markdown) per key made typing lag (owner report
- * 2026-10-08). Callers must pass stable props — `ChatPane` memoizes `pendingPrompt` and
+ * 2026-10-08). Callers must pass stable props — `ChatPane` memoizes `pendingPrompts` and
  * `projectFileNames` for exactly this.
  */
-export const MessageList = memo(function MessageList({ messages, isStreaming = false, scrollIntent = false, onScrolled, activeQuestionFormMessageId = null, questionFormSubmittedAnswersByMessageId, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, renderAttachment, showUsageTotal = true, showUsageLine = true, toolCallDisplay = 'show', showThinking = false, pendingPrompt = null, }) {
-    const t = useT();
+export const MessageList = memo(function MessageList({ messages: sourceMessages, isStreaming = false, scrollIntent = false, onScrolled, pendingPrompt, pendingPrompts, ...rowProps }) {
+    const messages = useMemo(() => projectAcceptedInputMessages({ messages: sourceMessages }), [sourceMessages]);
     const usageByMessage = useConversationUsage({ messages });
-    const { containerRef, onScroll } = useMessageListAutoScroll({ messages, scrollIntent }, onScrolled !== undefined ? { onScrolled } : {});
-    return (_jsxs("div", { className: "jini-message-list", ref: containerRef, onScroll: onScroll, "data-agent-element": "chat-transcript", "data-agent-role": "list", "data-agent-label": "The conversation transcript, oldest message first", children: [messages.map((message) => {
-                const isLast = message.id === messages[messages.length - 1]?.id;
-                const runStreaming = isLast && isStreaming && !isTerminalRunStatus({ status: message.runStatus });
-                return (_jsx(MessageRow, { message: message, ...(usageByMessage.has(message.id) ? { usageSummary: usageByMessage.get(message.id) } : {}), showUsageTotal: showUsageTotal, showUsageLine: showUsageLine, toolCallDisplay: toolCallDisplay, showThinking: showThinking, runStreaming: runStreaming, runSucceeded: message.runStatus === 'succeeded', questionFormInteractive: message.id === activeQuestionFormMessageId, ...(questionFormSubmittedAnswersByMessageId?.[message.id] !== undefined ? { questionFormSubmittedAnswers: questionFormSubmittedAnswersByMessageId[message.id] } : {}), ...(onQuestionFormSubmit !== undefined ? { onQuestionFormSubmit: (text, answers) => onQuestionFormSubmit(message.id, text, answers) } : {}), ...(projectFileNames !== undefined ? { projectFileNames } : {}), ...(onRequestOpenFile !== undefined ? { onRequestOpenFile } : {}), ...(renderAttachment !== undefined ? { renderAttachment } : {}) }, message.id));
-            }), pendingPrompt ? (_jsxs("div", { className: "jini-chat-pane__queued", role: "status", "aria-label": t('Message queued — not yet sent, will send once the current run finishes'), "data-testid": "chat-pane-queued", "data-agent-element": "chat-message-pending", "data-agent-role": "region", "data-agent-label": "A message queued to send once the current run finishes", children: [_jsx("div", { className: "jini-chat-pane__queued-text", children: pendingPrompt.text }), _jsx("div", { className: "jini-chat-pane__queued-actions", children: _jsx("button", { type: "button", className: "jini-chat-pane__queued-cancel", onClick: pendingPrompt.onCancel, title: t('Cancel queued message'), children: t('Cancel') }) })] })) : null] }));
+    const { containerRef, onScroll, awayFromLatest, jumpToLatest } = useMessageListAutoScroll({ messages, scrollIntent }, onScrolled !== undefined ? { onScrolled } : {});
+    return (_jsxs("div", { className: "jini-message-list", ref: containerRef, onScroll: onScroll, "data-agent-element": "chat-transcript", "data-agent-role": "list", "data-agent-label": "The conversation transcript, oldest message first", children: [messages.map((message) => renderMessageRow({
+                message,
+                isLast: message.id === messages[messages.length - 1]?.id,
+                isStreaming,
+                usageSummary: usageByMessage.get(message.id),
+            }, rowProps)), (pendingPrompts ?? (pendingPrompt ? [pendingPrompt] : [])).map((prompt, index) => (_jsx(QueuedMessage, { prompt: prompt, renderAttachment: rowProps.renderAttachment }, prompt.id ?? index))), awayFromLatest && _jsx(JumpToLatest, { onJump: jumpToLatest })] }));
 });
+/**
+ * Sticky, zero-height last child of the scroll container, so the button floats centred just above
+ * the composer without a wrapper element changing the pane's flex layout.
+ */
+function JumpToLatest({ onJump }) {
+    const t = useT();
+    return (_jsx("div", { className: "jini-message-list__jump", children: _jsxs("button", { type: "button", className: "jini-message-list__jump-btn", onClick: onJump, children: [_jsxs("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", children: [_jsx("path", { d: "M12 5v14" }), _jsx("path", { d: "m19 12-7 7-7-7" })] }), t('Jump to latest')] }) }));
+}
+/** One cancelable queue receipt; attachment rendering reuses the sent-message preview owner. */
+function QueuedMessage({ prompt, renderAttachment }) {
+    const t = useT();
+    const attachments = prompt.attachments ?? [];
+    const gallery = useAttachmentGallery({ attachments });
+    return (_jsxs("div", { className: "jini-chat-pane__queued", role: "status", "aria-label": t('Message queued — not yet sent, will send once the current run finishes'), "data-testid": "chat-pane-queued", "data-agent-element": "chat-message-pending", "data-agent-role": "region", "data-agent-label": "A message queued to send once the current run finishes", children: [_jsx("div", { children: t('Queued — sends when this reply finishes') }), _jsx("div", { className: "jini-chat-pane__queued-text", children: prompt.text }), attachments.length > 0 && _jsx("div", { className: "jini-message-attachments", children: attachments.map(attachment => _jsx(SentAttachmentButton, { attachment: attachment, onOpen: gallery.open, renderAttachment: renderAttachment }, attachment.path)) }), gallery.opened !== null && _jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation }), _jsx("div", { className: "jini-chat-pane__queued-actions", children: _jsx("button", { type: "button", className: "jini-chat-pane__queued-cancel", onClick: () => prompt.onCancel(), title: t('Cancel queued message'), children: t('Cancel') }) })] }));
+}
 //# sourceMappingURL=MessageList.js.map

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

@@ -1,4 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+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';
 /**
@@ -51,8 +53,8 @@ import { usageLayout, usageLineMeetsActions, useMessageUsage, useUsageSummary }
  * not appear until the whole message is done, not merely until its current
  * chunk stopped arriving.
  */
-import React, { memo } from 'react';
-import { isAwaitingAnswer, isTerminalRunStatus, splitOnQuestionForms, stripArtifact } from '../../core/index.js';
+import React, { memo, useMemo } from 'react';
+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';
@@ -116,16 +118,25 @@ function UsageSummary({ usage, showTotal }) {
         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] }));
 }
-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 }) {
@@ -164,50 +175,66 @@ const NO_ATTACHMENTS = [];
  * re-renders per composer keystroke) only re-renders rows whose props actually changed. Messages
  * are replaced, never mutated, so identity is a sound change signal.
  */
-export const MessageRow = memo(function MessageRow({ message, usageSummary, showUsageTotal = true, showUsageLine = true, toolCallDisplay = 'show', showThinking = false, runStreaming = false, runSucceeded = false, questionFormInteractive = false, questionFormSubmittedAnswers, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, renderAttachment, }) {
+export const MessageRow = memo(function MessageRow({ showUsageTotal = true, showUsageLine = true, toolCallDisplay = 'show', showThinking = false, runStreaming = false, runSucceeded = false, questionFormInteractive = false, ...props }) {
+    const message = useMemo(() => props.message.events === undefined ? props.message : {
+        ...props.message, events: projectAcceptedInputEvents({ events: props.message.events }),
+    }, [props.message]);
+    if (message.role === 'user')
+        return _jsx(UserMessageRow, { ...props, message: message });
+    return _jsx(AssistantMessageRow, { ...props, message: message, showUsageTotal, showUsageLine, toolCallDisplay, showThinking, runStreaming, runSucceeded, questionFormInteractive });
+});
+function UserMessageRow({ message, renderAttachment }) {
     const t = useT();
-    const registry = useExtEventRendererRegistry();
-    const messageUsage = useMessageUsage({ message, ...(usageSummary === undefined ? {} : { summary: usageSummary }) });
-    const timeline = useToolTimeline({ events: message.events }, { runStreaming, runSucceeded });
-    const extGroups = useExtEventGroups({ events: message.events }, { slotOf: (name, data) => registry.slot({ name, data }) });
-    const answeredCards = useAnsweredCards({ slotOf: registry.slot });
     // Which attachment chip (if any) this row's preview modal is open for. Row-local, not
     // module-level: two attachments in the same message can never be "open" at once, but two
     // different messages opening their own attachments independently is fine and expected.
     // Previous/next steps through this message's images only.
     const gallery = useAttachmentGallery({ attachments: message.attachments ?? NO_ATTACHMENTS });
-    if (message.role === 'user') {
-        return (_jsxs("div", { className: "jini-message jini-message-user", "data-message-id": message.id, "data-agent-element": `chat-message-${message.id}`, "data-agent-role": "region", "data-agent-label": "A message from the user", children: [message.attachments && message.attachments.length > 0 ? (_jsx("div", { className: "jini-message-attachments", children: message.attachments.map((a) => (_jsx(SentAttachmentButton, { attachment: a, onOpen: gallery.open, renderAttachment: renderAttachment }, a.path))) })) : null, _jsx("div", { className: "jini-message-content", children: message.content }), _jsx("div", { className: "jini-message-actions jini-message-actions--user", children: _jsx(CopyMessageButton, { text: message.content, label: t('Copy message') }) }), gallery.opened ? (_jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation })) : null] }));
-    }
+    return (_jsxs("div", { className: "jini-message jini-message-user", "data-message-id": message.id, "data-agent-element": `chat-message-${message.id}`, "data-agent-role": "region", "data-agent-label": "A message from the user", children: [message.attachments && message.attachments.length > 0 ? (_jsx("div", { className: "jini-message-attachments", children: message.attachments.map((a) => (_jsx(SentAttachmentButton, { attachment: a, onOpen: gallery.open, renderAttachment: renderAttachment }, a.path))) })) : null, _jsx("div", { className: "jini-message-content", children: message.content }), _jsx("div", { className: "jini-message-actions jini-message-actions--user", children: _jsx(CopyMessageButton, { text: message.content, label: t('Copy message') }) }), gallery.opened ? (_jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation })) : null] }));
+}
+function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageLine, toolCallDisplay, showThinking, runStreaming, runSucceeded, questionFormInteractive, questionFormSubmittedAnswers, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, }) {
+    const registry = useExtEventRendererRegistry();
+    const messageUsage = useMessageUsage({ message, ...(usageSummary === undefined ? {} : { summary: usageSummary }) });
+    const timeline = useToolTimeline({ events: message.events }, { runStreaming, runSucceeded });
+    const extGroups = useExtEventGroups({ events: message.events }, { slotOf: (name, data) => registry.slot({ name, data }) });
+    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 segments = splitOnQuestionForms({ input: visibleContent });
-    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 footerUsage = showUsageLine ? usage.footer : undefined;
     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)
+            return _jsx(MidRunUserMessage, { events: group.events });
         if (!renderer)
             return null;
+        const answerText = answeredCards.answerText(group.slot);
         const node = renderer({
             name: group.name,
             events: group.events,
-            runStreaming,
+            runStreaming: answeredCards.runStreaming,
             runSucceeded,
             awaitingAnswer,
             runId: message.runId,
             ...(group.call === undefined ? {} : { call: group.call }),
             answered: answeredCards.isAnswered(group.slot),
             onAnswered: () => answeredCards.markAnswered(group.slot),
+            onAnswerText: (text) => answeredCards.markAnswered(group.slot, text),
+            ...(answeredCards.isRecorded(group.slot) ? { answerRecorded: true } : {}),
+            ...(answerText === undefined ? {} : { answerText }),
         });
         if (!node)
             return null;
@@ -218,28 +245,29 @@ export const MessageRow = memo(function MessageRow({ message, usageSummary, show
         _jsx(ExtEventErrorBoundary, { name: group.name, children: _jsx("div", { children: node }) }, `${group.slot}:${group.events.length}`));
     };
     const renderTextSegments = (text, keyPrefix) => splitOnQuestionForms({ input: text }).map((segment, i) => segment.kind === 'text' ? (segment.text.trim() ? (_jsx("div", { className: "jini-message-content", children: _jsx(Markdown, { children: segment.text }) }, `${keyPrefix}-${i}`)) : null) : (_jsx(QuestionForm, { form: segment.form, interactive: questionFormInteractive, ...(questionFormSubmittedAnswers !== undefined ? { submittedAnswers: questionFormSubmittedAnswers } : {}), ...(onQuestionFormSubmit !== undefined ? { onSubmit: onQuestionFormSubmit } : {}) }, `${keyPrefix}-${i}`)));
+    const renderBlock = (block) => {
+        if (block.kind === 'text') {
+            return _jsx(React.Fragment, { children: renderTextSegments(block.text, block.key) }, block.key);
+        }
+        if (block.kind === 'reply-end') {
+            const reply = usage.replies[block.index];
+            return reply && showUsageLine ? _jsx(UsageSummary, { usage: reply, showTotal: showUsageTotal }, block.key) : null;
+        }
+        if (block.kind === 'tools')
+            return renderTools(block.rows, block.key);
+        if (block.kind === 'thinking')
+            return _jsx(ThinkingBlock, { text: block.text }, block.key);
+        const group = extGroups.find((g) => g.slot === block.slot);
+        if (!group)
+            return null;
+        return (_jsx("div", { className: "jini-message-ext-events", children: renderExtGroup(group) }, block.key));
+    };
     return (_jsxs("div", { className: usageLineMeetsActions({ footer: footerUsage, terminalNotice, pending, runInProgress }, { showTotal: showUsageTotal })
             ? '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((block) => {
-                    if (block.kind === 'text') {
-                        return _jsx(React.Fragment, { children: renderTextSegments(block.text, block.key) }, block.key);
-                    }
-                    if (block.kind === 'reply-end') {
-                        const reply = usage.replies[block.index];
-                        return reply && showUsageLine ? _jsx(UsageSummary, { usage: reply, showTotal: showUsageTotal }, block.key) : null;
-                    }
-                    if (block.kind === 'tools')
-                        return renderTools(block.rows, block.key);
-                    if (block.kind === 'thinking')
-                        return _jsx(ThinkingBlock, { text: block.text }, block.key);
-                    const group = extGroups.find((g) => g.slot === block.slot);
-                    if (!group)
-                        return null;
-                    return (_jsx("div", { className: "jini-message-ext-events", children: renderExtGroup(group) }, block.key));
-                })
-                : (_jsxs(_Fragment, { children: [segments.map((segment, i) => segment.kind === 'text' ? (segment.text.trim() ? (_jsx("div", { className: "jini-message-content", children: _jsx(Markdown, { children: segment.text }) }, i)) : null) : (_jsx(QuestionForm, { form: segment.form, interactive: questionFormInteractive, ...(questionFormSubmittedAnswers !== undefined ? { submittedAnswers: questionFormSubmittedAnswers } : {}), ...(onQuestionFormSubmit !== undefined ? { onSubmit: onQuestionFormSubmit } : {}) }, i))), 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 })] }));
-});
+                ? blocks.map(renderBlock)
+                : (_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
  * old "Thinking…" placeholder, which vanished for good as soon as the first tool row appeared.

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

@@ -33,19 +33,24 @@ export function usageLineMeetsActions({ footer, terminalNotice, pending, runInPr
  * the current turn's cost is unknown. `showTotal: false` turns the total off. */
 export function useUsageSummary({ usage }, { showTotal = true } = {}) {
     const t = useT();
-    const parts = [];
-    if (usage.durationMs !== undefined) {
-        const seconds = Math.round(usage.durationMs / 1000);
-        parts.push(seconds >= 60 ? `${Math.floor(seconds / 60)}m ${seconds % 60}s` : `${seconds}s`);
-    }
-    if (usage.costUsd !== undefined) {
-        parts.push(formatUsageCost({ costUsd: usage.costUsd, ...(showTotal ? { totalCostUsd: usage.totalCostUsd ?? usage.costUsd } : {}) }));
-    }
-    else if (showTotal && usage.totalCostUsd !== undefined) {
-        parts.push(`total ${formatUsageCost({ costUsd: usage.totalCostUsd })}`);
-    }
+    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}` };
 }
+function usageDuration({ durationMs }, _options = {}) {
+    if (durationMs === undefined)
+        return undefined;
+    const seconds = Math.round(durationMs / 1000);
+    return seconds >= 60 ? `${Math.floor(seconds / 60)}m ${seconds % 60}s` : `${seconds}s`;
+}
+function usageCost({ usage }, { showTotal = true } = {}) {
+    if (usage.costUsd !== undefined) {
+        return formatUsageCost({ costUsd: usage.costUsd, ...(showTotal ? { totalCostUsd: usage.totalCostUsd ?? usage.costUsd } : {}) });
+    }
+    if (showTotal && usage.totalCostUsd !== undefined)
+        return `total ${formatUsageCost({ costUsd: usage.totalCostUsd })}`;
+    return undefined;
+}
 //# sourceMappingURL=MessageRow.usage.js.map

package/dist/react/components/MidRunUserMessage.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * @module MidRunUserMessage
  *
@@ -10,6 +10,10 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * It is an event of the assistant turn, not a `ChatMessage` of its own, because the agent folded it
  * into the turn it was already running — there is no separate reply to hang off it.
  */
+import { acceptedInputEvent } from '../../core/accepted-input.js';
+import { SentAttachmentButton } from './SentAttachment.js';
+import { AttachmentPreviewModal } from './AttachmentPreviewModal.js';
+import { useAttachmentGallery } from './AttachmentGallery.hooks.js';
 import { MID_RUN_USER_MESSAGE_EVENT_NAME } from '../../core/turn-usage.js';
 import { registerExtEventRenderer } from '../ext-event-renderer-registry.js';
 /** The ext-event name the daemon's mid-run `user_message` run event arrives under. One source with
@@ -25,10 +29,19 @@ export function midRunUserMessageSlotKey({ data }) {
 }
 /** The bubble for one mid-run message — the same classes as a sent user message, so it reads as one. */
 export function MidRunUserMessage({ events }) {
-    const text = field(events.at(-1), 'text');
+    const data = events.at(-1);
+    const text = field(data, 'text');
     if (text === undefined)
         return null;
-    return (_jsx("div", { className: "jini-message jini-message-user jini-message-user--mid-run", "data-agent-role": "region", "data-agent-label": "A message from the user, sent while the agent was working", children: _jsx("div", { className: "jini-message-content", children: text }) }));
+    const receipt = acceptedInputEvent({ event: { kind: 'ext', name: MID_RUN_USER_MESSAGE_EVENT_NAME, data } });
+    // MOVE: A single live delivery may contain several queued inputs; display their original receipts.
+    const inputs = receipt?.data.inputs ?? [{ id: field(data, 'id') ?? 'mid-run', text }];
+    return _jsx(_Fragment, { children: inputs.map(input => _jsx(MidRunInput, { input: input }, input.id)) });
+}
+function MidRunInput({ input }) {
+    const attachments = input.attachments ?? [];
+    const gallery = useAttachmentGallery({ attachments });
+    return (_jsxs("div", { className: "jini-message jini-message-user jini-message-user--mid-run", "data-agent-role": "region", "data-agent-label": "A message from the user, sent while the agent was working", children: [_jsx("div", { className: "jini-message-content", children: input.text }), attachments.length > 0 && _jsx("div", { className: "jini-message-attachments", children: attachments.map(attachment => _jsx(SentAttachmentButton, { attachment: attachment, onOpen: gallery.open }, attachment.path)) }), gallery.opened !== null && _jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation })] }));
 }
 /**
  * Registers {@link MidRunUserMessage} against the ext-event registry.