@jini-ai/chat 0.5.2 → 0.5.4

package/dist/react/components/Markdown.js

@@ -34,7 +34,7 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
  * renderer covers:
  * ATX headings (`#`…`###`), fenced code blocks, ordered/unordered lists,
  * blockquotes, a horizontal rule, paragraphs, and inline `` `code` ``/
- * `**bold**`/`*italic*`/bare autolinks — including inside table cells, via
+ * `**bold**`/`*italic*`/`[label](url)` links/bare autolinks — including inside table cells, via
  * the same `renderInline` pass every other block uses. TODO(follow-up): port
  * the code-comment directive syntax once a host needs it.
  */
@@ -370,21 +370,52 @@ function TableBlock(props) {
                         setExpanded(false);
                 }, children: [_jsx("button", { type: "button", className: "jini-md-table-modal-close", onClick: () => setExpanded(false), "aria-label": "Close", children: "\u00D7" }), _jsx("div", { className: "jini-md-table-modal-body", children: expanded ? renderTableElement(props) : null })] })] }));
 }
-// Inline pass: `code`, **bold**, *italic*/_italic_, bare http(s) autolinks.
+// Inline pass: `code`, [label](url) links, **bold**, *italic*/_italic_, bare http(s) autolinks.
 // Processes left-to-right with a single regex alternation so spans never
 // nest incorrectly across kinds.
