@jini-ai/chat 0.3.9 → 0.3.10

package/dist/core/assistant-content.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @module assistant-content
+ *
+ * The ONE rule for turning a turn's events into its saved text `content`.
+ *
+ * Why it exists: `content` used to be every `text` event glued together (`out += ev.text`). A model
+ * that writes a short note, calls a tool, then answers produced `"Need project id. Find
+ * list_projects.`test_table` now exists…"` — the working note fused onto the answer mid-sentence,
+ * in the saved row, the copy button, and any transcript rebuilt from it. The live pane already
+ * shows those as separate steps (text, tool card, text); the saved string now keeps them apart too,
+ * with a blank line (a Markdown paragraph break) wherever a tool call or card sat between them.
+ *
+ * Every producer of `content` must use this: the browser (`useConversation`) and any host that
+ * saves a finished turn server-side. `interleaveMessageBlocks` accepts both this shape and the old
+ * glued one, so rows saved before this change still render in order.
+ */
+import type { AgentEvent } from './events.js';
+/** What separates two text runs that a tool call or card sat between. */
+export declare const ASSISTANT_STEP_SEPARATOR = "\n\n";
+/**
+ * A turn's text, with a paragraph break between runs separated by a tool call or card.
+ *
+ * @param events - The turn's events, in arrival order.
+ * @complexity O(total text length).
+ */
+export declare function assistantContentFromEvents(events: readonly AgentEvent[] | undefined): string;
+/** The pre-2026-09-27 rule (plain concatenation), kept only so older saved rows still match. */
+export declare function legacyAssistantContentFromEvents(events: readonly AgentEvent[] | undefined): string;
+//# sourceMappingURL=assistant-content.d.ts.map

package/dist/core/assistant-content.js

@@ -0,0 +1,41 @@
+/** What separates two text runs that a tool call or card sat between. */
+export const ASSISTANT_STEP_SEPARATOR = '\n\n';
+function separatorBefore(out, text) {
+    if (out.length === 0 || out.endsWith(ASSISTANT_STEP_SEPARATOR) || text.startsWith('\n'))
+        return '';
+    return out.endsWith('\n') ? '\n' : ASSISTANT_STEP_SEPARATOR;
+}
+/**
+ * A turn's text, with a paragraph break between runs separated by a tool call or card.
+ *
+ * @param events - The turn's events, in arrival order.
+ * @complexity O(total text length).
+ */
+export function assistantContentFromEvents(events) {
+    let out = '';
+    let stepBoundary = false;
+    for (const ev of events ?? []) {
+        if (ev.kind === 'text') {
+            if (ev.text.length === 0)
+                continue;
+            if (stepBoundary)
+                out += separatorBefore(out, ev.text);
+            out += ev.text;
+            stepBoundary = false;
+        }
+        else if (ev.kind === 'tool_use' || ev.kind === 'ext') {
+            stepBoundary = true;
+        }
+    }
+    return out;
+}
+/** The pre-2026-09-27 rule (plain concatenation), kept only so older saved rows still match. */
+export function legacyAssistantContentFromEvents(events) {
+    let out = '';
+    for (const ev of events ?? []) {
+        if (ev.kind === 'text')
+            out += ev.text;
+    }
+    return out;
+}
+//# sourceMappingURL=assistant-content.js.map

package/dist/core/compact-events.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module compact-events
+ *
+ * Shrinks a finished turn's events before they are saved.
+ *
+ * With partial-message streaming on, the CLI reports text a few tokens at a time, so one answer
+ * arrives as ~100 `text` events (`"Here"`, `" are your"`, …). Live, that is what makes words appear
+ * as they are written. Saved, it only repeats `{"kind":"text","text":…}` per token. Joining each
+ * run of back-to-back `text` events (and back-to-back `thinking` events) into one keeps the saved
+ * row's meaning intact: nothing is reordered, and any other event between two deltas — a tool call,
+ * a card, a status or raw line — still separates them, so `assistantContentFromEvents` and the
+ * pane's step layout read the same before and after.
+ */
+import type { AgentEvent } from './events.js';
+/**
+ * The events with every run of adjacent `text` (or adjacent `thinking`) events joined into one.
+ * Returns a new array; the input is not changed.
+ *
+ * @param events - A turn's events, in arrival order.
+ * @complexity O(number of events + total text length).
+ */
+export declare function mergeAdjacentTextEvents(events: readonly AgentEvent[] | undefined): AgentEvent[];
+//# sourceMappingURL=compact-events.d.ts.map

