@jini-ai/chat 0.5.1 → 0.5.3

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/McpUiSurfaceCard.d.ts

@@ -1,5 +1,6 @@
 import { type McpUiToolCallHandler } from '@jini-ai/ui/mcp-ui';
 import { type ExtEventRenderProps } from '../ext-event-renderer-registry.js';
+import { type SurfaceExpiryClock } from '../hooks/useSurfaceExpiry.js';
 /** The `kind: 'ext'` event name this renderer claims. */
 export declare const MCP_UI_EXT_EVENT_NAME = "mcp-ui";
 export interface McpUiSurfaceCardProps extends ExtEventRenderProps {
@@ -22,9 +23,14 @@ export interface McpUiSurfaceCardProps extends ExtEventRenderProps {
      * a fixed-width sidebar should pass a cap sized to its own viewport.
      */
     maxHeight?: number;
+    /**
+     * Time source for a card's answer deadline (`MCP_UI_EXPIRES_AT_META_KEY`). Omit for the wall clock;
+     * a test injects a fake one to step through the countdown.
+     */
+    expiryClock?: SurfaceExpiryClock;
 }
 /** Registered against `ext-event-renderer-registry.ts`'s `'mcp-ui'` name — see module doc. */
-export declare function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLink, maxHeight, call, runStreaming }: McpUiSurfaceCardProps): import("react").JSX.Element;
+export declare function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLink, maxHeight, call, runStreaming, expiryClock }: McpUiSurfaceCardProps): import("react").JSX.Element;
 /**
  * The ext-event slot key for MCP-UI: one slot per `ui://` URI. Each resource is its own card, so a
  * run's second card renders where it arrived instead of inside the first card's slot, while a

package/dist/react/components/McpUiSurfaceCard.js

@@ -62,9 +62,11 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * against the real driver in `@jini-ai/agentic`.
  */
 import { Fragment, useMemo } from 'react';
-import { McpUiHost, parseUIResource, readActionPlan, readPreferredFrameSize, } from '@jini-ai/ui/mcp-ui';
+import { McpUiHost, parseUIResource, readActionPlan, readExpiresAt, readPreferredFrameSize, } from '@jini-ai/ui/mcp-ui';
 import { registerExtEventRenderer } from '../ext-event-renderer-registry.js';
 import { useT } from '../hooks/context.js';
+import { useSurfaceExpiry } from '../hooks/useSurfaceExpiry.js';
+import { closedSurfaceLabel } from './mcp-ui-surface-state.js';
 /** The `kind: 'ext'` event name this renderer claims. */
 export const MCP_UI_EXT_EVENT_NAME = 'mcp-ui';
 /** Collapses the event stream to the newest resource per `ui://` URI, in first-appearance order. */
