@jini-ai/chat 0.6.15 → 0.6.16

package/dist/react/components/MessageRow.js

@@ -71,7 +71,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 +157,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 = [];
@@ -186,7 +186,7 @@ function UserMessageRow({ message, renderAttachment }) {
     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] }));
 }
-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 +206,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 +280,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 +319,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/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

package/dist/react/features/chat-pane/components/AgentRuntimePicker.js

@@ -1,7 +1,9 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { pickerModelValue, pickerCatalogNote, pickerModelOptions, shortModelLabel } from '../model-options.js';
+import { useId } from 'react';
 import { createPortal } from 'react-dom';
 import { AgentIcon, RemixIcon, SearchableModelSelect } from '@jini-ai/ui';
+import { InfoTip } from '@jini-ai/ui/admin-widgets';
 import { assessNativeToolPolicy } from '@jini-ai/agent-runtime/native-tool-policy';
 import { useT } from '../../../hooks/context.js';
 import { definedProps } from '../../../util/defined-props.js';
@@ -18,27 +20,37 @@ export function runtimeAgentStatus({ agent }) {
         return 'Installed · sign-in required';
     return agent.version ?? 'Installed';
 }
+/**
+ * An agent's `fullCliAccessNote` as a warning icon whose tip (hover, focus, tap) holds the text.
+ * It was a paragraph beside the model picker that squeezed the composer row (owner 2026-10-30).
+ * `descriptionId` lets the agent's own radio in the picker list read the same text.
+ */
+function FullAccessNoteTip({ note, descriptionId, t }) {
+    return (_jsx("span", { className: "jini-runtime-access-note", children: _jsx(InfoTip, { label: t(note), triggerLabel: t('Full computer access'), descriptionId: descriptionId, placement: "top", icon: _jsx(RemixIcon, { name: "alert-line", size: 16 }) }) }));
+}
 /** Selection preflight uses the launch assessor; it never substitutes for enforcement. */
 function NativeToolPolicyWarning({ agent, policy, isApi }) {
     const t = useT();
     if (!agent || isApi)
         return null;
     const warning = policy ? assessNativeToolPolicy({ def: agent, policy }) : null;
-    return _jsxs(_Fragment, { children: [agent.fullCliAccessNote ? _jsx("p", { children: t(agent.fullCliAccessNote) }) : null, warning ? _jsx("p", { role: "alert", children: t(warning) }) : null] });
+    return _jsxs(_Fragment, { children: [agent.fullCliAccessNote ? _jsx(FullAccessNoteTip, { note: agent.fullCliAccessNote, t: t }) : null, warning ? _jsx("p", { role: "alert", children: t(warning) }) : null] });
 }
 function RuntimeModeButtons({ executionMode, daemonOnline, apiModeAvailable, onExecutionModeChange, t, }) {
     const localModeLabel = executionMode === 'local' ? t('active') : '';
     return (_jsxs(_Fragment, { children: [_jsxs("button", { type: "button", className: `jini-runtime-mode${executionMode === 'local' ? ' is-active' : ''}`, disabled: !daemonOnline && executionMode !== 'local', onClick: () => onExecutionModeChange?.('local'), children: [_jsx(RemixIcon, { name: "terminal-box-line", size: 18 }), _jsx("span", { children: t('Use Local CLI') }), _jsx("span", { className: "jini-runtime-mode__meta", children: !daemonOnline ? t('offline') : localModeLabel }), executionMode === 'local' ? (_jsx(RemixIcon, { name: "check-line", size: 19, className: "jini-runtime-check" })) : null] }), _jsxs("button", { type: "button", className: `jini-runtime-mode${executionMode === 'api' ? ' is-active' : ''}`, disabled: !apiModeAvailable, onClick: () => onExecutionModeChange?.('api'), children: [_jsx(RemixIcon, { name: "link", size: 18 }), _jsx("span", { children: t('Use API · BYOK') }), !apiModeAvailable ? _jsx("span", { className: "jini-runtime-mode__meta", children: t('not configured') }) : null, executionMode === 'api' ? (_jsx(RemixIcon, { name: "check-line", size: 19, className: "jini-runtime-check" })) : null] })] }));
 }
 function RuntimeAgentList({ orderedAgents, value, onChange, agentIconBasePath, t, }) {
+    const noteIdPrefix = useId();
     if (orderedAgents.length === 0) {
         return _jsx("div", { className: "jini-runtime-empty", children: t('No available code agents') });
     }
-    return (_jsx(_Fragment, { children: orderedAgents.map((agent) => {
-            const active = agent.id === value.agentId;
-            const status = runtimeAgentStatus({ agent: agent });
-            return (_jsxs("button", { type: "button", role: "radio", "aria-checked": active, className: `jini-runtime-agent${active ? ' is-active' : ''}`, "aria-current": active ? 'true' : undefined, "aria-label": `${agent.name} · ${status}`, onClick: () => onChange(defaultChatPaneSelection({ agent: agent })), children: [_jsx(AgentIcon, { id: agent.id, size: 20, className: "jini-runtime-agent-icon", ...definedProps({ source: { basePath: agentIconBasePath } }) }), _jsxs("span", { className: "jini-runtime-agent__copy", children: [_jsx("strong", { children: agent.name }), agent.fullCliAccessNote ? _jsx("small", { children: t(agent.fullCliAccessNote) }) : null] }), agent.supportsTools === false ? (_jsx("span", { className: "jini-runtime-agent__badge", title: t("This CLI has no MCP support, so it cannot use this app's tools."), children: t('No tools') })) : null, _jsx("span", { className: "jini-runtime-agent__status", children: active ? t('selected') : status }), active ? (_jsx(RemixIcon, { name: "check-line", size: 19, className: "jini-runtime-check" })) : null] }, agent.id));
-        }) }));
+    return (_jsx(_Fragment, { children: orderedAgents.map((agent) => (_jsx(RuntimeAgentRow, { agent: agent, active: agent.id === value.agentId, noteId: agent.fullCliAccessNote ? `${noteIdPrefix}-${agent.id}-note` : undefined, onChange: onChange, agentIconBasePath: agentIconBasePath, t: t }, agent.id))) }));
+}
+function RuntimeAgentRow({ agent, active, noteId, onChange, agentIconBasePath, t }) {
+    const status = runtimeAgentStatus({ agent: agent });
+    // The note's icon is a control of its own, so it sits beside the radio, never inside it.
+    return (_jsxs("div", { className: "jini-runtime-agent-row", children: [_jsxs("button", { type: "button", role: "radio", "aria-checked": active, className: `jini-runtime-agent${active ? ' is-active' : ''}`, "aria-current": active ? 'true' : undefined, "aria-label": `${agent.name} · ${status}`, ...(noteId ? { 'aria-describedby': noteId } : {}), onClick: () => onChange(defaultChatPaneSelection({ agent: agent })), children: [_jsx(AgentIcon, { id: agent.id, size: 20, className: "jini-runtime-agent-icon", ...definedProps({ source: { basePath: agentIconBasePath } }) }), _jsx("span", { className: "jini-runtime-agent__copy", children: _jsx("strong", { children: agent.name }) }), agent.supportsTools === false ? (_jsx("span", { className: "jini-runtime-agent__badge", title: t("This CLI has no MCP support, so it cannot use this app's tools."), children: t('No tools') })) : null, _jsx("span", { className: "jini-runtime-agent__status", children: active ? t('selected') : status }), active ? (_jsx(RemixIcon, { name: "check-line", size: 19, className: "jini-runtime-check" })) : null] }), agent.fullCliAccessNote ? _jsx(FullAccessNoteTip, { note: agent.fullCliAccessNote, descriptionId: noteId, t: t }) : null] }));
 }
 /**
  * The composer bar's "Model ⌄" and "Effort ⌄" drop-ups for the selected CLI. These replace the

package/dist/react/features/chat-pane/components/ChatPane.js

@@ -302,11 +302,11 @@ function buildChatPaneSlots({ surfaceSlots, embed, renderRuntimePicker }, { lead
             footerAccessories: embed ? undefined : renderRuntimePicker(),
         } });
 }
-function ChatPaneTranscript({ pane, emptyState, embed, suggestions, onSelectSuggestion, pendingPrompts, projectFileNameSet, toolCallDisplay, showUsageLine, showThinking, t, }) {
+function ChatPaneTranscript({ pane, sendingLabel, emptyState, embed, suggestions, onSelectSuggestion, pendingPrompts, projectFileNameSet, toolCallDisplay, showUsageLine, showThinking, t, }) {
     if (pane.conversation.messages.length === 0 && emptyState) {
         return (_jsxs("div", { className: "jini-message-list jini-message-list--empty", children: [emptyState, embed && _jsx(ChatPaneSuggestionsRow, { suggestions: suggestions, onSelect: onSelectSuggestion, t: t })] }));
     }
-    return (_jsx(MessageList, { messages: pane.conversation.messages, isStreaming: pane.conversation.isStreaming, scrollIntent: pane.conversation.scrollIntent, onScrolled: pane.conversation.acknowledgeScroll, pendingPrompts: pendingPrompts, toolCallDisplay: toolCallDisplay, showUsageLine: showUsageLine, showThinking: showThinking, ...(projectFileNameSet === undefined ? {} : { projectFileNames: projectFileNameSet }) }));
+    return (_jsx(MessageList, { messages: pane.conversation.messages, ...definedProps({ source: { sendingLabel } }), isStreaming: pane.conversation.isStreaming, scrollIntent: pane.conversation.scrollIntent, onScrolled: pane.conversation.acknowledgeScroll, pendingPrompts: pendingPrompts, toolCallDisplay: toolCallDisplay, showUsageLine: showUsageLine, showThinking: showThinking, ...(projectFileNameSet === undefined ? {} : { projectFileNames: projectFileNameSet }) }));
 }
 /** The controls-area suggestions row shows on every workspace surface, and on the embed surface
  * only when the empty transcript has no `emptyState` to host it instead. */