package/dist/core/compact-events.js

@@ -0,0 +1,23 @@
+function isDelta(event) {
+    return event.kind === 'text' || event.kind === 'thinking';
+}
+/**
+ * The events with every run of adjacent `text` (or adjacent `thinking`) events joined into one.
+ * Returns a new array; the input is not changed.
+ *
+ * @param events - A turn's events, in arrival order.
+ * @complexity O(number of events + total text length).
+ */
+export function mergeAdjacentTextEvents(events) {
+    const out = [];
+    for (const event of events ?? []) {
+        const last = out[out.length - 1];
+        if (last && isDelta(event) && isDelta(last) && last.kind === event.kind) {
+            out[out.length - 1] = { kind: last.kind, text: last.text + event.text };
+            continue;
+        }
+        out.push(event);
+    }
+    return out;
+}
+//# sourceMappingURL=compact-events.js.map

package/dist/core/events.d.ts

@@ -39,6 +39,8 @@ export type AgentEvent = {
     label: string;
     detail?: string;
     code?: string;
+    /** Structured fields for a coded status (e.g. `api_retry`'s attempt numbers). See `run-activity.ts`. */
+    data?: Readonly<Record<string, string | number>>;
 } | {
     kind: 'text';
     text: string;

package/dist/core/index.d.ts

@@ -16,12 +16,16 @@ export * from './events.js';
 export * from './messages.js';
 export * from './partial-json.js';
 export * from './tool-events.js';
+export * from './tool-output.js';
 export * from './transport.js';
 export * from './tools.js';
 export * from './todos.js';
 export * from './question-form.js';
 export * from './util/index.js';
 export * from './transcript.js';
+export * from './run-activity.js';
+export * from './assistant-content.js';
+export * from './compact-events.js';
 /**
  * The chat pane's own capability manifest (`CHAT_CAPABILITIES`). The framework-free agent-control
  * vocabulary this used to sit alongside — `CapabilityDef`, `PAGE_CAPABILITIES`, the

package/dist/core/index.js

@@ -16,12 +16,16 @@ export * from './events.js';
 export * from './messages.js';
 export * from './partial-json.js';
 export * from './tool-events.js';
+export * from './tool-output.js';
 export * from './transport.js';
 export * from './tools.js';
 export * from './todos.js';
 export * from './question-form.js';
 export * from './util/index.js';
 export * from './transcript.js';
+export * from './run-activity.js';
+export * from './assistant-content.js';
+export * from './compact-events.js';
 /**
  * The chat pane's own capability manifest (`CHAT_CAPABILITIES`). The framework-free agent-control
  * vocabulary this used to sit alongside — `CapabilityDef`, `PAGE_CAPABILITIES`, the

package/dist/core/run-activity.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @module run-activity
+ *
+ * What a running turn is doing right now, as one short line ("Running Page Fill… 1 m 20 s").
+ *
+ * Why: once a turn's first tool row appeared, nothing on screen showed the run was still alive —
+ * the old "Thinking…" placeholder only showed while the message was completely empty. Model think
+ * time, long tool calls, held cards and API overload retries all looked identical: dead.
+ *
+ * Shape: {@link deriveRunActivity} reads the events the pane already has and returns the latest
+ * signal; {@link RUN_ACTIVITY_LABELS} is the ONE table that turns a signal into words. The clock
+ * (seconds since the signal began) is the caller's: the React hook ticks it once a second. Nothing
+ * here special-cases a particular tool.
+ *
+ * Status events this reads (a host translates its runtime's heartbeats into them):
+ * - `code: 'api_retry'`, `data: { attempt, maxAttempts, service? }` — the model API is overloaded.
+ * - `code: 'tool_progress'`, `data: { elapsedSeconds }` — a tool call is still running.
+ * - `code: 'thinking'` — the model is reasoning (keeps the idle timer honest).
+ */
+import type { AgentEvent } from './events.js';
+/** The latest thing a running turn is doing. */
+export type RunActivity = {
+    readonly kind: 'thinking';
+} | {
+    readonly kind: 'writing';
+} | {
+    readonly kind: 'finding-tool';
+} | {
+    readonly kind: 'running-tool';
+    readonly tool: string;
+    readonly reportedSeconds?: number;
+} | {
+    readonly kind: 'awaiting-answer';
+} | {
+    readonly kind: 'retrying';
+    readonly attempt?: number;
+    readonly maxAttempts?: number;
+    readonly service?: string;
+};
+/** {@link deriveRunActivity}'s result: the signal, plus a key that changes whenever the signal restarts. */
+export interface RunActivityState {
+    readonly activity: RunActivity;
+    /** Changes when a new signal begins, so the caller restarts its clock (e.g. `tool:<id>`). */
+    readonly key: string;
+    /** Count of events the person can see (text, tool rows, cards). A change means "something new". */
+    readonly visibleCount: number;
+}
+/** After this long with nothing new on screen, a thinking/writing line says "Still working…". */
+export declare const RUN_ACTIVITY_IDLE_MS = 20000;
+/** `"page.fill"` → `"Page Fill"`, `"mcp__supabase__list_projects"` → `"List Projects"`. Display only. */
+export declare function humanizeToolName(name: string, input?: unknown): string;
+/**
+ * The latest signal in a running turn's events.
+ *
+ * Precedence, newest wins: an API retry with nothing visible after it; a card that arrived while a
+ * tool call is still open (the tool is waiting on the person); the newest open tool call; else
+ * writing (last visible event is text) or thinking.
+ *
+ * @complexity O(n) in events, O(open tool calls) extra space.
+ */
+export declare function deriveRunActivity(events: readonly AgentEvent[] | undefined): RunActivityState;
+/** `4` → `"4 s"`, `80` → `"1 m 20 s"`, `120` → `"2 m 0 s"`. */
+export declare function formatActivityClock(totalSeconds: number): string;
+/** A translator: the chat package's `t(key, vars)`. */
+export type RunActivityTranslate = (key: string, vars?: Record<string, string | number>) => string;
+/** The clock values a label may use. */
+export interface RunActivityClock {
+    /** Seconds since this signal began (already corrected by any `tool_progress` report). */
+    readonly seconds: number;
+    /** Milliseconds since anything new appeared on screen. */
+    readonly idleMs: number;
+}
+/**
+ * THE event → words table. One entry per {@link RunActivity} kind; nothing else in the package
+ * decides what the activity line says. Keys are English source strings for the host's `t()`.
+ */
+export declare const RUN_ACTIVITY_LABELS: {
+    readonly [K in RunActivity['kind']]: (activity: Extract<RunActivity, {
+        kind: K;
+    }>, clock: RunActivityClock, t: RunActivityTranslate) => string;
+};
+/**
+ * The activity line's text for a signal and clock.
+ *
+ * @complexity O(1).
+ */
+export declare function describeRunActivity(activity: RunActivity, clock: RunActivityClock, t: RunActivityTranslate): string;
+//# sourceMappingURL=run-activity.d.ts.map

package/dist/core/run-activity.js

@@ -0,0 +1,153 @@
+/** Tool names whose only job is finding the right tool (MCP tool search / schema lookup). */
+const DISCOVERY_TOOL_NAMES = new Set([
+    'ToolSearch',
+    'search_tools',
+    'describe_tool',
+    'mcp__jini__search_tools',
+    'mcp__jini__describe_tool',
+]);
+/** Transport wrappers whose real tool id is in `input.toolId`. */
+const WRAPPER_TOOL_NAMES = new Set(['execute_delegated_tool', 'mcp__jini__execute_delegated_tool']);
+/** Ext events that are a card for the person (a form, a confirm, a sign-in). */
+const CARD_EXT_NAMES = new Set(['mcp-ui', 'a2ui']);
+/** After this long with nothing new on screen, a thinking/writing line says "Still working…". */
+export const RUN_ACTIVITY_IDLE_MS = 20_000;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function numberField(data, key) {
+    const value = isRecord(data) ? data[key] : undefined;
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function stringField(data, key) {
+    const value = isRecord(data) ? data[key] : undefined;
+    return typeof value === 'string' && value ? value : undefined;
+}
+/** `"page.fill"` → `"Page Fill"`, `"mcp__supabase__list_projects"` → `"List Projects"`. Display only. */
+export function humanizeToolName(name, input) {
+    const real = WRAPPER_TOOL_NAMES.has(name) ? (stringField(input, 'toolId') ?? name) : name;
+    const bare = real.startsWith('mcp__') ? real.split('__').slice(2).join('__') || real : real;
+    return bare
+        .split(/[._\s]+/)
+        .filter(Boolean)
+        .map((word) => word[0].toUpperCase() + word.slice(1))
+        .join(' ');
+}
+function isVisible(event) {
+    return event.kind === 'text' ? event.text.length > 0 : event.kind === 'tool_use' || event.kind === 'tool_result' || event.kind === 'ext';
+}
+function scanEvent(scan, event, index) {
+    if (isVisible(event)) {
+        scan.lastVisible = { index, kind: event.kind };
+        scan.visibleCount += 1;
+    }
+    if (event.kind === 'tool_use') {
+        scan.open = scan.open.filter((tool) => tool.id !== event.id);
+        scan.open.push({ id: event.id, name: event.name, input: event.input, index });
+    }
+    else if (event.kind === 'tool_result') {
+        scan.open = scan.open.filter((tool) => tool.id !== event.toolUseId);
+    }
+    else if (event.kind === 'ext' && CARD_EXT_NAMES.has(event.name)) {
+        scan.lastCardIndex = index;
+    }
+    else if (event.kind === 'status' && event.code === 'api_retry') {
+        scan.retry = { index, data: event.data };
+    }
+    else if (event.kind === 'status' && event.code === 'tool_progress') {
+        const seconds = numberField(event.data, 'elapsedSeconds');
+        if (seconds !== undefined)
+            scan.progress = { index, seconds };
+    }
+}
+/**
+ * The latest signal in a running turn's events.
+ *
+ * Precedence, newest wins: an API retry with nothing visible after it; a card that arrived while a
+ * tool call is still open (the tool is waiting on the person); the newest open tool call; else
+ * writing (last visible event is text) or thinking.
+ *
+ * @complexity O(n) in events, O(open tool calls) extra space.
+ */
+export function deriveRunActivity(events) {
+    const scan = { open: [], lastVisible: null, lastCardIndex: -1, retry: null, progress: null, visibleCount: 0 };
+    (events ?? []).forEach((event, index) => scanEvent(scan, event, index));
+    const visibleCount = scan.visibleCount;
+    const lastVisibleIndex = scan.lastVisible?.index ?? -1;
+    if (scan.retry && scan.retry.index > lastVisibleIndex) {
+        const data = scan.retry.data;
+        const attempt = numberField(data, 'attempt');
+        const maxAttempts = numberField(data, 'maxAttempts');
+        const service = stringField(data, 'service');
+        return {
+            activity: {
+                kind: 'retrying',
+                ...(attempt !== undefined ? { attempt } : {}),
+                ...(maxAttempts !== undefined ? { maxAttempts } : {}),
+                ...(service !== undefined ? { service } : {}),
+            },
+            key: `retry:${lastVisibleIndex}`,
+            visibleCount,
+        };
+    }
+    const newestOpen = scan.open[scan.open.length - 1];
+    if (newestOpen) {
+        if (scan.lastCardIndex > newestOpen.index) {
+            return { activity: { kind: 'awaiting-answer' }, key: `card:${scan.lastCardIndex}`, visibleCount };
+        }
+        if (DISCOVERY_TOOL_NAMES.has(newestOpen.name)) {
+            return { activity: { kind: 'finding-tool' }, key: `tool:${newestOpen.id}`, visibleCount };
+        }
+        const reported = scan.progress && scan.progress.index > newestOpen.index ? scan.progress.seconds : undefined;
+        return {
+            activity: {
+                kind: 'running-tool',
+                tool: humanizeToolName(newestOpen.name, newestOpen.input),
+                ...(reported !== undefined ? { reportedSeconds: reported } : {}),
+            },
+            key: `tool:${newestOpen.id}`,
+            visibleCount,
+        };
+    }
+    if (scan.lastVisible?.kind === 'text') {
+        return { activity: { kind: 'writing' }, key: `writing:${lastVisibleIndex}`, visibleCount };
+    }
+    return { activity: { kind: 'thinking' }, key: `thinking:${lastVisibleIndex}`, visibleCount };
+}
+/** `4` → `"4 s"`, `80` → `"1 m 20 s"`, `120` → `"2 m 0 s"`. */
+export function formatActivityClock(totalSeconds) {
+    const seconds = Math.max(0, Math.floor(totalSeconds));
+    const minutes = Math.floor(seconds / 60);
+    return minutes > 0 ? `${minutes} m ${seconds % 60} s` : `${seconds} s`;
+}
+/**
+ * THE event → words table. One entry per {@link RunActivity} kind; nothing else in the package
+ * decides what the activity line says. Keys are English source strings for the host's `t()`.
+ */
+export const RUN_ACTIVITY_LABELS = {
+    thinking: (_a, clock, t) => clock.idleMs >= RUN_ACTIVITY_IDLE_MS
+        ? t('Still working… {time}', { time: formatActivityClock(clock.seconds) })
+        : t('Thinking… {time}', { time: formatActivityClock(clock.seconds) }),
+    writing: (_a, clock, t) => clock.idleMs >= RUN_ACTIVITY_IDLE_MS
+        ? t('Still working… {time}', { time: formatActivityClock(clock.seconds) })
+        : t('Writing…'),
+    'finding-tool': (_a, clock, t) => t('Finding the right tool… {time}', { time: formatActivityClock(clock.seconds) }),
+    'running-tool': (a, clock, t) => t('Running {tool}… {time}', { tool: a.tool, time: formatActivityClock(clock.seconds) }),
+    'awaiting-answer': (_a, clock, t) => t('Waiting for your answer above · {time}', { time: formatActivityClock(clock.seconds) }),
+    retrying: (a, _clock, t) => {
+        const who = a.service ? t("{service}'s servers are busy", { service: a.service }) : t('The AI service is busy');
+        return a.attempt !== undefined && a.maxAttempts !== undefined
+            ? t('{who} — retrying ({attempt} of {max})…', { who, attempt: a.attempt, max: a.maxAttempts })
+            : t('{who} — retrying…', { who });
+    },
+};
+/**
+ * The activity line's text for a signal and clock.
+ *
+ * @complexity O(1).
+ */
+export function describeRunActivity(activity, clock, t) {
+    const label = RUN_ACTIVITY_LABELS[activity.kind];
+    return label(activity, clock, t);
+}
+//# sourceMappingURL=run-activity.js.map

package/dist/core/tool-output.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Formats a tool result's text for a person to read. Tool results travel to the model as compact
+ * JSON (`@jini-ai/mcp`'s `okResult` — indentation made nested results ~2.5× larger), so a view that
+ * shows one re-indents it here, at render time. Only a JSON object or array is re-indented; any other
+ * text (shell output, an error message, a bare JSON scalar, something that merely starts with `{`)
+ * comes back unchanged.
+ *
+ * @param text - A `tool_result` event's flattened `content`.
+ * @returns The value re-serialized with two-space indentation, or `text` as given.
+ * @complexity O(n) in `text.length`.
+ */
+export declare function formatToolOutputForDisplay(text: string): string;
+//# sourceMappingURL=tool-output.d.ts.map

package/dist/core/tool-output.js

@@ -0,0 +1,24 @@
+/**
+ * Formats a tool result's text for a person to read. Tool results travel to the model as compact
+ * JSON (`@jini-ai/mcp`'s `okResult` — indentation made nested results ~2.5× larger), so a view that
+ * shows one re-indents it here, at render time. Only a JSON object or array is re-indented; any other
+ * text (shell output, an error message, a bare JSON scalar, something that merely starts with `{`)
+ * comes back unchanged.
+ *
+ * @param text - A `tool_result` event's flattened `content`.
+ * @returns The value re-serialized with two-space indentation, or `text` as given.
+ * @complexity O(n) in `text.length`.
+ */
+export function formatToolOutputForDisplay(text) {
+    const trimmed = text.trim();
+    const first = trimmed[0];
+    if (first !== '{' && first !== '[')
+        return text;
+    try {
+        return JSON.stringify(JSON.parse(trimmed), null, 2);
+    }
+    catch {
+        return text;
+    }
+}
+//# sourceMappingURL=tool-output.js.map

package/dist/react/components/Markdown.js

@@ -131,6 +131,7 @@ function collectTableRows(lines, start) {
     }
     return { rows, next: i };
 }
+const ORDERED_ITEM = /^\s*\d+[.)]\s+/;
 function parseBlocks(input) {
     const lines = input.split(/\r?\n/);
     const blocks = [];
@@ -204,13 +205,14 @@ function parseBlocks(input) {
             i = next;
             continue;
         }
-        if (/^\s*\d+[.)]\s+/.test(line)) {
+        if (ORDERED_ITEM.test(line)) {
+            const start = Number(/\d+/.exec(line)[0]);
             const items = [];
-            while (i < lines.length && /^\s*\d+[.)]\s+/.test(lines[i])) {
-                items.push(lines[i].replace(/^\s*\d+[.)]\s+/, ''));
-                i += 1;
+            while (i < lines.length && ORDERED_ITEM.test(lines[i])) {
+                items.push(lines[i].replace(ORDERED_ITEM, ''));
+                i = nextLooseListLine(lines, i + 1);
             }
-            blocks.push({ kind: 'ol', items });
+            blocks.push({ kind: 'ol', start, items });
             continue;
         }
         const paragraph = [];
@@ -222,6 +224,18 @@ function parseBlocks(input) {
     }
     return blocks;
 }