@@ -112,39 +114,22 @@ function pendingMirrorLabel(t, plan) {
 function PendingSurfaceMirror({ uri, plan, t }) {
     return (_jsx("div", { "aria-hidden": "true", style: { display: 'none' }, "data-agent-element": pendingMirrorHandle(uri), "data-agent-role": "status", "data-agent-label": pendingMirrorLabel(t, plan) }));
 }
-/** Words in a finished call's result that mean nobody answered in time. */
-const UNANSWERED_RESULT = /\b(expired|abandoned|did not respond|run ended)\b/i;
-/**
- * Why a card can no longer be answered, or `undefined` while it still can.
- *
- * A held-open question (the tool shows the card and waits) is over once its tool call returns, and
- * dead once its run ends without that return. Its first document stays on screen either way, so
- * without this an expired, answered or orphaned question still looked answerable (host stuck-chat
- * investigation, 2026-09-27). Only a card still showing that FIRST document closes: a tool that sent
- * a follow-up document for the same `ui://` URI (an outcome after the answer) keeps showing it.
- *
- * The labels are read from the call's result text, so they are a best guess for a producer this
- * package has not seen; the card is closed either way, which is the property that matters.
- */
-function closedLabel(t, call, runStreaming, documentsForUri) {
-    if (call === undefined || documentsForUri > 1)
-        return undefined;
-    if (call.result === undefined)
-        return runStreaming ? undefined : t('This question expired');
-    return UNANSWERED_RESULT.test(call.result.content) ? t('This question expired') : t('Answered');
-}
 /** A closed card: the question's title, when the call gave one, and why it is closed. */
 function ClosedSurface({ call, label }) {
     const title = call?.input?.title;
     return (_jsx("div", { className: "mcpui-surface-card mcpui-surface-card-closed", role: "status", children: typeof title === 'string' && title.trim() !== '' ? `${title}: ${label}` : label }));
 }
 /** Registered against `ext-event-renderer-registry.ts`'s `'mcp-ui'` name — see module doc. */
-export function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLink, maxHeight, call, runStreaming }) {
+export function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLink, maxHeight, call, runStreaming, expiryClock }) {
     const t = useT();
     const resources = useMemo(() => latestResourcesByUri(events), [events]);
     // One card per slot is the registered shape (`mcpUiSurfaceSlotKey`), so `call` belongs to exactly
     // that card. A group holding several URIs has no single call to judge them by, and stays live.
-    const closed = resources.length === 1 ? closedLabel(t, call, runStreaming, events.length) : undefined;
+    const single = resources.length === 1 ? resources[0] : undefined;
+    const expiry = useSurfaceExpiry({ expiresAtMs: single === undefined ? undefined : readExpiresAt(single) }, expiryClock === undefined ? {} : { clock: expiryClock });
+    const closed = single === undefined
+        ? undefined
+        : closedSurfaceLabel({ t, call, runStreaming, documentsForUri: events.length, expired: expiry?.expired === true });
     if (closed !== undefined)
         return _jsx(ClosedSurface, { call: call, label: closed });
     if (resources.length === 0) {
@@ -153,20 +138,20 @@ export function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLi
         // looks like an ordinary empty turn.
         return (_jsx("div", { className: "mcpui-surface-card mcpui-surface-card-empty", role: "status", children: t('This MCP-UI event carried no renderable resource.') }));
     }
-    return (_jsx("div", { className: "mcpui-surface-card", children: resources.map((resource) => {
-            const preferred = readPreferredFrameSize(resource);
-            const height = preferred === undefined ? undefined : Number.parseInt(preferred[1], 10);
-            const plan = readActionPlan(resource);
-            return (_jsxs(Fragment, { children: [_jsx(McpUiHost, { title: resource.resource.uri, html: resource.resource.text, sandboxProxyUrl: sandboxProxyUrl, toolName: resource.resource.uri, 
-                        // The whole document, not its LENGTH. `useMcpUiHost` already defaults `sessionKey` to
-                        // `html` — exact by construction — and this override replaced that with a digest so
-                        // coarse that any two documents of equal size under one URI collided: a genuine update
-                        // (a re-rendered dialog with the same-length body, a swapped confirmation token) reused
-                        // the previous iframe session, so the handshake never re-ran and the frame kept serving
-                        // the OLD document's state. The URI stays in the key because it is real identity; the
-                        // length was never a substitute for content.
-                        sessionKey: `${resource.resource.uri}:${resource.resource.text}`, ...(onToolCall === undefined ? {} : { onToolCall }), ...(onOpenLink === undefined ? {} : { onOpenLink }), ...(height === undefined || Number.isNaN(height) ? {} : { initialHeight: height }), ...(maxHeight === undefined ? {} : { maxHeight }) }), plan !== undefined && _jsx(PendingSurfaceMirror, { uri: resource.resource.uri, plan: plan, t: t })] }, resource.resource.uri));
-        }) }));
+    return (_jsxs("div", { className: "mcpui-surface-card", children: [resources.map((resource) => {
+                const preferred = readPreferredFrameSize(resource);
+                const height = preferred === undefined ? undefined : Number.parseInt(preferred[1], 10);
+                const plan = readActionPlan(resource);
+                return (_jsxs(Fragment, { children: [_jsx(McpUiHost, { title: resource.resource.uri, html: resource.resource.text, sandboxProxyUrl: sandboxProxyUrl, toolName: resource.resource.uri, 
+                            // The whole document, not its LENGTH. `useMcpUiHost` already defaults `sessionKey` to
+                            // `html` — exact by construction — and this override replaced that with a digest so
+                            // coarse that any two documents of equal size under one URI collided: a genuine update
+                            // (a re-rendered dialog with the same-length body, a swapped confirmation token) reused
+                            // the previous iframe session, so the handshake never re-ran and the frame kept serving
+                            // the OLD document's state. The URI stays in the key because it is real identity; the
+                            // length was never a substitute for content.
+                            sessionKey: `${resource.resource.uri}:${resource.resource.text}`, ...(onToolCall === undefined ? {} : { onToolCall }), ...(onOpenLink === undefined ? {} : { onOpenLink }), ...(height === undefined || Number.isNaN(height) ? {} : { initialHeight: height }), ...(maxHeight === undefined ? {} : { maxHeight }) }), plan !== undefined && _jsx(PendingSurfaceMirror, { uri: resource.resource.uri, plan: plan, t: t })] }, resource.resource.uri));
+            }), expiry?.expired === false && (_jsx("p", { className: "mcpui-surface-expiry", role: "timer", children: t('Expires in {time}', { time: expiry.remaining }) }))] }));
 }
 /**
  * The ext-event slot key for MCP-UI: one slot per `ui://` URI. Each resource is its own card, so a

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

@@ -1,3 +1,14 @@
+/**
+ * @module MessageList
+ *
+ * Renders a conversation's messages via `<MessageRow>`, and — matching
+ * `useConversation`'s `scrollIntent` flag (see
+ * `ADS-memory/reports/jini-port/recon/r4b-webui-design.md` §4: "message array, optimistic
+ * user message, scroll-intent flag") — auto-scrolls to the newest content
+ * whenever `scrollIntent` is true, calling `onScrolled` once it has. The
+ * scroll-anchoring state lives in `useMessageListAutoScroll`
+ * (`MessageList.hooks.ts`); see that file for why it is presentational.
+ */
 import type { ChatMessage } from '../../core/index.js';
 import { type MessageRowProps } from './MessageRow.js';
 export interface MessageListProps extends Pick<MessageRowProps, 'projectFileNames' | 'onRequestOpenFile' | 'renderAttachment'> {

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

@@ -0,0 +1,19 @@
+/**
+ * @file `MessageList`'s scroll-anchoring state, split out of the component per this package's
+ * hooks-file convention (see `AttachmentPreviewModal.hooks.ts`). Pure DOM scroll-anchoring via a ref
+ * lives here (presentational), not in the headless `useConversation` hook, per that hook's own
+ * "transport-agnostic hooks never touch DOM" contract.
+ */
+import { type RefObject, type UIEvent } from 'react';
+import type { ChatMessage } from '../../core/index.js';
+export interface MessageListAutoScroll {
+    containerRef: RefObject<HTMLDivElement | null>;
+    onScroll: (event: UIEvent<HTMLElement>) => void;
+}
+export declare function useMessageListAutoScroll({ messages, scrollIntent }: {
+    messages: ChatMessage[];
+    scrollIntent: boolean;
+}, { onScrolled }?: {
+    onScrolled?: () => void;
+}): MessageListAutoScroll;
+//# sourceMappingURL=MessageList.hooks.d.ts.map

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

@@ -0,0 +1,82 @@
+/**
+ * @file `MessageList`'s scroll-anchoring state, split out of the component per this package's
+ * hooks-file convention (see `AttachmentPreviewModal.hooks.ts`). Pure DOM scroll-anchoring via a ref
+ * lives here (presentational), not in the headless `useConversation` hook, per that hook's own
+ * "transport-agnostic hooks never touch DOM" contract.
+ */
+import { useEffect, useRef } from 'react';
+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
+    // scroll-to-bottom — read by the ResizeObserver effect below, which only ever sees the DOM AFTER a
+    // resize already happened and so cannot recompute "was this at the bottom" from current values.
+    // 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
+    // parked up there, because the stick gate below — correct for streamed chatter — also swallowed
+    // their own send (owner-reported "Chat auto-scroll still sticks", todos audit 2026-10-04).
+    useEffect(() => {
+        if (startsNewTurn({ previous: previousMessagesRef.current, next: messages })) {
+            stickToBottomRef.current = true;
+        }
+        previousMessagesRef.current = messages;
+    }, [messages]);
+    useEffect(() => {
+        if (!scrollIntent)
+            return;
+        const el = containerRef.current;
+        // Gated on `stickToBottomRef`, same as the ResizeObserver effect below: `scrollIntent` turns
+        // true on EVERY streamed event (tool-call chatter included, not just a finished reply — see
+        // `useConversation.applyRunToAssistantMessage`), so scrolling unconditionally here yanked a user
+        // who had deliberately scrolled up to read history back to the bottom on the very next chunk
+        // (owner-reported, 2026-08-30). `stickToBottomRef` already reflects the user's own last scroll
+        // gesture via the `onScroll` handler below, captured BEFORE this content change, so it is safe
+        // to trust here.
+        if (el && stickToBottomRef.current) {
+            el.scrollTop = el.scrollHeight;
+        }
+        onScrolled?.();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [scrollIntent, messages]);
+    // Re-sticks to the bottom when a message ROW grows after mount with no accompanying `messages`
+    // change — the exact case an embedded MCP-UI/A2UI surface hits: it mounts at an initial guessed
+    // height (`preferredFrameSize` or `DEFAULT_INITIAL_HEIGHT`), then reports its real, often much
+    // taller content height asynchronously via `ui/notifications/size-changed`, entirely inside that
+    // surface's own React state (`McpUiHost`). The effect above never re-runs for that, so without this
+    // a surface which grows after the one-shot scroll leaves its own action buttons — or, once it
+    // resolves, the assistant's next reply — below the stale "bottom" with nothing to bring them back
+    // into view. Observes each direct child (one per message row) rather than the scroll container
+    // itself: the container's own box is held fixed by its flex/overflow layout, so only its CONTENT
+    // grows, which `ResizeObserver` only reports for the element whose box is actually changing.
+    // Re-created per `messages` change so a newly mounted row is observed too. Gated on
+    // `stickToBottomRef` so a human who scrolled up to read history is never yanked back down by an
+    // unrelated row resizing elsewhere in the transcript.
+    useEffect(() => {
+        const el = containerRef.current;
+        if (!el || typeof ResizeObserver !== 'function')
+            return;
+        const observer = new ResizeObserver(() => {
+            if (!stickToBottomRef.current)
+                return;
+            el.scrollTop = el.scrollHeight;
+        });
+        for (const child of Array.from(el.children))
+            observer.observe(child);
+        return () => observer.disconnect();
+    }, [messages]);
+    const onScroll = (event) => {
+        const el = event.currentTarget;
+        stickToBottomRef.current = nextStickToBottom(el, { wasSticking: stickToBottomRef.current, previousScrollTop: lastScrollTopRef.current });
+        lastScrollTopRef.current = el.scrollTop;
+    };
+    return { containerRef, onScroll };
+}
+//# sourceMappingURL=MessageList.hooks.js.map

package/dist/react/components/MessageList.js

@@ -1,80 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * @module MessageList
- *
- * Renders a conversation's messages via `<MessageRow>`, and — matching
- * `useConversation`'s `scrollIntent` flag (see
- * `ADS-memory/reports/jini-port/recon/r4b-webui-design.md` §4: "message array, optimistic
- * user message, scroll-intent flag") — auto-scrolls to the newest content
- * whenever `scrollIntent` is true, calling `onScrolled` once it has. Pure
- * DOM scroll-anchoring via a ref lives here (a presentational component),
- * not in the headless `useConversation` hook, per that hook's own
- * "transport-agnostic hooks never touch DOM" contract.
- */
-import { useEffect, useRef } from 'react';
 import { isTerminalRunStatus } from '../../core/index.js';
 import { useT } from '../hooks/context.js';
+import { useMessageListAutoScroll } from './MessageList.hooks.js';
 import { MessageRow } from './MessageRow.js';
-/** Slack, in px, for treating "close enough to the bottom" as "at the bottom" — a fractional
- * scrollHeight/clientHeight rounding difference should not by itself stop the sticky-follow below. */
-const AT_BOTTOM_THRESHOLD_PX = 4;
-function isScrolledToBottom(el) {
-    return el.scrollHeight - el.scrollTop - el.clientHeight <= AT_BOTTOM_THRESHOLD_PX;
-}
 export function MessageList({ messages, isStreaming = false, scrollIntent = false, onScrolled, activeQuestionFormMessageId = null, questionFormSubmittedAnswersByMessageId, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, renderAttachment, pendingPrompt = null, }) {
     const t = useT();
-    const containerRef = useRef(null);
-    // Whether the transcript was scrolled to its bottom as of the last user scroll or programmatic
-    // scroll-to-bottom — read by the ResizeObserver effect below, which only ever sees the DOM AFTER a
-    // resize already happened and so cannot recompute "was this at the bottom" from current values.
-    // Starts true: a freshly mounted pane opens on the latest turn, same as scrollIntent's own default.
-    const stickToBottomRef = useRef(true);
-    useEffect(() => {
-        if (!scrollIntent)
-            return;
-        const el = containerRef.current;
-        // Gated on `stickToBottomRef`, same as the ResizeObserver effect below: `scrollIntent` turns
-        // true on EVERY streamed event (tool-call chatter included, not just a finished reply — see
-        // `useConversation.applyRunToAssistantMessage`), so scrolling unconditionally here yanked a user
-        // who had deliberately scrolled up to read history back to the bottom on the very next chunk
-        // (owner-reported, 2026-08-30). `stickToBottomRef` already reflects the user's own last scroll
-        // gesture via the `onScroll` handler below, captured BEFORE this content change, so it is safe
-        // to trust here.
-        if (el && stickToBottomRef.current) {
-            el.scrollTop = el.scrollHeight;
-        }
-        onScrolled?.();
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [scrollIntent, messages]);
-    // Re-sticks to the bottom when a message ROW grows after mount with no accompanying `messages`
-    // change — the exact case an embedded MCP-UI/A2UI surface hits: it mounts at an initial guessed
-    // height (`preferredFrameSize` or `DEFAULT_INITIAL_HEIGHT`), then reports its real, often much
-    // taller content height asynchronously via `ui/notifications/size-changed`, entirely inside that
-    // surface's own React state (`McpUiHost`). The effect above never re-runs for that, so without this
-    // a surface which grows after the one-shot scroll leaves its own action buttons — or, once it
-    // resolves, the assistant's next reply — below the stale "bottom" with nothing to bring them back
-    // into view. Observes each direct child (one per message row) rather than the scroll container
-    // itself: the container's own box is held fixed by its flex/overflow layout, so only its CONTENT
-    // grows, which `ResizeObserver` only reports for the element whose box is actually changing.
-    // Re-created per `messages` change so a newly mounted row is observed too. Gated on
-    // `stickToBottomRef` so a human who scrolled up to read history is never yanked back down by an
-    // unrelated row resizing elsewhere in the transcript.
-    useEffect(() => {
-        const el = containerRef.current;
-        if (!el || typeof ResizeObserver !== 'function')
-            return;
-        const observer = new ResizeObserver(() => {
-            if (!stickToBottomRef.current)
-                return;
-            el.scrollTop = el.scrollHeight;
-        });
-        for (const child of Array.from(el.children))
-            observer.observe(child);
-        return () => observer.disconnect();
-    }, [messages]);
-    return (_jsxs("div", { className: "jini-message-list", ref: containerRef, onScroll: (event) => {
-            stickToBottomRef.current = isScrolledToBottom(event.currentTarget);
-        }, "data-agent-element": "chat-transcript", "data-agent-role": "list", "data-agent-label": "The conversation transcript, oldest message first", children: [messages.map((message) => {
+    const { containerRef, onScroll } = useMessageListAutoScroll({ messages, scrollIntent }, onScrolled !== undefined ? { onScrolled } : {});
+    return (_jsxs("div", { className: "jini-message-list", ref: containerRef, onScroll: onScroll, "data-agent-element": "chat-transcript", "data-agent-role": "list", "data-agent-label": "The conversation transcript, oldest message first", children: [messages.map((message) => {
                 const isLast = message.id === messages[messages.length - 1]?.id;
                 const runStreaming = isLast && isStreaming && !isTerminalRunStatus({ status: message.runStatus });
                 return (_jsx(MessageRow, { message: message, runStreaming: runStreaming, runSucceeded: message.runStatus === 'succeeded', questionFormInteractive: message.id === activeQuestionFormMessageId, ...(questionFormSubmittedAnswersByMessageId?.[message.id] !== undefined ? { questionFormSubmittedAnswers: questionFormSubmittedAnswersByMessageId[message.id] } : {}), ...(onQuestionFormSubmit !== undefined ? { onQuestionFormSubmit: (text, answers) => onQuestionFormSubmit(message.id, text, answers) } : {}), ...(projectFileNames !== undefined ? { projectFileNames } : {}), ...(onRequestOpenFile !== undefined ? { onRequestOpenFile } : {}), ...(renderAttachment !== undefined ? { renderAttachment } : {}) }, message.id));

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

@@ -0,0 +1,43 @@
+/**
+ * @file Pure scroll rules for `MessageList` (no DOM, no React), split out so the component file
+ * holds no logic.
+ */
+import type { ChatMessage } from '../../core/index.js';
+/** Slack, in px, for treating "close enough to the bottom" as "at the bottom" — a fractional
+ * scrollHeight/clientHeight rounding difference should not by itself stop the sticky-follow. */
+export declare const AT_BOTTOM_THRESHOLD_PX = 4;
+export declare function isScrolledToBottom(el: {
+    scrollHeight: number;
+    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
+ * an assistant message that newly entered `runStatus: 'queued'` (a retry, which resets the existing
+ * assistant message in place rather than appending one). Streamed chatter on an already-running
+ * turn is neither, so it never counts.
+ */
+export declare function startsNewTurn({ previous, next }: {
+    previous: readonly ChatMessage[];
+    next: readonly ChatMessage[];
+}): boolean;
+//# sourceMappingURL=MessageList.rules.d.ts.map

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

@@ -0,0 +1,38 @@
+/** Slack, in px, for treating "close enough to the bottom" as "at the bottom" — a fractional
+ * scrollHeight/clientHeight rounding difference should not by itself stop the sticky-follow. */
+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
+ * an assistant message that newly entered `runStatus: 'queued'` (a retry, which resets the existing
+ * assistant message in place rather than appending one). Streamed chatter on an already-running
+ * turn is neither, so it never counts.
+ */
+export function startsNewTurn({ previous, next }) {
+    const previousById = new Map(previous.map((message) => [message.id, message]));
+    return next.some((message) => {
+        const before = previousById.get(message.id);
+        if (message.role === 'user')
+            return before === undefined;
+        return message.runStatus === 'queued' && before?.runStatus !== 'queued';
+    });
+}
+//# sourceMappingURL=MessageList.rules.js.map

package/dist/react/components/MessageRow.js

@@ -50,7 +50,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';
@@ -160,6 +160,7 @@ export function MessageRow({ message, runStreaming = false, runSucceeded = false
         : null;
     const pending = isPendingWithNoContent(message, visibleContent, timeline.rows.length);
     const runInProgress = isRunInProgress(message.runStatus);
+    const awaitingAnswer = runStreaming && runInProgress && isAwaitingAnswer({ 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 +171,7 @@ export function MessageRow({ message, runStreaming = false, runSucceeded = false
             events: group.events,
             runStreaming,
             runSucceeded,
+            awaitingAnswer,
             runId: message.runId,
             ...(group.call === undefined ? {} : { call: group.call }),
         });

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/components/mcp-ui-surface-state.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @module components/mcp-ui-surface-state
+ *
+ * Whether an MCP-UI card in a chat transcript is closed, and with which label. Kept out of
+ * `McpUiSurfaceCard.tsx` so the component only renders; moved here from that file 2026-10-04 when
+ * the card's own deadline (`useSurfaceExpiry`) became a second reason to close it.
+ */
+import type { ExtEventCall } from '../ext-event-renderer-registry.js';
+import type { useT } from '../hooks/context.js';
+type Translate = ReturnType<typeof useT>;
+/**
+ * Why a card can no longer be answered, or `undefined` while it still can: {@link settledLabel}'s
+ * answer first, so a card answered in time still reads "Answered", then the card's own deadline
+ * (`useSurfaceExpiry`). The deadline closes the card the moment it passes rather than when the
+ * server's expired result arrives, so a person never clicks a card nobody is waiting on.
+ *
+ * @complexity O(r) in the call result's length (one regex test).
+ */
+export declare function closedSurfaceLabel({ t, call, runStreaming, documentsForUri, expired }: {
+    t: Translate;
+    call: ExtEventCall | undefined;
+    runStreaming: boolean;
+    documentsForUri: number;
+    expired: boolean;
+}): string | undefined;
+export {};
+//# sourceMappingURL=mcp-ui-surface-state.d.ts.map

package/dist/react/components/mcp-ui-surface-state.js

@@ -0,0 +1,33 @@
+/** Words in a finished call's result that mean nobody answered in time. */
+const UNANSWERED_RESULT = /\b(expired|abandoned|did not respond|run ended)\b/i;
+/**
+ * Why a card can no longer be answered, or `undefined` while it still can.
+ *
+ * A held-open question (the tool shows the card and waits) is over once its tool call returns, and
+ * dead once its run ends without that return. Its first document stays on screen either way, so
+ * without this an expired, answered or orphaned question still looked answerable (host stuck-chat
+ * investigation, 2026-09-27). Only a card still showing that FIRST document closes: a tool that sent
+ * a follow-up document for the same `ui://` URI (an outcome after the answer) keeps showing it.
+ *
+ * The labels are read from the call's result text, so they are a best guess for a producer this
+ * package has not seen; the card is closed either way, which is the property that matters.
+ */
+function settledLabel(t, call, runStreaming, documentsForUri) {
+    if (call === undefined || documentsForUri > 1)
+        return undefined;
+    if (call.result === undefined)
+        return runStreaming ? undefined : t('This question expired');
+    return UNANSWERED_RESULT.test(call.result.content) ? t('This question expired') : t('Answered');
+}
+/**
+ * Why a card can no longer be answered, or `undefined` while it still can: {@link settledLabel}'s
+ * answer first, so a card answered in time still reads "Answered", then the card's own deadline
+ * (`useSurfaceExpiry`). The deadline closes the card the moment it passes rather than when the
+ * server's expired result arrives, so a person never clicks a card nobody is waiting on.
+ *
+ * @complexity O(r) in the call result's length (one regex test).
+ */
+export function closedSurfaceLabel({ t, call, runStreaming, documentsForUri, expired }) {
+    return settledLabel(t, call, runStreaming, documentsForUri) ?? (expired ? t('This question expired') : undefined);
+}
+//# sourceMappingURL=mcp-ui-surface-state.js.map