-const INLINE_RE = /(`[^`]+`)|(\*\*[^*]+\*\*)|(\*[^*]+\*|_[^_]+_)|(https?:\/\/[^\s)]+)/g;
+//
+// `_italic_` follows CommonMark's word-boundary rule: an `_` with a letter,
+// digit or `_` on its outer side never opens or closes emphasis, and an `_`
+// between two word characters inside the span is content. The plain
+// `_[^_]+_` this replaced matched intraword, so a tool-result name like
+// `ANALYTICS_ROOT_KEY_SEED` rendered as `ANALYTICS<em>ROOT</em>KEY_SEED`.
+// `*` stays permissive — CommonMark allows intraword `*` emphasis.
+const UNDERSCORE_EM = String.raw `(?<![\p{L}\p{N}_])_(?![\s_])(?:[^_]|_(?=[\p{L}\p{N}]))+?(?<!\s)_(?![\p{L}\p{N}_])`;
+// `[label](url)`: the URL may hold one level of balanced parentheses (`Foo_(bar)`), and the whole
+// link may itself sit inside parentheses (`([edit](/admin/pages/x))`) — the outer `)` is left as text.
+const MD_LINK = String.raw `\[[^\]\n]+\]\((?:[^()\s]|\([^()\s]*\))+\)`;
+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;
+// Off-site links open in a new tab; a same-origin path stays in the tab so the host's in-app link
+// interceptor (an SPA router) can take it without a reload.
+const OFFSITE_LINK_HREF = /^(?:https?:|mailto:)/iu;
+function renderMarkdownLink(source, key) {
+    // `MD_LINK` already matched `source`, so these two groups always capture.
+    const [, label, href] = MD_LINK_PARTS.exec(source);
+    if (!SAFE_LINK_HREF.test(href))
+        return source;
+    const offsite = OFFSITE_LINK_HREF.test(href);
+    return (_jsx("a", { href: href, ...(offsite ? { target: '_blank', rel: 'noreferrer' } : {}), children: renderInline(label) }, key));
+}
 function renderInline(text) {
     const nodes = [];
     let lastIndex = 0;
     let key = 0;
-    let match = INLINE_RE.exec(text);
+    // A fresh copy per call, not the shared `g` regex: a link label recurses into this function
+    // mid-loop, and a shared `lastIndex` would be reset under the outer scan.
+    const inlineRe = new RegExp(INLINE_RE);
+    let match = inlineRe.exec(text);
     while (match !== null) {
         if (match.index > lastIndex)
             nodes.push(text.slice(lastIndex, match.index));
-        const [whole, code, bold, italic, link] = match;
+        const [whole, code, mdLink, bold, italic, link] = match;
         if (code)
             nodes.push(_jsx("code", { children: code.slice(1, -1) }, key++));
+        else if (mdLink)
+            nodes.push(renderMarkdownLink(mdLink, key++));
         else if (bold)
             nodes.push(_jsx("strong", { children: bold.slice(2, -2) }, key++));
         else if (italic)
@@ -395,7 +426,7 @@ function renderInline(text) {
         // defined (if possibly empty) full-match string at index 0, so this
         // fallback is unreachable (same dead-fallback reasoning as above).
         lastIndex = match.index + whole.length;
-        match = INLINE_RE.exec(text);
+        match = inlineRe.exec(text);
     }
     if (lastIndex < text.length)
         nodes.push(text.slice(lastIndex));

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

@@ -5,7 +5,7 @@
  * "transport-agnostic hooks never touch DOM" contract.
  */
 import { useEffect, useRef } from 'react';
-import { isScrolledToBottom, startsNewTurn } from './MessageList.rules.js';
+import { nextStickToBottom, startsNewTurn } from './MessageList.rules.js';
 export function useMessageListAutoScroll({ messages, scrollIntent }, { onScrolled } = {}) {
     const containerRef = useRef(null);
     // Whether the transcript was scrolled to its bottom as of the last user scroll or programmatic
@@ -14,6 +14,10 @@ export function useMessageListAutoScroll({ messages, scrollIntent }, { onScrolle
     // Starts true: a freshly mounted pane opens on the latest turn, same as scrollIntent's own default.
     const stickToBottomRef = useRef(true);
     const previousMessagesRef = useRef(messages);
+    // `scrollTop` at the previous `scroll` event — `nextStickToBottom` needs the direction of travel.
+    // Only scroll events write it (a browser fires one for programmatic scrolls too). Starts at
+    // Infinity, "no position seen yet", so a first event away from the bottom unsticks as it always did.
+    const lastScrollTopRef = useRef(Number.POSITIVE_INFINITY);
     // Runs BEFORE the scroll effect below (effects run in declaration order), so a send re-sticks in
     // time for that same commit's scroll. The user's own send (or retry) is an explicit "take me to
     // the latest turn": without this, a user who had scrolled up to read history and then sent stayed
@@ -69,7 +73,9 @@ export function useMessageListAutoScroll({ messages, scrollIntent }, { onScrolle
         return () => observer.disconnect();
     }, [messages]);
     const onScroll = (event) => {
-        stickToBottomRef.current = isScrolledToBottom(event.currentTarget);
+        const el = event.currentTarget;
+        stickToBottomRef.current = nextStickToBottom(el, { wasSticking: stickToBottomRef.current, previousScrollTop: lastScrollTopRef.current });
+        lastScrollTopRef.current = el.scrollTop;
     };
     return { containerRef, onScroll };
 }

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

@@ -11,6 +11,24 @@ export declare function isScrolledToBottom(el: {
     scrollTop: number;
     clientHeight: number;
 }): boolean;
+/**
+ * The sticky-follow flag after a `scroll` event.
+ *
+ * At the bottom always re-sticks. Otherwise only a move UP (the position went down since the last
+ * event) unsticks. A `scroll` event is dispatched a frame after the scroll that caused it, so the
+ * event for an auto-scroll can arrive after more streamed rows already grew the content: the
+ * position is unchanged but no longer at the bottom. Reading that as "the user scrolled away" is
+ * what left a tool-heavy run's final reply below the fold (demo dry-run, 2026-10-05). Content growth
+ * never lowers `scrollTop`; a user scrolling up always does.
+ */
+export declare function nextStickToBottom(el: {
+    scrollHeight: number;
+    scrollTop: number;
+    clientHeight: number;
+}, { wasSticking, previousScrollTop }: {
+    wasSticking: boolean;
+    previousScrollTop: number;
+}): boolean;
 /**
  * Whether `next` starts a turn the user themself asked for, relative to `previous`: a user message
  * that was not there before (a send — `useConversation.sendMessage` appends it optimistically), or

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

@@ -4,6 +4,21 @@ export const AT_BOTTOM_THRESHOLD_PX = 4;
 export function isScrolledToBottom(el) {
     return el.scrollHeight - el.scrollTop - el.clientHeight <= AT_BOTTOM_THRESHOLD_PX;
 }
+/**
+ * The sticky-follow flag after a `scroll` event.
+ *
+ * At the bottom always re-sticks. Otherwise only a move UP (the position went down since the last
+ * event) unsticks. A `scroll` event is dispatched a frame after the scroll that caused it, so the
+ * event for an auto-scroll can arrive after more streamed rows already grew the content: the
+ * position is unchanged but no longer at the bottom. Reading that as "the user scrolled away" is
+ * what left a tool-heavy run's final reply below the fold (demo dry-run, 2026-10-05). Content growth
+ * never lowers `scrollTop`; a user scrolling up always does.
+ */
+export function nextStickToBottom(el, { wasSticking, previousScrollTop }) {
+    if (isScrolledToBottom(el))
+        return true;
+    return el.scrollTop < previousScrollTop ? false : wasSticking;
+}
 /**
  * Whether `next` starts a turn the user themself asked for, relative to `previous`: a user message
  * that was not there before (a send — `useConversation.sendMessage` appends it optimistically), or

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 { terminalMessageNotice, continuingRunNotice } from '../../core/durable-projection.js';
 /**
  * @module MessageRow
  *
@@ -50,7 +51,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * chunk stopped arriving.
  */
 import React, { useState } from 'react';
-import { isTerminalRunStatus, splitOnQuestionForms, stripArtifact } from '../../core/index.js';
+import { isAwaitingAnswer, isTerminalRunStatus, splitOnQuestionForms, stripArtifact } from '../../core/index.js';
 import { useToolTimeline } from '../hooks/useToolTimeline.js';
 import { useExtEventGroups } from '../hooks/useExtEventGroups.js';
 import { useCopyToClipboard } from '../hooks/useCopyToClipboard.js';
@@ -120,6 +121,23 @@ function UsageSummary({ usage }) {
         return null;
     return (_jsxs("div", { className: "jini-message-usage", children: [_jsx("span", { className: "jini-message-usage-dot", "aria-hidden": true, children: "\u25CF" }), t('Done'), " \u00B7 ", parts.join(' · ')] }));
 }
+function messageBlocks({ visibleContent, message, rows }, _optional = {}) {
+    // Interleaving is skipped outright when an artifact was stripped. `stripArtifact` operates on the
+    // whole string and trims, so the surviving text no longer lines up with the per-run offsets the
+    // event walk produces, and an artifact block could legitimately span a tool call. Rather than
+    // reason about partial overlaps, an artifact-bearing message keeps the flat layout — those
+    // messages are dominated by the artifact panel anyway, so the ordering matters least there.
+    if (visibleContent !== message.content)
+        return null;
+    return interleaveMessageBlocks({ events: message.events, content: message.content, rows }, { slotOf: (ev) => extEventSlot({ name: ev.name, data: ev.data }) });
+}
+function messageAwaitingAnswer({ runStreaming, runInProgress, events }, _optional = {}) {
+    return runStreaming === true && runInProgress && isAwaitingAnswer({ events });
+}
+function AssistantMessageFooter({ message, usageEvent, terminalNotice, pending, runInProgress, runStreaming, visibleContent }, _optional = {}) {
+    const t = useT();
+    return _jsxs(_Fragment, { children: [usageEvent ? _jsx(UsageSummary, { usage: usageEvent }) : 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) }) : null] });
+}
 /**
  * Quiet, icon-only copy affordance shared by the user- and assistant-message
  * action rows below. Delegates the actual clipboard write (and its
@@ -147,19 +165,14 @@ export function MessageRow({ message, runStreaming = false, runSucceeded = false
     if (message.role === 'user') {
         return (_jsxs("div", { className: "jini-message jini-message-user", "data-message-id": message.id, "data-agent-element": `chat-message-${message.id}`, "data-agent-role": "region", "data-agent-label": "A message from the user", children: [message.attachments && message.attachments.length > 0 ? (_jsx("div", { className: "jini-message-attachments", children: message.attachments.map((a) => (_jsx("button", { type: "button", className: "jini-message-attachment-chip", onClick: () => setOpenAttachment(a), title: t('Open {name}', { name: a.name }), "aria-label": t('Open {name}', { name: a.name }), children: renderAttachment ? renderAttachment(a) : a.name }, 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') }) }), openAttachment ? (_jsx(AttachmentPreviewModal, { attachment: openAttachment, onClose: () => setOpenAttachment(null) })) : null] }));
     }
+    const terminalNotice = terminalMessageNotice({ message }, {});
     const visibleContent = stripArtifact({ content: message.content });
     const segments = splitOnQuestionForms({ input: visibleContent });
     const usageEvent = message.events?.filter((ev) => ev.kind === 'usage').pop();
-    // Interleaving is skipped outright when an artifact was stripped. `stripArtifact` operates on the
-    // whole string and trims, so the surviving text no longer lines up with the per-run offsets the
-    // event walk produces, and an artifact block could legitimately span a tool call. Rather than
-    // reason about partial overlaps, an artifact-bearing message keeps the flat layout — those
-    // messages are dominated by the artifact panel anyway, so the ordering matters least there.
-    const blocks = visibleContent === message.content
-        ? interleaveMessageBlocks({ events: message.events, content: message.content, rows: timeline.rows }, { slotOf: (ev) => extEventSlot({ name: ev.name, data: ev.data }) })
-        : null;
+    const blocks = messageBlocks({ visibleContent, message, rows: timeline.rows }, {});
     const pending = isPendingWithNoContent(message, visibleContent, timeline.rows.length);
     const runInProgress = isRunInProgress(message.runStatus);
+    const awaitingAnswer = messageAwaitingAnswer({ runStreaming, runInProgress, events: message.events }, {});
     const renderToolCard = (row) => (_jsx(ToolCard, { use: row.use, result: row.result, runStreaming: runStreaming, runSucceeded: runSucceeded, ...(projectFileNames !== undefined ? { projectFileNames } : {}), ...(onRequestOpenFile !== undefined ? { onRequestOpenFile } : {}) }, row.id));
     const renderExtGroup = (group) => {
         const renderer = getExtEventRenderer({ name: group.name });
@@ -170,6 +183,7 @@ export function MessageRow({ message, runStreaming = false, runSucceeded = false
             events: group.events,
             runStreaming,
             runSucceeded,
+            awaitingAnswer,
             runId: message.runId,
             ...(group.call === undefined ? {} : { call: group.call }),
         });
@@ -195,7 +209,7 @@ export function MessageRow({ message, runStreaming = false, runSucceeded = false
                         return null;
                     return (_jsx("div", { className: "jini-message-ext-events", children: renderExtGroup(group) }, block.key));
                 })
-                : (_jsxs(_Fragment, { children: [segments.map((segment, i) => segment.kind === 'text' ? (segment.text.trim() ? (_jsx("div", { className: "jini-message-content", children: _jsx(Markdown, { children: segment.text }) }, i)) : null) : (_jsx(QuestionForm, { form: segment.form, interactive: questionFormInteractive, ...(questionFormSubmittedAnswers !== undefined ? { submittedAnswers: questionFormSubmittedAnswers } : {}), ...(onQuestionFormSubmit !== undefined ? { onSubmit: onQuestionFormSubmit } : {}) }, i))), timeline.rows.length > 0 ? (_jsx("div", { className: "jini-message-tools", children: timeline.rows.map(renderToolCard) })) : null, extGroups.length > 0 ? _jsx("div", { className: "jini-message-ext-events", children: extGroups.map(renderExtGroup) }) : null] })), usageEvent ? _jsx(UsageSummary, { usage: usageEvent }) : null, message.runStatus === 'failed' ? _jsx("div", { className: "jini-message-error", children: t('This turn failed.') }) : null, !pending && !runInProgress ? (_jsx("div", { className: "jini-message-actions jini-message-actions--assistant", children: _jsx(CopyMessageButton, { text: visibleContent, label: t('Copy message') }) })) : null, _jsx(RunActivityLine, { events: message.events, active: pending || (runStreaming === true && runInProgress) })] }));
+                : (_jsxs(_Fragment, { children: [segments.map((segment, i) => segment.kind === 'text' ? (segment.text.trim() ? (_jsx("div", { className: "jini-message-content", children: _jsx(Markdown, { children: segment.text }) }, i)) : null) : (_jsx(QuestionForm, { form: segment.form, interactive: questionFormInteractive, ...(questionFormSubmittedAnswers !== undefined ? { submittedAnswers: questionFormSubmittedAnswers } : {}), ...(onQuestionFormSubmit !== undefined ? { onSubmit: onQuestionFormSubmit } : {}) }, i))), timeline.rows.length > 0 ? (_jsx("div", { className: "jini-message-tools", children: timeline.rows.map(renderToolCard) })) : null, extGroups.length > 0 ? _jsx("div", { className: "jini-message-ext-events", children: extGroups.map(renderExtGroup) }) : null] })), _jsx(AssistantMessageFooter, { message, usageEvent, terminalNotice, pending, runInProgress, runStreaming, visibleContent })] }));
 }
 /**
  * The live "what is it doing" line under a running reply (see `core/run-activity.ts`). Replaces the
@@ -203,7 +217,8 @@ export function MessageRow({ message, runStreaming = false, runSucceeded = false
  * Kept a separate component so its one-second tick re-renders only this line, not the whole row.
  */
 function RunActivityLine({ events, active }) {
-    const label = useRunActivity({ events: events, active: active });
+    const activityLabel = useRunActivity({ events: events, active: active });
+    const label = 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.js

@@ -21,14 +21,13 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * generic rendering for it.
  */
 import { useState } from 'react';
-import { formatToolOutputForDisplay, isTodoWriteToolName, parseTodoWriteInput, toRenderProps } from '../../core/index.js';
+import { formatToolOutputForDisplay, isDelegatedWrapperToolName, isTodoWriteToolName, parseTodoWriteInput, toRenderProps } from '../../core/index.js';
 import { useT } from '../hooks/context.js';
 import { getToolRenderer } from '../tool-renderer-registry.js';
 import { Icon } from './Icon.js';
 import { TodoCard } from './TodoCard.js';
 /** 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_]*)+$/;
-const EXECUTE_DELEGATED_TOOL_NAMES = new Set(['execute_delegated_tool', 'mcp__jini__execute_delegated_tool']);
 const SEARCH_TOOLS_NAMES = new Set(['search_tools', 'mcp__jini__search_tools']);
 const DESCRIBE_TOOL_NAMES = new Set(['describe_tool', 'mcp__jini__describe_tool']);
 export function ToolCard({ use, result, runStreaming, runSucceeded, projectFileNames, onRequestOpenFile }) {
@@ -64,8 +63,12 @@ function renderToolCardBody(name, use, result, isStreaming, isSucceeded, fileCtx
     // action twice. Suppressed only on a *successful* result: a wrapper-level failure (a genuine
     // transport error, not a tool-execution failure — those come back as a normal 'completed' result
     // with status:'failed' inside it) has no matching canonical row to fall back on, so it must stay
-    // visible rather than disappear silently.
-    if (EXECUTE_DELEGATED_TOOL_NAMES.has(name) && result && !result.isError)
+    // visible rather than disappear silently. (A wrapper that failed AFTER the bridge emitted its
+    // canonical row — e.g. a 400 on a refused input — never reaches here when rendered through
+    // `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 }) && result && !result.isError)
         return null;
     if (isTodoWriteToolName({ name: name }))
         return _jsx(TodoCard, { todos: parseTodoWriteInput({ input: use.input }), runStreaming: isStreaming });
