@jini-ai/chat 0.6.15 → 0.6.17

package/dist/react/components/Icon.js

@@ -6,6 +6,7 @@ const ICON_GLYPHS = {
     check: _jsx("path", { d: "M20 6 9 17l-5-5" }),
     close: CROSS,
     x: CROSS,
+    retry: _jsxs(_Fragment, { children: [_jsx("path", { d: "M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8" }), _jsx("path", { d: "M3 3v5h5" })] }),
     'chevron-down': _jsx("path", { d: "m6 9 6 6 6-6" }),
     /** Conversation-switcher trigger — a speech bubble reads as "chat history" without a label. */
     comment: (_jsx("path", { d: "M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z" })),
@@ -14,6 +15,7 @@ const ICON_GLYPHS = {
     'chevron-left': _jsx("path", { d: "m15 18-6-6 6-6" }),
     'chevron-right': _jsx("path", { d: "m9 18 6-6-6-6" }),
     attach: _jsx("path", { d: "m21.44 11.05-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48" }),
+    folder: _jsx("path", { d: "M3 7V5a2 2 0 0 1 2-2h5l2 3h7a2 2 0 0 1 2 2v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V7Z" }),
     file: _jsxs(_Fragment, { children: [_jsx("path", { d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8Z" }), _jsx("path", { d: "M14 2v6h6" }), _jsx("path", { d: "M8 13h8M8 17h6" })] }),
     image: _jsxs(_Fragment, { children: [_jsx("rect", { width: "18", height: "18", x: "3", y: "3", rx: "2" }), _jsx("circle", { cx: "9", cy: "9", r: "2" }), _jsx("path", { d: "m21 15-5-5L5 21" })] }),
     pencil: _jsxs(_Fragment, { children: [_jsx("path", { d: "m16 3 5 5L8 21H3v-5L16 3Z" }), _jsx("path", { d: "m14 5 5 5" })] }),

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

@@ -2,4 +2,5 @@ export interface MarkdownProps {
     children: string;
 }
 export declare function Markdown({ children }: MarkdownProps): import("react").JSX.Element;
+export declare const SAFE_LINK_HREF: RegExp;
 //# sourceMappingURL=Markdown.d.ts.map

package/dist/react/components/Markdown.js

@@ -415,7 +415,7 @@ const MD_LINK_PARTS = /^\[([^\]\n]+)\]\((.+)\)$/u;
 const INLINE_RE = new RegExp(String.raw `(\x60[^\x60]+\x60)|(${MD_LINK})|(\*\*[^*]+\*\*)|(\*[^*]+\*|${UNDERSCORE_EM})|(https?:\/\/[^\s)]+)`, 'gu');
 // Only these targets become anchors; anything else (`javascript:`, `data:`, protocol-relative
 // `//host`) stays literal text, since the text is untrusted model output.
-const SAFE_LINK_HREF = /^(?:https?:\/\/|mailto:|\/(?!\/)|#)/iu;
+export const SAFE_LINK_HREF = /^(?:https?:\/\/|mailto:|\/(?!\/)|#)/iu;
 // Every link opens in a new tab — an in-app path too, so following one never navigates the tab the
 // chat lives in (owner 2026-10-08). Only a `#` same-document anchor stays in place. ChatPane's
 // click guard (`useChatPaneNewTabLinks`) covers links this renderer does not draw.

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

@@ -3,10 +3,11 @@ import { type MessageRowProps } from './MessageRow.js';
 interface PendingPrompt {
     id?: string;
     text: string;
+    folders?: string[];
     attachments?: ChatAttachment[];
     onCancel: () => void;
 }
-export interface MessageListProps extends Pick<MessageRowProps, 'projectFileNames' | 'onRequestOpenFile' | 'renderAttachment' | 'showUsageTotal' | 'showUsageLine' | 'toolCallDisplay' | 'showThinking'> {
+export interface MessageListProps extends Pick<MessageRowProps, 'projectFileNames' | 'onRequestOpenFile' | 'renderAttachment' | 'showUsageTotal' | 'showUsageLine' | 'toolCallDisplay' | 'showThinking' | 'sendingLabel'> {
     messages: ChatMessage[];
     isStreaming?: boolean;
     /** Mirrors `useConversation().scrollIntent` — when `true`, this component scrolls to the bottom on mount/update. */

package/dist/react/components/MessageList.js

@@ -10,6 +10,7 @@ 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 { FolderChips } from './FolderChips.js';
 import { memo, useMemo } from 'react';
 import { projectAcceptedInputMessages } from '../../core/accepted-input.js';
 import { isTerminalRunStatus } from '../../core/index.js';
@@ -55,6 +56,6 @@ 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') }) })] }));
+    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') }), prompt.folders?.length ? _jsx("div", { className: "jini-message-attachments", children: _jsx(FolderChips, { folders: prompt.folders }) }) : null, _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

@@ -73,6 +73,9 @@ export interface MessageRowProps {
     runStreaming?: boolean;
     /** Whether the server has yet to accept this reply's run (its user turn is still pending). */
     runSending?: boolean;
+    /** Host-localized text shown verbatim only while this run is active and sending.
+     * Omit to use the translated `Sending…` label. */
+    sendingLabel?: string;
     runSucceeded?: boolean;
     /** Whether this message's question-form (if any) is still the active/answerable one. */
     questionFormInteractive?: boolean;

package/dist/react/components/MessageRow.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { FolderChips } from './FolderChips.js';
 import { projectAcceptedInputEvents } from '../../core/accepted-input.js';
 import { MidRunUserMessage, MID_RUN_USER_MESSAGE_EXT_EVENT_NAME } from './MidRunUserMessage.js';
 import { useSurfaceAnswerContexts } from './mcp-ui-question-input.js';
@@ -71,7 +72,7 @@ import { Markdown } from './Markdown.js';
 import { ToolCard } from './ToolCard.js';
 import { QuestionForm } from './QuestionForm.js';
 import { ToolCallGroup } from './ToolCallGroup.js';
-import { applyToolCallDisplay, toolRowsForDisplay } from '../tool-call-display.js';
+import { applyToolCallDisplay, retriedToolRowIds, toolRowsForDisplay } from '../tool-call-display.js';
 /**
  * True while an assistant message is still fully pending — no visible text
  * and no tool rows have arrived yet. Shared by the "Thinking…" placeholder
@@ -157,9 +158,9 @@ function ThinkingBlock({ text }) {
 function messageAwaitingAnswer({ runStreaming, runInProgress, events }, { isAnsweredCard } = {}) {
     return runStreaming === true && runInProgress && isAwaitingAnswer({ events }, { isAnsweredCard });
 }
-function AssistantMessageFooter({ message, usageEvent, showUsageTotal, terminalNotice, pending, runInProgress, runStreaming, runSending, visibleContent, isAnsweredCard }, _optional = {}) {
+function AssistantMessageFooter({ message, usageEvent, showUsageTotal, terminalNotice, pending, runInProgress, runStreaming, runSending, sendingLabel, visibleContent, isAnsweredCard }, _optional = {}) {
     const t = useT();
-    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, sending: runSending }) : 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, sending: runSending, sendingLabel: sendingLabel }) : null] });
 }
 /** Stable empty list for a message with no attachments. */
 const NO_ATTACHMENTS = [];
@@ -184,9 +185,9 @@ function UserMessageRow({ message, renderAttachment }) {
     // 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 });
-    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?.length || message.folders?.length) ? (_jsxs("div", { className: "jini-message-attachments", children: [_jsx(FolderChips, { folders: message.folders }), (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, runSending, runSucceeded, questionFormInteractive, questionFormSubmittedAnswers, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, }) {
+function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageLine, toolCallDisplay, showThinking, runStreaming, runSending, sendingLabel, 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 });
@@ -206,7 +207,8 @@ function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageL
     });
     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));
+    const retriedRows = retriedToolRowIds({ rows: timeline.rows });
+    const renderToolCard = (row) => (_jsx(ToolCard, { retried: retriedRows.has(row.id), use: row.use, result: row.result, runStreaming: runStreaming, runSucceeded: runSucceeded, ...(projectFileNames !== undefined ? { projectFileNames } : {}), ...(onRequestOpenFile !== undefined ? { onRequestOpenFile } : {}) }, row.id));
     // 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)
@@ -279,7 +281,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, section
                 ? section.map(renderBlock)
-                : (_jsxs(_Fragment, { children: [renderTextSegments(visibleContent, 'text'), flatTools.map((group) => renderTools(group.rows, group.key)), flatExtGroups.length > 0 ? _jsx("div", { className: "jini-message-ext-events", children: flatExtGroups.map(renderExtGroup) }) : null] })), footer && _jsx(AssistantMessageFooter, { message, usageEvent: footerUsage, showUsageTotal, terminalNotice, pending, runInProgress, runStreaming, runSending, visibleContent, isAnsweredCard: answeredCards.isAnsweredCard })] }, footer ? message.id : key));
+                : (_jsxs(_Fragment, { children: [renderTextSegments(visibleContent, 'text'), flatTools.map((group) => renderTools(group.rows, group.key)), flatExtGroups.length > 0 ? _jsx("div", { className: "jini-message-ext-events", children: flatExtGroups.map(renderExtGroup) }) : null] })), footer && _jsx(AssistantMessageFooter, { message, usageEvent: footerUsage, showUsageTotal, terminalNotice, pending, runInProgress, runStreaming, runSending, sendingLabel, visibleContent, isAnsweredCard: answeredCards.isAnsweredCard })] }, footer ? message.id : key));
     // The lossless fallback keeps the host's text intact; user receipts still own separate rows,
     // in their original receipt order, outside the assistant's actions and usage footer.
     // Keep the same child-array nesting as the interleaved path so React preserves the footer.
@@ -318,13 +320,14 @@ function isUserSection({ section }, _options = {}) {
  * 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.
  * Kept a separate component so its one-second tick re-renders only this line, not the whole row.
+ * A host's already-localized sending label is used verbatim until acceptance.
  */
-function RunActivityLine({ events, active, isAnsweredCard, sending }) {
+function RunActivityLine({ events, active, isAnsweredCard, sending, sendingLabel }) {
     const t = useT();
     const activityLabel = useRunActivity({ events: events, active: active }, { isAnsweredCard });
     // Until the server accepts the start the turn is still on its way: "Thinking…" there read as the
     // model working while the text had not even arrived (owner, 2026-10-27). No timeout.
-    const label = active && sending ? t('Sending…') : continuingRunNotice({ events, active }, {}) ?? activityLabel;
+    const label = active && sending ? sendingLabel ?? t('Sending…') : continuingRunNotice({ events, active }, {}) ?? activityLabel;
     if (label === null)
         return null;
     return (_jsx("div", { className: "jini-message-pending jini-run-activity", "aria-live": "off", children: label }));

package/dist/react/components/MidRunUserMessage.js

@@ -10,6 +10,7 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
  * It is stored as 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 { FolderChips } from './FolderChips.js';
 import { acceptedInputEvent } from '../../core/accepted-input.js';
 import { SentAttachmentButton } from './SentAttachment.js';
 import { CopyMessageButton } from './CopyMessageButton.js';
@@ -37,7 +38,7 @@ export function MidRunUserMessage({ events, runStreaming = false, transcriptRow
         return null;
     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 }];
+    const inputs = receipt?.data.inputs ?? [receipt?.data ?? { id: field(data, 'id') ?? 'mid-run', text }];
     // A run that ended without reading the message hands it to the next turn; it is no longer queued here.
     return _jsx(_Fragment, { children: inputs.map(input => _jsx(MidRunInput, { input: input, transcriptRow: transcriptRow, queued: runStreaming && (input.deliveryState ?? receipt?.data.deliveryState) === 'queued' }, input.id)) });
 }
@@ -48,7 +49,7 @@ function MidRunInput({ input, queued, transcriptRow }) {
     const t = useT();
     const attachments = input.attachments ?? [];
     const gallery = useAttachmentGallery({ attachments });
-    return (_jsxs("div", { className: `jini-message jini-message-user${transcriptRow ? '' : ' jini-message-user--mid-run'}`, "data-agent-role": "region", "data-agent-label": "A message from the user, sent while the agent was working", children: [queued && _jsx("div", { className: "jini-message-user__queued", role: "status", children: t('Queued — read after the current step') }), _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)) }), _jsx("div", { className: "jini-message-actions jini-message-actions--user", children: _jsx(CopyMessageButton, { text: input.text, label: t('Copy message') }) }), gallery.opened !== null && _jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation })] }));
+    return (_jsxs("div", { className: `jini-message jini-message-user${transcriptRow ? '' : ' jini-message-user--mid-run'}`, "data-agent-role": "region", "data-agent-label": "A message from the user, sent while the agent was working", children: [queued && _jsx("div", { className: "jini-message-user__queued", role: "status", children: t('Queued — read after the current step') }), input.folders?.length ? _jsx("div", { className: "jini-message-attachments", children: _jsx(FolderChips, { folders: input.folders }) }) : null, _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)) }), _jsx("div", { className: "jini-message-actions jini-message-actions--user", children: _jsx(CopyMessageButton, { text: input.text, label: t('Copy message') }) }), gallery.opened !== null && _jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation })] }));
 }
 /**
  * Registers {@link MidRunUserMessage} against the ext-event registry.

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

@@ -16,7 +16,9 @@ export interface ToolCardProps {
     projectFileNames?: Set<string>;
     /** Lifts a basename up to the host so it can focus the matching tab in its own file viewer. */
     onRequestOpenFile?: (name: string) => void;