+/**
+ * A "loose" numbered list puts a blank line between items ("1. a\n\n2. b").
+ * Skip those blank lines when the next non-blank line is another numbered
+ * item, so the items stay in ONE `<ol>` (numbered 1..n) instead of n lists
+ * that each show "1.". Otherwise return `i` unchanged and the list ends.
+ */
+function nextLooseListLine(lines, i) {
+    let j = i;
+    while (j < lines.length && lines[j].trim() === '')
+        j += 1;
+    return j > i && j < lines.length && ORDERED_ITEM.test(lines[j]) ? j : i;
+}
 function isBlockStart(lines, i) {
     const line = lines[i];
     return (/^```/.test(line)
@@ -229,7 +243,7 @@ function isBlockStart(lines, i) {
         || /^(-{3,}|\*{3,}|_{3,})\s*$/.test(line)
         || /^>\s?/.test(line)
         || /^\s*[-*]\s+/.test(line)
-        || /^\s*\d+[.)]\s+/.test(line)
+        || ORDERED_ITEM.test(line)
         || isTableStartAt(lines, i));
 }
 function renderBlock(block) {
@@ -243,7 +257,7 @@ function renderBlock(block) {
         case 'ul':
             return (_jsx("ul", { children: block.items.map((item, i) => (_jsx("li", { children: renderInline(item) }, i))) }));
         case 'ol':
-            return (_jsx("ol", { children: block.items.map((item, i) => (_jsx("li", { children: renderInline(item) }, i))) }));
+            return (_jsx("ol", { start: block.start === 1 ? undefined : block.start, children: block.items.map((item, i) => (_jsx("li", { children: renderInline(item) }, i))) }));
         case 'bq':
             return _jsx("blockquote", { children: renderInline(block.text) });
         case 'code':

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

@@ -24,7 +24,15 @@ export interface McpUiSurfaceCardProps extends ExtEventRenderProps {
     maxHeight?: number;
 }
 /** Registered against `ext-event-renderer-registry.ts`'s `'mcp-ui'` name — see module doc. */
-export declare function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLink, maxHeight }: McpUiSurfaceCardProps): import("react").JSX.Element;
+export declare function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLink, maxHeight, call, runStreaming }: 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
+ * re-emitted resource with the same URI still updates its card in place. Pass it as
+ * `registerExtEventRenderer(MCP_UI_EXT_EVENT_NAME, renderer, { slotKey: mcpUiSurfaceSlotKey })`
+ * when registering a custom MCP-UI renderer; {@link registerMcpUiSurfaceRenderer} already does.
+ */
+export declare function mcpUiSurfaceSlotKey(data: unknown): string | undefined;
 /**
  * Registers {@link McpUiSurfaceCard} against the ext-event registry.
  *

package/dist/react/components/McpUiSurfaceCard.js

@@ -112,10 +112,41 @@ 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 (Tovu 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 }) {
+export function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLink, maxHeight, call, runStreaming }) {
     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;
+    if (closed !== undefined)
+        return _jsx(ClosedSurface, { call: call, label: closed });
     if (resources.length === 0) {
         // Visible rather than silent: an `ext` event named `mcp-ui` that carries no parseable resource
         // is a producer bug, and a transcript that renders nothing for it hides the bug behind what
@@ -137,6 +168,16 @@ export function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLi
                         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));
         }) }));
 }
+/**
+ * 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
+ * re-emitted resource with the same URI still updates its card in place. Pass it as
+ * `registerExtEventRenderer(MCP_UI_EXT_EVENT_NAME, renderer, { slotKey: mcpUiSurfaceSlotKey })`
+ * when registering a custom MCP-UI renderer; {@link registerMcpUiSurfaceRenderer} already does.
+ */
+export function mcpUiSurfaceSlotKey(data) {
+    return parseUIResource(data)?.resource.uri;
+}
 /**
  * Registers {@link McpUiSurfaceCard} against the ext-event registry.
  *
@@ -154,6 +195,6 @@ export function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLi
  * @returns An unregister handle, so a test or a hot reload can dispose cleanly.
  */
 export function registerMcpUiSurfaceRenderer(options) {
-    return registerExtEventRenderer(options.name ?? MCP_UI_EXT_EVENT_NAME, (props) => (_jsx(McpUiSurfaceCard, { ...props, sandboxProxyUrl: options.sandboxProxyUrl, ...(options.onToolCall === undefined ? {} : { onToolCall: options.onToolCall }), ...(options.onOpenLink === undefined ? {} : { onOpenLink: options.onOpenLink }), ...(options.maxHeight === undefined ? {} : { maxHeight: options.maxHeight }) })));
+    return registerExtEventRenderer(options.name ?? MCP_UI_EXT_EVENT_NAME, (props) => (_jsx(McpUiSurfaceCard, { ...props, sandboxProxyUrl: options.sandboxProxyUrl, ...(options.onToolCall === undefined ? {} : { onToolCall: options.onToolCall }), ...(options.onOpenLink === undefined ? {} : { onOpenLink: options.onOpenLink }), ...(options.maxHeight === undefined ? {} : { maxHeight: options.maxHeight }) })), { slotKey: mcpUiSurfaceSlotKey });
 }
 //# sourceMappingURL=McpUiSurfaceCard.js.map