@@ -85,7 +88,7 @@ function renderToolCardBody(name, use, result, isStreaming, isSucceeded, fileCtx
         return _jsx(WebFetchCard, { input: use.input, result: result, runStreaming: isStreaming, runSucceeded: isSucceeded });
     if (name === 'WebSearch' || name === 'web_search')
         return _jsx(WebSearchCard, { input: use.input, result: result, runStreaming: isStreaming, runSucceeded: isSucceeded });
-    if (JINI_TOOL_ID_PATTERN.test(name) || EXECUTE_DELEGATED_TOOL_NAMES.has(name)) {
+    if (JINI_TOOL_ID_PATTERN.test(name) || isDelegatedWrapperToolName({ name: name })) {
         // The unsuppressed (failed-wrapper) case falls through here too: `name` is still
         // `execute_delegated_tool`, so `jiniToolIdFromInput` recovers the real id from
         // `{toolId, input}` instead of `DelegatedToolCard` receiving its own wrapper name as the title.
@@ -133,8 +136,8 @@ function DelegatedToolCard({ name, input, result, runStreaming, runSucceeded })
     // 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 = EXECUTE_DELEGATED_TOOL_NAMES.has(name) ? (wrapper.toolId ?? name) : name;
-    const args = EXECUTE_DELEGATED_TOOL_NAMES.has(name) ? wrapper.input : 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 (_jsxs("div", { className: "op-card op-jini-tool", children: [_jsxs("button", { type: "button", className: "op-card-head", onClick: () => setOpen((o) => !o), children: [_jsx(ResultBadge, { result: result, runStreaming: runStreaming, runSucceeded: runSucceeded }), _jsxs("span", { className: `op-title${isRunning ? ' shimmer-text' : ''}`, children: [t('Tool call'), " \u00B7 ", humanizeToolId(toolId)] }), target ? _jsx("span", { className: "op-meta", children: target }) : null, _jsx("span", { className: "op-expand-chev", "aria-hidden": true, children: _jsx(Icon, { name: open ? 'chevron-down' : 'chevron-right', size: 11 }) })] }), _jsx("div", { className: `accordion-collapsible${open ? ' open' : ''}`, children: _jsx("div", { className: "accordion-collapsible-inner", children: _jsxs("div", { className: "op-card-detail", children: [_jsx("pre", { className: "op-command", children: JSON.stringify(args ?? {}) }), result?.content ? _jsx("pre", { className: "op-output", children: truncate(formatToolOutputForDisplay({ text: result.content }), 2000) }) : null, _jsx(ToolResultMedia, { result: result })] }) }) }), _jsx(FileErrorDetail, { result: result })] }));

package/dist/react/ext-event-renderer-registry.d.ts

@@ -40,6 +40,13 @@ export interface ExtEventRenderProps {
     /** Whether the owning run is still streaming — more events with this `name` may still arrive. */
     runStreaming: boolean;
     runSucceeded: boolean;
+    /**
+     * Whether the owning run is waiting on the person — a card (form, confirm, sign-in) sits on a
+     * still-open tool call (`isAwaitingAnswer` in `core/run-activity.ts`). A "still working" notice
+     * should hide while this is true. Always `false` once the run stops streaming. Optional so a host
+     * that builds these props itself (tests, wrappers) keeps compiling; `MessageRow` always sets it.
+     */
+    awaitingAnswer?: boolean;
     /** The owning message's `ChatMessage.runId`, if known — a renderer that needs to send something back to this specific run (e.g. an A2UI action) needs this; omitted (`undefined`) for a message with no run association. */
     runId: string | undefined;
     /** See {@link ExtEventCall}. Absent when the group's first event arrived outside any tool call. */

package/dist/react/features/chat-pane/components/ChatPane.d.ts

@@ -6,5 +6,5 @@ import type { ChatPaneProps } from '../types.js';
  * @complexity Time/space: O(n) in rendered messages, agents, and suggestions.
  * @overallScore 100/100
  */
-export declare function ChatPane({ transport, agents: injectedAgents, runtimeAccess, runtimeStatusPollMs, title, variant, initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents, daemonOnline, executionMode, apiModeAvailable, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions, workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement, projectFileNames, uploadAttachments, attachmentAccept, disabled, runtimePickerPlacement, composerSlots, header, leadingAccessory, footer, className, style, }: ChatPaneProps): import("react").JSX.Element;
+export declare function ChatPane({ transport, agents: injectedAgents, runtimeAccess, runtimeStatusPollMs, title, variant, initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents, daemonOnline, executionMode, apiModeAvailable, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, composerHistoryScope, composerHistoryStorage, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions, workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement, projectFileNames, uploadAttachments, attachmentAccept, disabled, runtimePickerPlacement, composerSlots, header, leadingAccessory, footer, className, style, }: ChatPaneProps): import("react").JSX.Element;
 //# sourceMappingURL=ChatPane.d.ts.map

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

@@ -73,8 +73,8 @@ function ChatPaneNoUsableCliMessage({ executionMode, apiModeAvailable, onExecuti
 }
 /** The pane's stack of mutually-independent error/status banners — each condition is its own
  * source of truth, so they are rendered as siblings rather than folded into one derived state. */
-function ChatPaneStatusMessages({ unavailable, scanningAgents, connectingAgents, executionMode, apiModeAvailable, onExecutionModeChange, conversationError, attachmentError, dropReadError, workingDirectoryError, workingDirectoryPending, workingDirectoryInvalid, runtimeInventoryError, typedAnswerNotice, onSendAsNewMessage, t, }) {
-    return (_jsxs(_Fragment, { children: [unavailable && connectingAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Connecting to the assistant…') })) : unavailable && scanningAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Loading available CLIs') })) : unavailable ? (_jsx(ChatPaneNoUsableCliMessage, { executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, t: t })) : null, conversationError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: conversationError.message })) : null, attachmentError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: attachmentError.message })) : null, dropReadError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: dropReadError })) : null, workingDirectoryError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: workingDirectoryError.message })) : null, workingDirectoryPending ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Checking working directory…') })) : workingDirectoryInvalid ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: t('Working directory is unavailable.') })) : null, runtimeInventoryError && !connectingAgents ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: runtimeInventoryError.message })) : null, typedAnswerNotice ? (_jsxs("div", { className: "jini-chat-pane__error", role: "alert", children: [t(describeTypedAnswerNotice({ notice: typedAnswerNotice })), typedAnswerNotice === 'not-pending' ? (_jsxs(_Fragment, { children: [' ', _jsx("button", { type: "button", className: "jini-chat-pane__error-action", onClick: onSendAsNewMessage, children: t('Send as a new message') })] })) : null] })) : null] }));
+function ChatPaneStatusMessages({ unavailable, scanningAgents, connectingAgents, executionMode, apiModeAvailable, onExecutionModeChange, attachmentError, dropReadError, workingDirectoryError, workingDirectoryPending, workingDirectoryInvalid, runtimeInventoryError, typedAnswerNotice, onSendAsNewMessage, t, }) {
+    return (_jsxs(_Fragment, { children: [unavailable && connectingAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Connecting to the assistant…') })) : unavailable && scanningAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Loading available CLIs') })) : unavailable ? (_jsx(ChatPaneNoUsableCliMessage, { executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, t: t })) : null, attachmentError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: attachmentError.message })) : null, dropReadError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: dropReadError })) : null, workingDirectoryError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: workingDirectoryError.message })) : null, workingDirectoryPending ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Checking working directory…') })) : workingDirectoryInvalid ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: t('Working directory is unavailable.') })) : null, runtimeInventoryError && !connectingAgents ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: runtimeInventoryError.message })) : null, typedAnswerNotice ? (_jsxs("div", { className: "jini-chat-pane__error", role: "alert", children: [t(describeTypedAnswerNotice({ notice: typedAnswerNotice })), typedAnswerNotice === 'not-pending' ? (_jsxs(_Fragment, { children: [' ', _jsx("button", { type: "button", className: "jini-chat-pane__error-action", onClick: onSendAsNewMessage, children: t('Send as a new message') })] })) : null] })) : null] }));
 }
 function ChatPaneWorkingDirectoryBlock({ workingDirectoryAccess, workingDirectoryControlPlacement, pane, t, }) {
     if (workingDirectoryAccess && workingDirectoryControlPlacement === 'below') {
@@ -178,7 +178,7 @@ function ChatPaneComposerArea({ fileDrop, uploadAttachments, pane, disabled, una
  * @complexity Time/space: O(n) in rendered messages, agents, and suggestions.
  * @overallScore 100/100
  */
-export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, runtimeAccess, runtimeStatusPollMs = 5_000, title, variant = 'workspace', initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents = false, daemonOnline = true, executionMode = 'local', apiModeAvailable = false, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions = [], workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement = 'below', projectFileNames, uploadAttachments, attachmentAccept, disabled = false, runtimePickerPlacement = 'up', composerSlots, header, leadingAccessory, footer, className, style, }) {
+export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, runtimeAccess, runtimeStatusPollMs = 5_000, title, variant = 'workspace', initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents = false, daemonOnline = true, executionMode = 'local', apiModeAvailable = false, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, composerHistoryScope, composerHistoryStorage, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions = [], workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement = 'below', projectFileNames, uploadAttachments, attachmentAccept, disabled = false, runtimePickerPlacement = 'up', composerSlots, header, leadingAccessory, footer, className, style, }) {
     const t = useT();
     const composerPlaceholder = useChatPaneComposerPlaceholder({ placeholder: placeholder, placeholders: placeholders });
     const inventory = useChatPaneRuntimeInventory(definedProps({ source: {
@@ -201,6 +201,8 @@ export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, run
             onSelectionChange,
             runContext,
             initialDraft,
+            composerHistoryScope,
+            composerHistoryStorage,
             validateAttachments,
             uploadAttachments,
             onActivityChange,

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

@@ -1,6 +1,7 @@
 import { type ChatPaneSendBlocker } from '../rules.js';
 import type { ChatPaneActivity, ChatPaneAgent, ChatPaneAttachmentUploadOptions, ChatPaneAgentSelection, ChatPaneRunContext, ChatPaneWorkingDirectoryAccess, DeliverTypedAnswer, TypedAnswerNotice } from '../types.js';
 import type { ChatAttachment, ChatMessage } from '@jini-ai/chat';
+import type { ComposerHistoryStoragePort } from '../../../../core/composer-history.js';
 import type { ChatTransport } from '@jini-ai/chat';
 import { type UseComposerResult } from '../../../hooks/useComposer.js';
 import { type UseConversationResult } from '../../../hooks/useConversation.js';
@@ -15,6 +16,8 @@ export interface UseChatPaneOptions {
     onSelectionChange?: (selection: ChatPaneAgentSelection) => void;
     runContext?: ChatPaneRunContext;
     initialDraft?: string;
+    composerHistoryScope?: string;
+    composerHistoryStorage?: ComposerHistoryStoragePort;
     /** Forwarded verbatim to `useComposer`; see `validateAttachments` there for the contract. */
     validateAttachments?: (attachments: readonly ChatAttachment[]) => Promise<readonly ChatAttachment[]>;
     uploadAttachments?: (files: File[], options?: ChatPaneAttachmentUploadOptions) => Promise<ChatAttachment[]>;

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

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { describeChatPaneSendBlocker, findAwaitedTypedAnswerId, findChatPaneSendBlocker, isChatPaneQueueableBlocker, isTypedAnswerTurn, resolveChatPaneSelection, } from '../rules.js';
 import { definedProps } from '../../../util/defined-props.js';
 import { cacheAttachmentPreviewSource } from '../../../hooks/attachment-preview-cache.js';
+import { readCachedAttachmentBatchId, writeCachedAttachmentBatchId, } from '../../../hooks/composer-draft-cache.js';
 import { useComposer } from '../../../hooks/useComposer.js';
 import { useConversation, } from '../../../hooks/useConversation.js';
 import { useChatPaneWorkingDirectory, } from './useChatPaneWorkingDirectory.hooks.js';
@@ -96,7 +97,12 @@ export function useChatPane(options) {
     const queuedConversationIdRef = useRef(undefined);
     const mountedRef = useRef(true);
     const attachmentGenerationRef = useRef(0);
-    const attachmentBatchIdRef = useRef(createAttachmentBatchId());
+    // Every attachment staged for one turn must share one upload batch (the daemon refuses a turn
+    // spanning two). So a mount that will restore cached attachments starts in THEIR batch rather
+    // than a new one; see `readCachedAttachmentBatchId`.
+    const [initialAttachmentBatchId] = useState(() => readCachedAttachmentBatchId({ conversationId: options.conversationId }) ?? createAttachmentBatchId());
+    const attachmentBatchIdRef = useRef(initialAttachmentBatchId);
+    const batchConversationIdRef = useRef(options.conversationId);
     const activeUploadsRef = useRef(new Set());
     const [internalSelection, setInternalSelection] = useState(options.initialSelection ?? { agentId: '' });
     const workingDirectoryState = useChatPaneWorkingDirectory(definedProps({ source: {
@@ -108,12 +114,6 @@ export function useChatPane(options) {
     const requestedSelection = options.selection ?? internalSelection;
     const selection = useMemo(() => resolveChatPaneSelection({ agents: options.agents, requested: requestedSelection }), [options.agents, requestedSelection]);
     const selectedAgent = options.agents.find((agent) => agent.id === selection.agentId);
-    const composer = useComposer(definedProps({ source: {
-            initialDraft: options.initialDraft,
-            initialAgent: selection,
-            conversationId: options.conversationId,
-            validateAttachments: options.validateAttachments,
-        } }));
     const conversation = useConversation(definedProps({ source: {
             transport: options.transport,
             initialMessages: options.initialMessages,
@@ -122,6 +122,15 @@ export function useChatPane(options) {
             // absent), so only the falsy "no agent selected" case should omit the key.
             agentId: selection.agentId || undefined,
         } }));
+    const composer = useComposer(definedProps({ source: {
+            initialDraft: options.initialDraft,
+            historyMessages: conversation.messages,
+            historyScope: options.composerHistoryScope,
+            historyStorage: options.composerHistoryStorage,
+            initialAgent: selection,
+            conversationId: options.conversationId,
+            validateAttachments: options.validateAttachments,
+        } }));
     const activity = resolveChatPaneActivity(selectedAgent, conversation);
     useEffect(() => {
         options.onActivityChange?.(activity);
@@ -199,10 +208,31 @@ export function useChatPane(options) {
         typedAnswerGenerationRef.current += 1;
         heldAnswerQuestionIdRef.current = null;
     }, [options.conversationId]);
+    // A conversation switch without a remount: adopt the batch of the attachments the composer is
+    // about to restore for the new conversation, else start a fresh one so two conversations never
+    // share a batch directory (the agent is granted the whole directory, not just the claimed files).
+    // An id arriving where there was none is the same conversation finally getting a key — the
+    // composer keeps what is staged (see `useComposer`), so the batch stays too.
+    useEffect(() => {
+        const previousConversationId = batchConversationIdRef.current;
+        if (options.conversationId === previousConversationId)
+            return;
+        batchConversationIdRef.current = options.conversationId;
+        const restoredBatchId = readCachedAttachmentBatchId({ conversationId: options.conversationId });
+        if (restoredBatchId !== null) {
+            attachmentBatchIdRef.current = restoredBatchId;
+            return;
+        }
+        if (previousConversationId == null)
+            return;
+        attachmentBatchIdRef.current = createAttachmentBatchId();
+    }, [options.conversationId]);
     const addAttachments = useCallback(async (files) => {
         if (files.length === 0 || options.uploadAttachments === undefined)
             return;
         const generation = attachmentGenerationRef.current;
+        const batchId = attachmentBatchIdRef.current;
+        const conversationId = options.conversationId;
         const controller = new AbortController();
         activeUploadsRef.current.add(controller);
         setActiveUploadCount(activeUploadsRef.current.size);
@@ -211,7 +241,7 @@ export function useChatPane(options) {
             await uploadAttachmentBatch(files, {
                 upload: options.uploadAttachments,
                 signal: controller.signal,
-                batchId: attachmentBatchIdRef.current,
+                batchId,
                 stillWanted: () => mountedRef.current
                     && !controller.signal.aborted
                     && generation === attachmentGenerationRef.current,
@@ -221,6 +251,9 @@ export function useChatPane(options) {
                 // `attachment-preview-cache.ts`'s module doc for why this is the only place that copy can
                 // ever be captured.
                 onAttachment: (attachment, file) => {
+                    // Recorded before staging so the cache entry that persists this attachment carries its
+                    // batch, which is what lets a later mount restore the batch along with the attachment.
+                    writeCachedAttachmentBatchId({ conversationId, batchId });
                     composer.addAttachment(attachment);
                     if (file)
                         cacheAttachmentPreviewSource({ path: attachment.path, file });
@@ -233,7 +266,7 @@ export function useChatPane(options) {
                 setActiveUploadCount(activeUploadsRef.current.size);
             }
         }
-    }, [composer, options.uploadAttachments]);
+    }, [composer, options.conversationId, options.uploadAttachments]);
     const sendPrompt = useCallback(async (prompt) => {
         const trimmed = prompt.trim();
         if (!trimmed)

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

@@ -83,9 +83,12 @@ export declare function isChatPaneQueueableBlocker({ blocker }: {
  * Only the question tool counts. Other tools park on cards too — a delete confirm, an approval —
  * but they take no typed answer: the server routes typed text only to the question tool, so treating
  * those as waiting would refuse the text with "no longer waiting" and drop it instead of queueing.
- * A call is the question tool when ANY `tool_use` for its id names it, since a vendor's wrapper row
- * (`execute_delegated_tool`) and the daemon's canonical row share the id and may arrive in either
- * order.
+ * A call is the question tool when ANY `tool_use` for its id names it, since the same call's
+ * `tool_use` can arrive more than once (the CLI re-emits it). A vendor's wrapper row
+ * (`execute_delegated_tool`) and the daemon's canonical row do NOT share an id — the wrapper carries
+ * the CLI's `toolu_…` id and the canonical row a fresh UUID from `@jini-ai/mcp`. The canonical row
+ * opens after its wrapper, so it is the newest open call when the surface arrives, and that is
+ * what attributes the surface to the question tool.
  *
  * A surface is attributed to the newest call still open when it arrived — the same rule
  * `useExtEventGroups` uses to give a card its `call` — so an older call returning does not settle

package/dist/react/features/chat-pane/rules.js

@@ -116,9 +116,12 @@ export function isChatPaneQueueableBlocker({ blocker }) {
  * Only the question tool counts. Other tools park on cards too — a delete confirm, an approval —
  * but they take no typed answer: the server routes typed text only to the question tool, so treating
  * those as waiting would refuse the text with "no longer waiting" and drop it instead of queueing.
- * A call is the question tool when ANY `tool_use` for its id names it, since a vendor's wrapper row
- * (`execute_delegated_tool`) and the daemon's canonical row share the id and may arrive in either
- * order.
+ * A call is the question tool when ANY `tool_use` for its id names it, since the same call's
+ * `tool_use` can arrive more than once (the CLI re-emits it). A vendor's wrapper row
+ * (`execute_delegated_tool`) and the daemon's canonical row do NOT share an id — the wrapper carries
+ * the CLI's `toolu_…` id and the canonical row a fresh UUID from `@jini-ai/mcp`. The canonical row
+ * opens after its wrapper, so it is the newest open call when the surface arrives, and that is
+ * what attributes the surface to the question tool.
  *
  * A surface is attributed to the newest call still open when it arrived — the same rule
  * `useExtEventGroups` uses to give a card its `call` — so an older call returning does not settle

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

@@ -1,6 +1,7 @@
 import type { CSSProperties, ReactNode, RefObject } from 'react';
 import type { ChatAttachment, ChatMessage } from '@jini-ai/chat';
 import type { ComposerSlots } from '../../slots.js';
+import type { ComposerHistoryStoragePort } from '../../../core/composer-history.js';
 import type { ChatTransport, RunContext } from '@jini-ai/chat';
 export interface ChatPaneAgentOption {
     id: string;
@@ -172,6 +173,10 @@ export interface ChatPaneProps {
     /** Passed straight through to the runtime picker. */
     onByokModelChange?: (model: string) => void;
     initialDraft?: string;
+    /** Principal-scoped recent prompt recall; defaults to the origin-local default scope. */
+    composerHistoryScope?: string;
+    /** Optional storage effects; omitted uses bounded browser storage with memory fallback. */
+    composerHistoryStorage?: ComposerHistoryStoragePort;
     /**
      * Confirms which previously staged attachments still exist, so a draft restored after a reload
      * never shows a chip for a file the backend has since garbage-collected — that looks intact and

package/dist/react/hooks/composer-draft-cache.d.ts

@@ -115,6 +115,34 @@ export declare function clearCachedDraft({ conversationId }: {
 export declare function readCachedAttachments({ conversationId }: {
     conversationId: string | null | undefined;
 }): readonly ChatAttachment[] | null;
+/**
+ * The upload batch `conversationId`'s cached attachments were uploaded under, so a pane that
+ * restores those attachments uploads the next file into the SAME batch.
+ *
+ * Why this exists: the daemon grants the agent exactly one batch directory per turn and refuses a
+ * turn whose attachments span two ("Attachments must belong to one batch"). A pane that restored an
+ * attachment after a remount, reload, or conversation switch used to upload the next file under a
+ * brand-new batch id, so every such turn failed before the agent started (2026-10-06).
+ *
+ * @returns The batch id, or `null` when there are no cached attachments to stay consistent with
+ * (none staged, attachment persistence off because the host supplied no validator, or an entry
+ * written before batch ids were recorded) — the caller then starts a fresh batch.
+ * @complexity Time/space: O(1) on an in-memory hit, O(n) in the stored count otherwise.
+ */
+export declare function readCachedAttachmentBatchId({ conversationId }: {
+    conversationId: string | null | undefined;
+}): string | null;
+/**
+ * Records the upload batch of an attachment about to be staged in `conversationId`'s composer.
+ * Memory only: the stored envelope picks it up on the {@link writeCachedAttachments} that persists
+ * that attachment, so it is never written ahead of the references it describes.
+ *
+ * @complexity Time/space: O(1) amortized.
+ */
+export declare function writeCachedAttachmentBatchId({ conversationId, batchId }: {
+    conversationId: string | null | undefined;
+    batchId: string;
+}): void;
 /**
  * Stores `attachments` for `conversationId` in both tiers.
  *