@@ -404,6 +404,6 @@ export function ChatPane(props) {
     const selectSuggestion = useChatPaneSuggestion({ rootRef, setDraft: pane.composer.setDraft });
     const openLinkInNewTab = useChatPaneNewTabLinks();
     const { pendingPrompts, projectFileNameSet } = useChatPaneTranscriptProps({ pane }, definedProps({ source: { projectFileNames: p.projectFileNames } }));
-    return (_jsxs("section", { className: chatPaneClassName(p.variant, p.className), style: p.style, "data-activity": pane.activity, ref: rootRef, onClickCapture: openLinkInNewTab, children: [_jsx("style", { "data-jini-chat-pane-styles": "true", children: CHAT_PANE_STYLES }), p.header ?? defaultHeader(p.title, pane.reset, t), p.agentPluginsMode !== 'off' && _jsx(AgentPluginUsage, { conversationId: pane.conversation.conversationId, messages: pane.conversation.messages }), _jsxs("div", { className: "jini-chat-pane__body", children: [_jsx(ChatPaneTranscript, { pane: pane, emptyState: p.emptyState, embed: surface.embed, suggestions: p.suggestions, onSelectSuggestion: selectSuggestion, pendingPrompts: pendingPrompts, projectFileNameSet: projectFileNameSet, toolCallDisplay: p.toolCallDisplay, showUsageLine: p.showUsageLine, showThinking: p.showThinking, t: t }), _jsxs("div", { className: "jini-chat-pane__controls", ref: controlsRef, children: [showsControlsSuggestions(surface.embed, pane.conversation.messages.length, p.emptyState) && (_jsx(ChatPaneSuggestionsRow, { suggestions: p.suggestions, onSelect: selectSuggestion, t: t })), pane.secretRedacted ? _jsx("div", { className: "jini-chat-pane__notice", role: "status", children: t(SECRET_REDACTED_NOTICE) }) : null, _jsx(ChatPaneStatusMessages, { unavailable: unavailable, scanningAgents: runtimeView.scanningAgents, connectingAgents: runtimeView.connectingAgents, executionMode: p.executionMode, apiModeAvailable: p.apiModeAvailable, onExecutionModeChange: p.onExecutionModeChange, sendError: pane.conversation.sendError, onRetrySend: () => void pane.retrySend(), attachmentError: pane.attachmentError, dropReadError: fileDrop.dropReadError, workingDirectoryError: pane.workingDirectoryError, workingDirectoryPending: pane.workingDirectoryPending, workingDirectoryInvalid: pane.workingDirectoryInvalid, runtimeInventoryError: inventory.runtimeInventoryError, typedAnswerNotice: pane.typedAnswerNotice, t: t }), _jsx(ChatPaneComposerArea, { fileDrop: fileDrop, uploadAttachments: surface.uploadAttachments, pane: pane, disabled: p.disabled, unavailable: unavailable, placeholder: composerPlaceholder, slots: slots, attachmentAccept: p.attachmentAccept, workingDirectoryAccess: p.workingDirectoryAccess, workingDirectoryControlPlacement: surface.workingDirectoryControlPlacement, t: t })] })] }), p.footer] }));
+    return (_jsxs("section", { className: chatPaneClassName(p.variant, p.className), style: p.style, "data-activity": pane.activity, ref: rootRef, onClickCapture: openLinkInNewTab, children: [_jsx("style", { "data-jini-chat-pane-styles": "true", children: CHAT_PANE_STYLES }), p.header ?? defaultHeader(p.title, pane.reset, t), p.agentPluginsMode !== 'off' && _jsx(AgentPluginUsage, { conversationId: pane.conversation.conversationId, messages: pane.conversation.messages }), _jsxs("div", { className: "jini-chat-pane__body", children: [_jsx(ChatPaneTranscript, { pane: pane, sendingLabel: p.sendingLabel, emptyState: p.emptyState, embed: surface.embed, suggestions: p.suggestions, onSelectSuggestion: selectSuggestion, pendingPrompts: pendingPrompts, projectFileNameSet: projectFileNameSet, toolCallDisplay: p.toolCallDisplay, showUsageLine: p.showUsageLine, showThinking: p.showThinking, t: t }), _jsxs("div", { className: "jini-chat-pane__controls", ref: controlsRef, children: [showsControlsSuggestions(surface.embed, pane.conversation.messages.length, p.emptyState) && (_jsx(ChatPaneSuggestionsRow, { suggestions: p.suggestions, onSelect: selectSuggestion, t: t })), pane.secretRedacted ? (_jsxs("div", { className: "jini-chat-pane__status jini-chat-pane__status--dismissible", role: "status", children: [_jsx("span", { children: t(SECRET_REDACTED_NOTICE) }), _jsx("button", { type: "button", className: "jini-chat-pane__error-action", onClick: pane.dismissSecretRedacted, children: t('Dismiss') })] })) : null, _jsx(ChatPaneStatusMessages, { unavailable: unavailable, scanningAgents: runtimeView.scanningAgents, connectingAgents: runtimeView.connectingAgents, executionMode: p.executionMode, apiModeAvailable: p.apiModeAvailable, onExecutionModeChange: p.onExecutionModeChange, sendError: pane.conversation.sendError, onRetrySend: () => void pane.retrySend(), attachmentError: pane.attachmentError, dropReadError: fileDrop.dropReadError, workingDirectoryError: pane.workingDirectoryError, workingDirectoryPending: pane.workingDirectoryPending, workingDirectoryInvalid: pane.workingDirectoryInvalid, runtimeInventoryError: inventory.runtimeInventoryError, typedAnswerNotice: pane.typedAnswerNotice, t: t }), _jsx(ChatPaneComposerArea, { fileDrop: fileDrop, uploadAttachments: surface.uploadAttachments, pane: pane, disabled: p.disabled, unavailable: unavailable, placeholder: composerPlaceholder, slots: slots, attachmentAccept: p.attachmentAccept, workingDirectoryAccess: p.workingDirectoryAccess, workingDirectoryControlPlacement: surface.workingDirectoryControlPlacement, t: t })] })] }), p.footer] }));
 }
 //# sourceMappingURL=ChatPane.js.map

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.d.ts