+    /** A later call of the same tool in this turn succeeded (`retriedToolRowIds`): a failure shows a neutral "Retried" badge, not red. */
+    retried?: boolean;
 }
-export declare function ToolCard({ use, result, runStreaming, runSucceeded, projectFileNames, onRequestOpenFile }: ToolCardProps): import("react").JSX.Element | null;
+export declare function ToolCard({ use, result, runStreaming, runSucceeded, projectFileNames, onRequestOpenFile, retried }: ToolCardProps): import("react").JSX.Element | null;
 export {};
 //# sourceMappingURL=ToolCard.d.ts.map

package/dist/react/components/ToolCard.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 const RUNNING_TITLE_CLASS = ' shimmer-text';
 /**
  * @module ToolCard
@@ -21,18 +21,29 @@ const RUNNING_TITLE_CLASS = ' shimmer-text';
  * `AskUserQuestion`) falls through to `GenericCard`, which is a correct,
  * generic rendering for it.
  */
-import { useId, useState } from 'react';
-import { COLLAPSED_DETAIL_MAX_CHARS, describeCollapsedToolCall, describeToolCallDetail, isDelegatedWrapperToolName, isTodoWriteToolName, parseTodoWriteInput, redactUserText, toRenderProps } from '../../core/index.js';
+import { createContext, useContext, useId, useMemo, useState } from 'react';
+import { COLLAPSED_DETAIL_MAX_CHARS, describeCollapsedToolCall, describeToolCallDetail, humanizeToolName, isDelegatedWrapperToolName, isTodoWriteToolName, parseTodoWriteInput, redactUserText, toRenderProps } from '../../core/index.js';
 import { useT, useToolRendererRegistry } from '../hooks/context.js';
 import { Icon } from './Icon.js';
+import { SAFE_LINK_HREF } from './Markdown.js';
 import { TodoCard } from './TodoCard.js';
+import { toolRowTarget } from './ToolCard.rules.js';
+import { toolPresentation } from '../../core/tool-presentation.js';
+/**
+ * Read by `ErrorBadge` only. A context, not one more prop threaded through every family card,
+ * because each card renders its own badge and all of them must agree.
+ */
+const RetriedContext = createContext(false);
 /** A Jini registry tool id: dotted, lowercase, snake_case segments — `page.fill`, `daemon.db.vacuum`, `chat.send_message`. Never matches an agent-vendor tool name (`Bash`, `Write`, `mcp__jini__execute_delegated_tool`), which is the point — this is how a canonical delegated-tool event is told apart from everything else. */
 const JINI_TOOL_ID_PATTERN = /^[a-z][a-z_]*(\.[a-z][a-z_]*)+$/;
-export function ToolCard({ use, result, runStreaming, runSucceeded, projectFileNames, onRequestOpenFile }) {
+export function ToolCard({ use, result, runStreaming, runSucceeded, projectFileNames, onRequestOpenFile, retried = false }) {
     const registry = useToolRendererRegistry();
+    // Resolve vendor dialects for rendering only; tool ids and stored events stay intact.
+    const presentation = toolPresentation(use);
+    use = { ...use, ...presentation };
     const name = use.name;
     const card = { input: use.input, result: result, runStreaming: runStreaming ?? false, runSucceeded: runSucceeded ?? false };
-    const content = renderToolCardBody({ use, card, fileCtx: { projectFileNames, onRequestOpenFile }, registry });
+    const content = renderToolCardBody({ use, card, wrapper: presentation.wrapper, fileCtx: { projectFileNames, onRequestOpenFile }, registry });
     if (content === null)
         return null;
     // Tagged once here, at the single dispatch point every branch below funnels through, rather than
@@ -40,7 +51,7 @@ export function ToolCard({ use, result, runStreaming, runSucceeded, projectFileN
     // host's own custom-registered renderer) gets it automatically. `use.id` is this tool call's own
     // stable identifier (unique per call within a message), never reused, so this handle is never
     // ambiguous the way a repeated literal handle would be.
-    return (_jsx("div", { "data-agent-element": `tool-call-${use.id}`, "data-agent-role": "region", "data-agent-label": `A ${humanizeToolId(name)} tool call the AI made`, children: content }));
+    return (_jsx("div", { "data-agent-element": `tool-call-${use.id}`, "data-agent-role": "region", "data-agent-label": `A ${humanizeToolName({ name: name })} tool call the AI made`, children: _jsx(RetriedContext.Provider, { value: retried, children: content }) }));
 }
 // Hardcoded family cards for tools shipped with this package, keyed by every name each tool goes
 // by. A `Map`, not an object literal, so a tool named `constructor`/`toString` can never resolve
@@ -90,7 +101,8 @@ function renderToolCardBody(args) {
     // `useToolTimeline`: `foldDelegatedWrapperCalls` drops it in favour of that canonical row. This
     // check still covers a host that renders `<ToolCard>` straight from raw events.)
     // Covers the read-only gateway (`execute_readonly_delegated_tool`) too.
-    if (isDelegatedWrapperToolName({ name: name }) && card.result && !card.result.isError)
+    // An outer transport receipt may have no bridge row; keep its inner call visible.
+    if (!args.wrapper && isDelegatedWrapperToolName({ name: name }) && card.result && !card.result.isError)
         return null;
     if (isTodoWriteToolName({ name: name }))
         return _jsx(TodoCard, { todos: parseTodoWriteInput({ input: use.input }), runStreaming: card.runStreaming });
@@ -108,28 +120,29 @@ function renderToolCardBody(args) {
     }
     return _jsx(GenericCard, { name: name, ...card });
 }
-/** `"page.fill"` -> `"Page Fill"`, `"daemon.db.vacuum"` -> `"Daemon Db Vacuum"`. Cosmetic only — never used to make a routing decision. */
-function humanizeToolId(id) {
-    return id
-        .split('.')
-        .map((segment) => segment.split('_').map((word) => (word ? word[0].toUpperCase() + word.slice(1) : word)).join(' '))
-        .join(' ');
-}
-/** The one argument that best identifies *what* a call acted on, for the card's collapsed summary — an element handle, a page id, or (for tools with neither) whatever the first string-valued argument is. */
-function primaryTarget(input) {
-    if (input == null || typeof input !== 'object')
-        return undefined;
-    const obj = input;
-    for (const key of ['element', 'page', 'handle', 'toolId', 'id']) {
-        const v = obj[key];
-        if (typeof v === 'string' && v)
-            return v;
-    }
-    for (const v of Object.values(obj)) {
-        if (typeof v === 'string' && v)
-            return v;
-    }
-    return undefined;
+/**
+ * The head every Jini/MCP/unknown tool row shares: status, "<Humanized Name>" (announced as
+ * "Tool call · <Humanized Name>"), and the
+ * target ({@link toolRowTarget}). One place, so a tool id the family table doesn't know (`content_post_update`,
+ * `mcp__tovu__theme_list_files`) still reads as a label and never as its raw name and JSON args.
+ */
+function ToolRowHead({ name, input, result, runStreaming, runSucceeded }) {
+    const t = useT();
+    // Streaming deltas recreate result envelopes; parse only when the target's inputs change.
+    // A failed event's payload describes the error even when it contains human-looking names.
+    const resultContent = result?.content;
+    const resultIsError = result?.isError;
+    const target = useMemo(() => toolRowTarget({ input: input, resultContent: resultIsError ? undefined : resultContent }), [input, resultContent, resultIsError]);
+    const summary = target ? headSummary({ text: target }) : undefined;
+    const prefix = `${t('Tool call')} · `;
+    const toolName = humanizeToolName({ name: name });
+    const isRunning = runStreaming && !result;
+    // Name and target each carry their full text as a tooltip: on a narrow dock the name truncates
+    // first and the target is capped (styles.ts `.op-title`/`.op-meta`), so either can be cut.
+    // The "Tool call · " prefix is visually hidden (owner bug 11-01: it took half a ~333px dock row, so
+    // names read "Tool call · Cont…") but stays in the row's accessible name. The name's tooltip must
+    // not repeat it: trees that read a child's title before its text announced "Tool call · Tool call ·".
+    return (_jsxs(_Fragment, { children: [_jsx(ResultBadge, { result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }), _jsx("span", { className: "op-sr-prefix", children: prefix }), _jsx("span", { className: `op-title${isRunning ? RUNNING_TITLE_CLASS : ''}`, title: toolName, children: toolName }), summary ? _jsx("span", { className: "op-meta op-target", title: summary, children: summary }) : null] }));
 }
 /**
  * A card for one `page.*`/`daemon.db.*`/`chat.*`/… call — the canonical event
@@ -139,15 +152,12 @@ function primaryTarget(input) {
  * blob this replaces.
  */
 function DelegatedToolCard({ name, input, result, runStreaming, runSucceeded }) {
-    const t = useT();
     // Wrapper form (only reached on a failed wrapper call, per ToolCard's suppression comment):
     // the real id and args are nested under {toolId, input}, not `input` itself.
     const wrapper = (input ?? {});
     const toolId = isDelegatedWrapperToolName({ name: name }) ? (wrapper.toolId ?? name) : name;
     const args = isDelegatedWrapperToolName({ name: name }) ? wrapper.input : input;
-    const target = primaryTarget(args);
-    const isRunning = runStreaming && !result;
-    return (_jsx(ExpandableCard, { className: "op-jini-tool", call: { input: args ?? {}, result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }, head: _jsxs(_Fragment, { children: [_jsx(ResultBadge, { result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }), _jsxs("span", { className: `op-title${isRunning ? RUNNING_TITLE_CLASS : ''}`, children: [t('Tool call'), " \u00B7 ", humanizeToolId(toolId)] }), target ? _jsx("span", { className: "op-meta", children: headSummary({ text: target }) }) : null] }), after: _jsx(FileErrorDetail, { result: result }), children: _jsx(ToolCallDetail, { input: args ?? {}, result: result, runStreaming: runStreaming, runSucceeded: runSucceeded, children: _jsx(ToolResultMedia, { result: result }) }) }));
+    return (_jsx(ExpandableCard, { className: "op-jini-tool", call: { input: args ?? {}, result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }, head: _jsx(ToolRowHead, { name: toolId, input: args, result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }), after: _jsx(FileErrorDetail, { result: result }), children: _jsx(ToolCallDetail, { input: args ?? {}, result: result, runStreaming: runStreaming, runSucceeded: runSucceeded, children: _jsx(ToolResultMedia, { result: result }) }) }));
 }
 function SearchToolsCard({ input, result, runStreaming, runSucceeded }) {
     const t = useT();
@@ -236,8 +246,7 @@ function WebSearchCard({ input, result, runStreaming, runSucceeded }) {
 }
 /** Any tool this package has no family card for — an MCP tool, or a card tool such as `assistant_ask_choice` whose form renders elsewhere in the turn. The row still opens to the full call. */
 function GenericCard({ name, input, result, runStreaming, runSucceeded }) {
-    const summary = describeInput(input);
-    return (_jsx(ExpandableCard, { className: "op-generic", call: { input: input, result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }, head: _jsxs(_Fragment, { children: [_jsx(ResultBadge, { result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }), _jsx("span", { className: "op-title", children: name }), summary ? _jsx("span", { className: "op-meta", children: headSummary({ text: summary }) }) : null] }), after: _jsx(ToolResultMedia, { result: result }), children: _jsx(ToolCallDetail, { input: input, result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }) }));
+    return (_jsx(ExpandableCard, { className: "op-generic", call: { input: input, result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }, head: _jsx(ToolRowHead, { name: name, input: input, result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }), after: _jsx(ToolResultMedia, { result: result }), children: _jsx(ToolCallDetail, { input: input, result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }) }));
 }
 /**
  * The one row shell every card shares: a real `<button>` head (Enter/Space toggle it) that reports
@@ -255,7 +264,14 @@ function ExpandableCard({ className, head, after, call, children }) {
 }
 /** The collapsed row's stand-in for its panel — see {@link ExpandableCard} and `describeCollapsedToolCall`. */
 function CollapsedReaderText({ call }) {
-    const text = describeCollapsedToolCall({ input: call.input, result: call.result }, { runStreaming: call.runStreaming, runSucceeded: call.runSucceeded });
+    const input = call.input;
+    const resultContent = call.result?.content;
+    const resultIsError = call.result?.isError ?? false;
+    // Streaming deltas recreate envelopes; only changed reader text needs formatting/redaction.
+    // Run state explains a missing result, but cannot change the text of a recorded result.
+    const runStreaming = !call.result && call.runStreaming;
+    const runSucceeded = !call.result && call.runSucceeded;
+    const text = useMemo(() => describeCollapsedToolCall({ input, result: resultContent === undefined ? undefined : { content: resultContent, isError: resultIsError } }, { runStreaming, runSucceeded }), [input, resultContent, resultIsError, runStreaming, runSucceeded]);
     return _jsx("span", { className: "op-card-reader-text", hidden: true, children: text });
 }
 /** The call's input, its result (or why there is none), and any extra `children` — see `describeToolCallDetail` for the redaction and formatting rules. */
@@ -266,6 +282,13 @@ function ToolCallDetail({ input, result, runStreaming, runSucceeded, children })
     const detail = describeToolCallDetail({ input: input, result: result }, { runStreaming: runStreaming, runSucceeded: runSucceeded, maxChars: Infinity });
     return (_jsxs("div", { className: "op-card-detail", children: [detail.inputText !== null ? _jsx("pre", { className: "op-command op-input", children: detail.inputText }) : null, detail.outputText !== null ? _jsx("pre", { className: "op-output", children: detail.outputText }) : null, detail.noteKey !== null ? _jsx("p", { className: "op-detail-note", children: t(detail.noteKey) }) : null, children] }));
 }
+/** A failed result: neutral "Retried" when a later call of the same tool succeeded, else red. */
+function ErrorBadge({ result }) {
+    const t = useT();
+    if (useContext(RetriedContext))
+        return (_jsx("span", { className: "op-status op-status-retried", title: t('Retried'), children: _jsx(Icon, { name: "retry", size: 14 }) }));
+    return (_jsx("span", { className: "op-status op-status-error", title: describeToolCallDetail({ input: null, result }, { maxChars: COLLAPSED_DETAIL_MAX_CHARS }).outputText ?? t('Error'), children: _jsx(Icon, { name: "close", size: 14 }) }));
+}
 function ResultBadge({ result, runStreaming, runSucceeded }) {
     const t = useT();
     if (!result && runStreaming)
@@ -273,7 +296,7 @@ function ResultBadge({ result, runStreaming, runSucceeded }) {
     if (!result && !runSucceeded)
         return (_jsx("span", { className: "op-status op-status-error", title: t('Error'), children: _jsx(Icon, { name: "close", size: 14 }) }));
     if (result?.isError)
-        return (_jsx("span", { className: "op-status op-status-error", title: describeToolCallDetail({ input: null, result }, { maxChars: COLLAPSED_DETAIL_MAX_CHARS }).outputText ?? t('Error'), children: _jsx(Icon, { name: "close", size: 14 }) }));
+        return _jsx(ErrorBadge, { result: result });
     return (_jsx("span", { className: "op-status op-status-ok", title: t('Done'), children: _jsx(Icon, { name: "check", size: 14 }) }));
 }
 /**
@@ -295,7 +318,23 @@ function ToolResultMedia({ result }) {
     const images = blocks.filter((block) => block.type === 'image');
     if (images.length === 0)
         return null;
-    return (_jsx("div", { className: "op-media", children: images.map((block, index) => (_jsx("img", { className: "op-media-image", src: `data:${block.mimeType};base64,${block.data}`, alt: "", style: { maxWidth: '100%', height: 'auto', display: 'block' } }, index))) }));
+    return (_jsx("div", { className: "op-media", children: images.map((block, index) => _jsx(ToolResultImageFigure, { block: block }, index)) }));
+}
+/**
+ * One tool image: captioned by its `title` (also the alt text) and linked to its `href` in a new
+ * tab, so a picture a tool just saved opens full size. The href is tool output, so it gets the same
+ * safe-target rule as chat links (`Markdown.tsx`); `javascript:`/`data:` stays an unlinked image.
+ */
+function ToolResultImageFigure({ block }) {
+    const img = (_jsx("img", { className: "op-media-image", src: `data:${block.mimeType};base64,${block.data}`, alt: block.title ?? '', style: { maxWidth: '100%', height: 'auto', display: 'block' } }));
+    const linked = block.href !== undefined && SAFE_LINK_HREF.test(block.href) && !block.href.startsWith('#')
+        ? _jsx("a", { className: "op-media-link", href: block.href, target: "_blank", rel: "noopener noreferrer", children: img })
+        : img;
+    if (block.title === undefined)
+        return linked;
+    return (
+    // No host stylesheet styles op-media yet; reset the UA figure margin (40px sides) inline, like the img.
+    _jsxs("figure", { className: "op-media-figure", style: { margin: 0 }, children: [linked, _jsx("figcaption", { className: "op-media-caption", children: block.title })] }));
 }
 function FileErrorDetail({ result }) {
     if (!result?.isError)
@@ -305,26 +344,6 @@ function FileErrorDetail({ result }) {
     const detail = describeToolCallDetail({ input: null, result }, { maxChars: COLLAPSED_DETAIL_MAX_CHARS });
     return detail.outputText === null ? null : _jsx("pre", { className: "op-output", children: detail.outputText });
 }
-function describeInput(input) {
-    if (input == null)
-        return '';
-    if (typeof input === 'string')
-        return input;
-    if (typeof input !== 'object')
-        return String(input);
-    const obj = input;
-    for (const key of ['file_path', 'path', 'pattern', 'url', 'query', 'name', 'command']) {
-        const v = obj[key];
-        if (typeof v === 'string')
-            return v;
-    }
-    try {
-        return JSON.stringify(obj);
-    }
-    catch {
-        return '';
-    }
-}
 /**
  * A head's one-line summary of an arbitrary argument. Heads stay mounted for every collapsed row,
  * and the fallback argument can be a 20k-char payload or a key, so it gets the reader text's

package/dist/react/components/ToolCard.rules.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @file What a generic tool row names as its target — pure, so `ToolCard.tsx`'s `ToolRowHead` only
+ * draws it. Moved out of `ToolCard.tsx` (11-01) when the target learned to read the result too.
+ */
+/**
+ * What a tool row names as its target, for a person, best first: an argument that names it (see
+ * {@link SUMMARY_KEYS}: handle, title, slug, path, query…), the name the result returned, a shallow
+ * batch summary (after the result name, so an incidental array argument like `tags` never hides the
+ * record a single-record call returned), the record's kind ("post"), then any other readable string argument. Never the JSON of the whole
+ * object — that read as raw machine output in the head (`{"id":"30127d…","kind":"post",…`); the
+ * full arguments are in the expanded detail — and never an opaque id (owner bug 11-01: "Content
+ * Post Update 30127d31-…"). `undefined` when nothing reads as a target.
+ *
+ * @complexity O(k) in the argument and result key counts; one `JSON.parse` of the result.
+ */
+export declare function toolRowTarget({ input, resultContent }: {
+    input: unknown;
+    resultContent?: string | undefined;
+}): string | undefined;
+//# sourceMappingURL=ToolCard.rules.d.ts.map

package/dist/react/components/ToolCard.rules.js

@@ -0,0 +1,92 @@
+/**
+ * @file What a generic tool row names as its target — pure, so `ToolCard.tsx`'s `ToolRowHead` only
+ * draws it. Moved out of `ToolCard.tsx` (11-01) when the target learned to read the result too.
+ */
+/** Argument keys that name *what* a call acted on, best first: an element handle or page, then a human title/name/slug, then a path or query, then an id. */
+const SUMMARY_KEYS = ['element', 'page', 'handle', 'title', 'name', 'slug', 'file_path', 'path', 'pattern', 'url', 'query', 'command', 'toolId', 'id'];
+/** Result fields that name a record for a person — what a write or read returns about its target. */
+const RESULT_NAME_KEYS = ['title', 'name', 'slug'];
+/** Argument keys that say what *kind* of thing a call acted on — the last-resort target. */
+const KIND_KEYS = ['kind', 'entityType', 'type', 'collection'];
+/** A UUID or a long bare hex id: meaningless to a person, so never shown as a row's target. */
+const OPAQUE_ID = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{16,})$/i;
+function readable(value) {
+    return typeof value === 'string' && value !== '' && !OPAQUE_ID.test(value);
+}
+function firstReadable(obj, keys) {
+    for (const key of keys) {
+        const value = obj[key];
+        if (readable(value))
+            return value;
+    }
+    return undefined;
+}
+/** Failure metadata describes the error, never the acted-on record. @complexity O(1). */
+function isErrorResult(obj) {
+    const hasError = obj.error != null && obj.error !== false;
+    const failedStatus = obj.status === 'failed' || obj.status === 'error';
+    return hasError || failedStatus || obj.isError === true || obj.success === false;
+}
+/**
+ * The record name a JSON tool result carries — at its top level or one object level down
+ * (`{ post: { title } }`). `undefined` for failures, non-JSON text or a result with no name field.
+ *
+ * @complexity O(n + k) for content length n and top-level key count k; one `JSON.parse`.
+ */
+function resultName(content) {
+    if (!content || !content.trimStart().startsWith('{'))
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+    if (parsed == null || typeof parsed !== 'object')
+        return undefined;
+    const obj = parsed;
+    if (isErrorResult(obj))
+        return undefined;
+    const nested = Object.values(obj).filter((v) => v != null && typeof v === 'object' && !Array.isArray(v));
+    return firstReadable(obj, RESULT_NAME_KEYS) ?? nested.map((v) => firstReadable(v, RESULT_NAME_KEYS)).find(Boolean);
+}
+/** A batch member's own target: a readable string member, or an object member's summary key. O(k). */
+function memberTarget(first) {
+    if (readable(first))
+        return first;
+    return first != null && typeof first === 'object' ? firstReadable(first, SUMMARY_KEYS) : undefined;
+}
+/** A shallow batch target, independent of CLI and collection key. No document-body traversal.
+ * O(k) in the envelope and first member's key counts; never scans or serializes all members.
+ */
+function batchTarget(input) {
+    const members = Array.isArray(input) ? input : Object.values(input).find(Array.isArray);
+    if (!members?.length)
+        return undefined;
+    const target = memberTarget(members[0]);
+    if (!target)
+        return `${members.length} ${members.length === 1 ? 'item' : 'items'}`;
+    return members.length === 1 ? target : `${target} +${members.length - 1}`;
+}
+/**
+ * What a tool row names as its target, for a person, best first: an argument that names it (see
+ * {@link SUMMARY_KEYS}: handle, title, slug, path, query…), the name the result returned, a shallow
+ * batch summary (after the result name, so an incidental array argument like `tags` never hides the
+ * record a single-record call returned), the record's kind ("post"), then any other readable string argument. Never the JSON of the whole
+ * object — that read as raw machine output in the head (`{"id":"30127d…","kind":"post",…`); the
+ * full arguments are in the expanded detail — and never an opaque id (owner bug 11-01: "Content
+ * Post Update 30127d31-…"). `undefined` when nothing reads as a target.
+ *
+ * @complexity O(k) in the argument and result key counts; one `JSON.parse` of the result.
+ */
+export function toolRowTarget({ input, resultContent }) {
+    if (typeof input === 'string')
+        return readable(input) ? input : undefined;
+    if (input != null && typeof input !== 'object')
+        return String(input);
+    const args = (input ?? {});
+    const named = firstReadable(args, SUMMARY_KEYS) ?? resultName(resultContent);
+    return named ?? batchTarget(args) ?? firstReadable(args, KIND_KEYS) ?? Object.values(args).find(readable);
+}
+//# sourceMappingURL=ToolCard.rules.js.map