@@ -44,8 +44,10 @@ export interface UseChatPaneOptions extends UserTextRedactionOptions {
     deliverMidRunMessage?: DeliverMidRunMessage;
 }
 export interface UseChatPaneResult extends UseChatPaneWorkingDirectoryResult {
-    /** Show a localized non-secret notice when a paste was removed. */
+    /** Show a localized non-secret notice when a paste was removed. Cleared by the next send or {@link dismissSecretRedacted}. */
     secretRedacted: boolean;
+    /** Hides the redaction notice. */
+    dismissSecretRedacted: () => void;
     conversation: UseConversationResult;
     composer: UseComposerResult;
     selection: ChatPaneAgentSelection;

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

@@ -680,6 +680,7 @@ export function useChatPane(options) {
         if (!prompt || composerDeliveryBlocked({ delivering: deliveringTypedAnswerRef.current, starting: startingPromptRef.current, composer, submitted: submittedComposerRef.current }))
             return;
         setTypedAnswerNotice(null);
+        guard.clearNotice();
         // Until upload completes, an empty attachment list is not evidence of a text-only answer.
         if (uploadingWhileStreaming) {
             await sendOrdinaryTurn(prompt);
@@ -701,6 +702,7 @@ export function useChatPane(options) {
         composer,
         conversation.isStreaming,
         conversation.messages,
+        guard.clearNotice,
         options.deliverTypedAnswer,
         sendBlocker,
         sendOrdinaryTurn,
@@ -720,16 +722,18 @@ export function useChatPane(options) {
         if (!prompt || composerDeliveryBlocked({ delivering: deliveringTypedAnswerRef.current, starting: startingPromptRef.current, composer, submitted: submittedComposerRef.current }))
             return;
         setTypedAnswerNotice(null);
+        guard.clearNotice();
         await sendOrdinaryTurn(prompt);
-    }, [composer, sendOrdinaryTurn]);
+    }, [composer, guard.clearNotice, sendOrdinaryTurn]);
     const interruptSend = useCallback(() => {
         const prompt = composerPrompt(composer);
         if (!prompt || composerDeliveryBlocked({ delivering: deliveringTypedAnswerRef.current, starting: startingPromptRef.current, composer, submitted: submittedComposerRef.current }))
             return;
+        guard.clearNotice();
         enqueueTurn({ turn: guard.redact({ text: prompt }, {}) });
         composer.setDraft('');
         conversation.cancel();
-    }, [composer, conversation, enqueueTurn, guard.redact]);
+    }, [composer, conversation, enqueueTurn, guard.clearNotice, guard.redact]);
     /** Abort only uploads owned by the removed inputs; late completions must not refill the composer. */
     const discardQueuedUploads = useCallback(({ id }, _options = {}) => {
         for (const [controller, owner] of queuedUploadOwnersRef.current) {
@@ -799,6 +803,7 @@ export function useChatPane(options) {
         composer.reset();
         setAttachmentError(null);
         setTypedAnswerNotice(null);
+        guard.clearNotice();
         typedAnswerGenerationRef.current += 1;
         // Without this, a prompt queued behind a streaming run survives `reset()` and — once
         // `conversation.cancel()` above clears the streaming blocker — the flush effect fires it into
@@ -808,9 +813,10 @@ export function useChatPane(options) {
         queuedUploadOwnersRef.current.clear();
         setQueuedInputs([]);
         refusedSendRef.current = null;
-    }, [composer, conversation, options.initialMessages]);
+    }, [composer, conversation, guard.clearNotice, options.initialMessages]);
     return {
         secretRedacted: guard.secretRedacted,
+        dismissSecretRedacted: guard.clearNotice,
         conversation,
         composer,
         selection,