@jini-ai/chat 0.5.1 → 0.5.3

package/CHANGELOG.md

@@ -1,8 +1,31 @@
+## 0.5.3 — 2026-10-06
+
+- New `createLastConversationStore({ scope }, { storage? })` (react): remembers one conversation id per caller identity under a versioned localStorage key (`jini.chat.last-conversation.v1.<scope>`); corrupt or foreign entries read as nothing remembered. Selection stays host-owned.
+- Restored staged attachments keep their upload batch: the draft cache records the batch id beside each conversation's attachment references, and `useChatPane` resumes that batch on mount and on a conversation switch, so a second attachment after a remount no longer fails the turn ("Attachments must belong to one batch").
+- A display-only A2UI surface (`surfaceProperties.displayOnly`, e.g. a drawn chart) no longer reads as "Waiting for your answer above".
+- A run held on an open form reads as waiting, not working: new `isAwaitingAnswer`, passed to ext event renderers as `awaitingAnswer`.
+- One row per delegated tool call: `isDelegatedWrapperToolName` covers both delegated gateways (bare or `mcp__<server>__`-prefixed) and `foldDelegatedWrapperCalls` drops a wrapper call once its canonical call exists (`useToolTimeline`, `ToolCard`).
+- Markdown: `[label](url)` links render (relative and parenthesized URLs, unsafe schemes kept as text, off-site links open in a new tab); intraword underscores never open or close emphasis.
+- A late scroll event no longer unsticks the transcript from the bottom; only a move up does.
+- Requires `@jini-ai/agentic` ^0.4.2 (`displayOnlySurfaceIdOf`).
+
+## 0.5.2 — 2026-10-05
+
+- `useChatPane` holds a draft typed for a question that has since closed (answered elsewhere, expired, or refused with `'not-pending'`): `send` shows the `'not-pending'` notice instead of queueing it as a new paid run. Only clearing the draft or the new `sendAsNewMessage()` (the notice's "Send as a new message" button in `ChatPane`) lets it out as an ordinary turn. New pure `findAwaitedTypedAnswerId`.
+- A delivered typed answer clears the composer only if its text is unchanged, so a correction typed while the host answered survives; a delivery settling after `reset()`, a conversation switch or unmount changes neither the draft nor the notice.
+
+- `ChatPane`/`useChatPane` accept `deliverTypedAnswer`: text typed while the running agent holds a question card open (a surface whose tool call has not returned) goes to the host instead of the queue. `'delivered'` clears the draft; `'not-pending'`/`'failed'` (or a throw) keep the draft, show a notice (`typedAnswerNotice`) and never queue it, so a closed question can no longer turn an answer into a second paid run. New `createTypedAnswerPoster` posts `{toolName, params: {__typedAnswer}}` to the MCP-UI tool-call route (202 delivered, 409 not-pending). Omitting the prop keeps today's queue-while-streaming behavior.
+
+- `McpUiSurfaceCard` counts down a card's answer deadline (`MCP_UI_EXPIRES_AT_META_KEY`) under the live frame ("Expires in {time}", `role="timer"`) and closes it as "This question expired" when the deadline passes; a card answered in time still reads "Answered". New `useSurfaceExpiry` hook with an injectable `SurfaceExpiryClock` (card prop `expiryClock`), and pure `describeSurfaceExpiry`/`formatRemainingTime` in core.
+
+- A user's own send or retry re-sticks the transcript to the bottom even when they had scrolled up to read history (`MessageList`; scroll rules move to `useMessageListAutoScroll`).
+- The `@jini-ai/db` peer range is `^0.2.0 || ^0.3.0`; chat uses only db's kernel and store entries, which 0.3.0 leaves unchanged.
+
 ## 0.5.1 — 2026-10-04
 
 - Internal `@jini-ai/*` dependencies are caret ranges (`workspace:^`) instead of exact pins, so a host on `@jini-ai/agentic` 0.4.1 or on a newer patch resolves a single copy without an override.
 
-## Unreleased
+### Also shipped in 0.5.1 (was listed under Unreleased)
 
 - Type store fixtures with the shared storage kernel and chat contracts, including host-owned tables;
   align construction, reopening, paging and message fixtures with current API shapes.

package/dist/core/index.d.ts

@@ -24,6 +24,7 @@ export * from './question-form.js';
 export * from './util/index.js';
 export * from './transcript.js';
 export * from './run-activity.js';
+export * from './surface-expiry.js';
 export * from './assistant-content.js';
 export * from './compact-events.js';
 /**

package/dist/core/index.js

@@ -24,6 +24,7 @@ export * from './question-form.js';
 export * from './util/index.js';
 export * from './transcript.js';
 export * from './run-activity.js';
+export * from './surface-expiry.js';
 export * from './assistant-content.js';
 export * from './compact-events.js';
 /**

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

@@ -1,22 +1,3 @@
-/**
- * @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 = {
@@ -57,7 +38,8 @@ export declare function humanizeToolName({ name }: {
  * 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
+ * tool call is still open (the tool is waiting on the person; a display-only A2UI surface is not a
+ * card); 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.
@@ -65,6 +47,16 @@ export declare function humanizeToolName({ name }: {
 export declare function deriveRunActivity({ events }: {
     events: readonly AgentEvent[] | undefined;
 }): RunActivityState;
+/**
+ * Whether the run is waiting on the person: a card (form, confirm, sign-in) arrived while its tool
+ * call is still open. Hosts use it to hide "still working" notices, which read as a hung run while
+ * the run is really waiting for an answer.
+ *
+ * @complexity O(n) in events.
+ */
+export declare function isAwaitingAnswer({ events }: {
+    events: readonly AgentEvent[] | undefined;
+}): boolean;
 /** `4` → `"4 s"`, `80` → `"1 m 20 s"`, `120` → `"2 m 0 s"`. */
 export declare function formatActivityClock({ totalSeconds }: {
     totalSeconds: number;

package/dist/core/run-activity.js

@@ -1,3 +1,24 @@
+/**
+ * @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 { a2uiSurfaceIdOf, displayOnlySurfaceIdOf } from '@jini-ai/agentic/a2ui';
+import { isDelegatedWrapperToolName } from './tool-events.js';
 /** Tool names whose only job is finding the right tool (MCP tool search / schema lookup). */
 const DISCOVERY_TOOL_NAMES = new Set([
     'ToolSearch',
@@ -6,10 +27,10 @@ const DISCOVERY_TOOL_NAMES = new Set([
     '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']);
+/** The A2UI ext name: its surfaces may declare themselves display-only (`@jini-ai/agentic/a2ui`). */
+const A2UI_EXT_NAME = '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) {
@@ -25,7 +46,8 @@ function stringField(data, key) {
 }
 /** `"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;
+    // A transport wrapper's real tool id is in `input.toolId`.
+    const real = isDelegatedWrapperToolName({ name: name }) ? (stringField(input, 'toolId') ?? name) : name;
     const bare = real.startsWith('mcp__') ? real.split('__').slice(2).join('__') || real : real;
     return bare
         .split(/[._\s]+/)
@@ -36,6 +58,23 @@ export function humanizeToolName({ name }, { input } = {}) {
 function isVisible(event) {
     return event.kind === 'text' ? event.text.length > 0 : event.kind === 'tool_use' || event.kind === 'tool_result' || event.kind === 'ext';
 }
+/**
+ * Whether an ext event is a card the person must answer. A display-only A2UI surface shows
+ * something and asks nothing, so a tool holding its call open after drawing one (assistant_render_ui
+ * waits a few seconds to hear a browser refusal) must not read as "Waiting for your answer above"
+ * (demo V3, 2026-10-05).
+ */
+function isAnswerCard(scan, name, data) {
+    if (!CARD_EXT_NAMES.has(name))
+        return false;
+    if (name !== A2UI_EXT_NAME)
+        return true;
+    const displayOnlyId = displayOnlySurfaceIdOf({ message: data });
+    if (displayOnlyId !== undefined)
+        scan.displayOnlySurfaces.add(displayOnlyId);
+    const surfaceId = a2uiSurfaceIdOf({ message: data });
+    return surfaceId === undefined || !scan.displayOnlySurfaces.has(surfaceId);
+}
 function scanEvent(scan, event, index) {
     if (isVisible(event)) {
         scan.lastVisible = { index, kind: event.kind };
@@ -48,7 +87,7 @@ function scanEvent(scan, event, 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)) {
+    else if (event.kind === 'ext' && isAnswerCard(scan, event.name, event.data)) {
         scan.lastCardIndex = index;
     }
     else if (event.kind === 'status' && event.code === 'api_retry') {
@@ -64,13 +103,14 @@ function scanEvent(scan, event, index) {
  * 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
+ * tool call is still open (the tool is waiting on the person; a display-only A2UI surface is not a
+ * card); 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 };
+    const scan = { open: [], lastVisible: null, lastCardIndex: -1, retry: null, progress: null, visibleCount: 0, displayOnlySurfaces: new Set() };
     (events ?? []).forEach((event, index) => scanEvent(scan, event, index));
     const visibleCount = scan.visibleCount;
     const lastVisibleIndex = scan.lastVisible?.index ?? -1;
@@ -114,6 +154,16 @@ export function deriveRunActivity({ events }) {
     }
     return { activity: { kind: 'thinking' }, key: `thinking:${lastVisibleIndex}`, visibleCount };
 }
+/**
+ * Whether the run is waiting on the person: a card (form, confirm, sign-in) arrived while its tool
+ * call is still open. Hosts use it to hide "still working" notices, which read as a hung run while
+ * the run is really waiting for an answer.
+ *
+ * @complexity O(n) in events.
+ */
+export function isAwaitingAnswer({ events }) {
+    return deriveRunActivity({ events }).activity.kind === 'awaiting-answer';
+}
 /** `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));
@@ -133,7 +183,9 @@ export const RUN_ACTIVITY_LABELS = {
         : t('Writing…'),
     'finding-tool': (_a, clock, t) => t('Finding the right tool… {time}', { time: formatActivityClock({ totalSeconds: clock.seconds }) }),
     'running-tool': (a, clock, t) => t('Running {tool}… {time}', { tool: a.tool, time: formatActivityClock({ totalSeconds: clock.seconds }) }),
-    'awaiting-answer': (_a, clock, t) => t('Waiting for your answer above · {time}', { time: formatActivityClock({ totalSeconds: clock.seconds }) }),
+    // No clock: the run is waiting on the person, not working, and a ticking timer under an open
+    // form read as a hung run (demo dry-run, 2026-10-05).
+    'awaiting-answer': (_a, _clock, t) => t('Waiting for your answer above'),
     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

package/dist/core/surface-expiry.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @module surface-expiry
+ *
+ * The answer deadline of a pending MCP-UI card (`MCP_UI_EXPIRES_AT_META_KEY` in `@jini-ai/ui`):
+ * whether it has passed, and the time left as the card shows it. Pure — the caller supplies "now",
+ * so the boundary (just before / at / after the deadline) is tested without a real clock.
+ */
+/** How often a live countdown re-reads the clock. Matches the label's whole-second resolution. */
+export declare const SURFACE_EXPIRY_TICK_MS = 1000;
+/** A card still answerable, with the time left, or one whose deadline has passed. */
+export type SurfaceExpiry = {
+    readonly expired: true;
+} | {
+    readonly expired: false;
+    readonly remainingMs: number;
+    readonly remaining: string;
+};
+/**
+ * Describes a card's deadline at one instant.
+ *
+ * Expired AT the deadline, not after it: the server gives up when its timer fires, so a click at
+ * that instant would already find nothing waiting.
+ *
+ * @param input.expiresAtMs - The deadline, epoch milliseconds.
+ * @param input.nowMs - The current time, same clock.
+ * @complexity O(1).
+ */
+export declare function describeSurfaceExpiry({ expiresAtMs, nowMs }: {
+    expiresAtMs: number;
+    nowMs: number;
+}): SurfaceExpiry;
+/**
+ * Formats a positive duration as `m:ss`, or `h:mm:ss` from an hour up.
+ *
+ * Rounds UP to the whole second, so a card with any time left never reads `0:00` while it can still
+ * be answered; it reads `0:01` until the instant it expires.
+ *
+ * @param remainingMs - Milliseconds left, greater than zero.
+ * @complexity O(1).
+ */
+export declare function formatRemainingTime(remainingMs: number): string;
+//# sourceMappingURL=surface-expiry.d.ts.map

package/dist/core/surface-expiry.js

@@ -0,0 +1,42 @@
+/**
+ * @module surface-expiry
+ *
+ * The answer deadline of a pending MCP-UI card (`MCP_UI_EXPIRES_AT_META_KEY` in `@jini-ai/ui`):
+ * whether it has passed, and the time left as the card shows it. Pure — the caller supplies "now",
+ * so the boundary (just before / at / after the deadline) is tested without a real clock.
+ */
+/** How often a live countdown re-reads the clock. Matches the label's whole-second resolution. */
+export const SURFACE_EXPIRY_TICK_MS = 1_000;
+/**
+ * Describes a card's deadline at one instant.
+ *
+ * Expired AT the deadline, not after it: the server gives up when its timer fires, so a click at
+ * that instant would already find nothing waiting.
+ *
+ * @param input.expiresAtMs - The deadline, epoch milliseconds.
+ * @param input.nowMs - The current time, same clock.
+ * @complexity O(1).
+ */
+export function describeSurfaceExpiry({ expiresAtMs, nowMs }) {
+    const remainingMs = expiresAtMs - nowMs;
+    if (remainingMs <= 0)
+        return { expired: true };
+    return { expired: false, remainingMs, remaining: formatRemainingTime(remainingMs) };
+}
+/**
+ * Formats a positive duration as `m:ss`, or `h:mm:ss` from an hour up.
+ *
+ * Rounds UP to the whole second, so a card with any time left never reads `0:00` while it can still
+ * be answered; it reads `0:01` until the instant it expires.
+ *
+ * @param remainingMs - Milliseconds left, greater than zero.
+ * @complexity O(1).
+ */
+export function formatRemainingTime(remainingMs) {
+    const totalSeconds = Math.ceil(remainingMs / 1_000);
+    const hours = Math.floor(totalSeconds / 3_600);
+    const minutes = Math.floor((totalSeconds % 3_600) / 60);
+    const seconds = String(totalSeconds % 60).padStart(2, '0');
+    return hours > 0 ? `${hours}:${String(minutes).padStart(2, '0')}:${seconds}` : `${minutes}:${seconds}`;
+}
+//# sourceMappingURL=surface-expiry.js.map

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

@@ -17,4 +17,38 @@ import type { AgentEvent } from './events.js';
 export declare function dedupeToolUsesById({ events }: {
     events: AgentEvent[] | undefined;
 }): AgentEvent[];
+/**
+ * Whether `name` is a delegated-tool transport wrapper — `execute_delegated_tool` or
+ * `execute_readonly_delegated_tool`, bare or as an MCP client names it (`mcp__<server>__…`). Its real
+ * tool id is in `input.toolId`. The one shared definition, so a renderer and the run-activity line
+ * cannot disagree about which names are wrappers (both once missed the read-only gateway).
+ *
+ * @complexity O(n) in the length of `name`.
+ */
+export declare function isDelegatedWrapperToolName({ name }: {
+    name: string;
+}): boolean;
+/**
+ * Drop each delegated-tool wrapper call that the daemon also reported as its own canonical row,
+ * so one call shows as one row.
+ *
+ * WHY. A delegated call arrives twice: the vendor CLI's wrapper `tool_use`
+ * (`mcp__jini__execute_delegated_tool {toolId, input}`, with the CLI's `toolu_…` id) and the
+ * daemon bridge's canonical `tool_use` named after the real tool (`content_stats`, with a fresh
+ * UUID from `@jini-ai/mcp`). The ids differ, so {@link dedupeToolUsesById} cannot merge them, and a
+ * failed call showed two red rows. The canonical row is the one to keep: it carries the tool's own
+ * name, input and result.
+ *
+ * A wrapper folds onto the first LATER canonical `tool_use` whose name equals its `input.toolId`
+ * and that no earlier wrapper has claimed; its `tool_result` events go with it. A wrapper with no
+ * such canonical row (refused before the bridge, e.g. a read-only 403) stays, so its error is not
+ * hidden.
+ *
+ * @param events - The event list, normally already passed through {@link dedupeToolUsesById}.
+ * @returns A new array without the folded wrappers, or the original reference when none fold.
+ * @complexity O(n·w): n events, w wrapper calls (a handful per message).
+ */
+export declare function foldDelegatedWrapperCalls({ events }: {
+    events: AgentEvent[] | undefined;
+}): AgentEvent[];
 //# sourceMappingURL=tool-events.d.ts.map

package/dist/core/tool-events.js

@@ -33,4 +33,65 @@ export function dedupeToolUsesById({ events }) {
     }
     return deduped ?? events;
 }
+/** The two delegated-tool gateways `@jini-ai/mcp` hosts: the write gateway and its read-only companion. */
+const DELEGATED_WRAPPER_PATTERN = /^(?:mcp__.+__)?execute_(?:readonly_)?delegated_tool$/;
+/**
+ * Whether `name` is a delegated-tool transport wrapper — `execute_delegated_tool` or
+ * `execute_readonly_delegated_tool`, bare or as an MCP client names it (`mcp__<server>__…`). Its real
+ * tool id is in `input.toolId`. The one shared definition, so a renderer and the run-activity line
+ * cannot disagree about which names are wrappers (both once missed the read-only gateway).
+ *
+ * @complexity O(n) in the length of `name`.
+ */
+export function isDelegatedWrapperToolName({ name }) {
+    return DELEGATED_WRAPPER_PATTERN.test(name);
+}
+function wrapperToolId(event) {
+    if (event.kind !== 'tool_use' || !isDelegatedWrapperToolName({ name: event.name }))
+        return undefined;
+    const input = event.input;
+    const toolId = typeof input === 'object' && input !== null ? input.toolId : undefined;
+    return typeof toolId === 'string' && toolId ? toolId : undefined;
+}
+/**
+ * Drop each delegated-tool wrapper call that the daemon also reported as its own canonical row,
+ * so one call shows as one row.
+ *
+ * WHY. A delegated call arrives twice: the vendor CLI's wrapper `tool_use`
+ * (`mcp__jini__execute_delegated_tool {toolId, input}`, with the CLI's `toolu_…` id) and the
+ * daemon bridge's canonical `tool_use` named after the real tool (`content_stats`, with a fresh
+ * UUID from `@jini-ai/mcp`). The ids differ, so {@link dedupeToolUsesById} cannot merge them, and a
+ * failed call showed two red rows. The canonical row is the one to keep: it carries the tool's own
+ * name, input and result.
+ *
+ * A wrapper folds onto the first LATER canonical `tool_use` whose name equals its `input.toolId`
+ * and that no earlier wrapper has claimed; its `tool_result` events go with it. A wrapper with no
+ * such canonical row (refused before the bridge, e.g. a read-only 403) stays, so its error is not
+ * hidden.
+ *
+ * @param events - The event list, normally already passed through {@link dedupeToolUsesById}.
+ * @returns A new array without the folded wrappers, or the original reference when none fold.
+ * @complexity O(n·w): n events, w wrapper calls (a handful per message).
+ */
+export function foldDelegatedWrapperCalls({ events }) {
+    if (!events || events.length === 0)
+        return [];
+    const claimed = new Set();
+    const folded = new Set();
+    events.forEach((event, i) => {
+        const toolId = wrapperToolId(event);
+        // A replayed wrapper (same id) must not claim a second canonical row.
+        if (toolId === undefined || event.kind !== 'tool_use' || folded.has(event.id))
+            return;
+        const match = events.findIndex((other, j) => j > i && !claimed.has(j) && other.kind === 'tool_use' && other.name === toolId);
+        if (match === -1)
+            return;
+        claimed.add(match);
+        folded.add(event.id);
+    });
+    if (folded.size === 0)
+        return events;
+    return events.filter((event) => !((event.kind === 'tool_use' && folded.has(event.id)) ||
+        (event.kind === 'tool_result' && folded.has(event.toolUseId))));
+}
 //# sourceMappingURL=tool-events.js.map

package/dist/core/tools.d.ts

@@ -10,7 +10,7 @@
  * archived provenance ledger.
  */
 import type { ToolResultEvent, ToolResultMediaBlock, ToolUseEvent } from './events.js';
-export { dedupeToolUsesById } from './tool-events.js';
+export { dedupeToolUsesById, foldDelegatedWrapperCalls, isDelegatedWrapperToolName } from './tool-events.js';
 /** The four-state tool-call lifecycle agreed across AG-UI / CopilotKit / LangGraph render props. */
 export type ToolStatus = 'inProgress' | 'executing' | 'complete' | 'error';
 /** The render-prop payload a tool-call UI needs, independent of any framework. */

package/dist/core/tools.js

@@ -1,4 +1,4 @@
-export { dedupeToolUsesById } from './tool-events.js';
+export { dedupeToolUsesById, foldDelegatedWrapperCalls, isDelegatedWrapperToolName } from './tool-events.js';
 /**
  * Map a tool call to its AG-UI-style lifecycle status.
  *

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

@@ -16,6 +16,6 @@
  * `@deprecated`, so every existing `import { ChatPane } from '@jini-ai/chat/react'` keeps working
  * unchanged. New code should import from this subpath directly.
  */
-export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './features/chat-pane/index.js';
-export type { AgentRuntimePickerProps, ByokRuntimeSummary, ChatPaneActivity, ChatPaneAgent, ChatPaneAgentBridgeAccess, ChatPaneAgentControlOptions, ChatPaneAgentOption, ChatPaneAgentSelection, ChatPaneAgentToolAction, ChatPaneAgentToolDef, ChatPaneAgentToolInputSchema, ChatPaneAgentToolRisk, ChatPaneAttachmentUploadOptions, ChatPaneComposerHandle, ChatPaneProps, ChatPaneRunContext, ChatPaneRunContextInput, ChatPaneRuntimeAccess, ChatPaneVariant, ChatPaneWorkingDirectoryAccess, CreateDaemonAttachmentUploaderOptions, CreateMcpUiToolCallerOptions, McpUiToolCallRequest, RuntimePickerPlacement, UseChatPaneAgentControlOptions, UseChatPaneOptions, UseChatPaneResult, UseChatPaneRuntimeInventoryOptions, UseChatPaneRuntimeInventoryResult, UseChatPaneWorkingDirectoryOptions, UseChatPaneWorkingDirectoryResult, } from './features/chat-pane/index.js';
+export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './features/chat-pane/index.js';
+export type { AgentRuntimePickerProps, ByokRuntimeSummary, ChatPaneActivity, ChatPaneAgent, ChatPaneAgentBridgeAccess, ChatPaneAgentControlOptions, ChatPaneAgentOption, ChatPaneAgentSelection, ChatPaneAgentToolAction, ChatPaneAgentToolDef, ChatPaneAgentToolInputSchema, ChatPaneAgentToolRisk, ChatPaneAttachmentUploadOptions, ChatPaneComposerHandle, ChatPaneProps, ChatPaneRunContext, ChatPaneRunContextInput, ChatPaneRuntimeAccess, ChatPaneVariant, ChatPaneWorkingDirectoryAccess, CreateDaemonAttachmentUploaderOptions, CreateMcpUiToolCallerOptions, CreateTypedAnswerPosterOptions, DeliverTypedAnswer, McpUiToolCallRequest, RuntimePickerPlacement, TypedAnswerDelivery, TypedAnswerNotice, UseChatPaneAgentControlOptions, UseChatPaneOptions, UseChatPaneResult, UseChatPaneRuntimeInventoryOptions, UseChatPaneRuntimeInventoryResult, UseChatPaneWorkingDirectoryOptions, UseChatPaneWorkingDirectoryResult, } from './features/chat-pane/index.js';
 //# sourceMappingURL=chat-pane.d.ts.map

package/dist/react/chat-pane.js

@@ -16,5 +16,5 @@
  * `@deprecated`, so every existing `import { ChatPane } from '@jini-ai/chat/react'` keeps working
  * unchanged. New code should import from this subpath directly.
  */
-export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './features/chat-pane/index.js';
+export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './features/chat-pane/index.js';
 //# sourceMappingURL=chat-pane.js.map

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

@@ -36,7 +36,7 @@
  * fallback that `onError` can retract - never a second, competing source of truth for a format the
  * server already classified.
  */
-import { type MouseEvent, type RefObject, type SyntheticEvent } from 'react';
+import { type MouseEvent, type RefCallback, type SyntheticEvent } from 'react';
 import type { ChatAttachment } from '../../core/index.js';
 export type AttachmentPreviewStatus = 'image' | 'text' | 'unsupported';
 /** Hard cap on rendered text-preview characters, so a large attached log/CSV cannot hang the tab painting one giant `<pre>`. */
@@ -45,12 +45,25 @@ export declare const MAX_TEXT_PREVIEW_CHARS = 200000;
 export declare function looksLikeImageAttachment({ attachment }: {
     attachment: Pick<ChatAttachment, 'kind' | 'name'>;
 }): boolean;
+/**
+ * Reads `file` as text via `FileReader`, not the newer `Blob.prototype.text()` promise API: both
+ * are supported in every real evergreen browser, but jsdom (this package's test environment,
+ * verified directly - `File`/`Blob` here has no `.text`/`.arrayBuffer` at all) implements
+ * `FileReader.readAsText` while leaving `.text()` unimplemented. Choosing the form the test
+ * environment can actually exercise avoids a test-only monkeypatch of a browser primitive whose
+ * production behavior isn't in question - only its jsdom coverage was.
+ */
+export declare function readFileAsText({ file }: {
+    file: File;
+}, { createReader }?: {
+    createReader?: () => FileReader;
+}): Promise<string>;
 export interface AttachmentTextPreview {
     content: string;
     truncated: boolean;
 }
 export interface AttachmentPreviewController {
-    dialogRef: RefObject<HTMLDialogElement | null>;
+    dialogRef: RefCallback<HTMLDialogElement>;
     status: AttachmentPreviewStatus;
     imageUrl: string | undefined;
     onImageError: () => void;
@@ -71,5 +84,9 @@ export interface AttachmentPreviewController {
 export declare function useAttachmentPreviewModal({ attachment, onClose }: {
     attachment: ChatAttachment;
     onClose: () => void;
+}, { readText }?: {
+    readText?: (required: {
+        file: File;
+    }) => Promise<string>;
 }): AttachmentPreviewController;
 //# sourceMappingURL=AttachmentPreviewModal.hooks.d.ts.map

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

@@ -36,7 +36,7 @@
  * fallback that `onError` can retract - never a second, competing source of truth for a format the
  * server already classified.
  */
-import { useEffect, useRef, useState } from 'react';
+import { useEffect, useState } from 'react';
 import { getAttachmentPreviewSource } from '../hooks/attachment-preview-cache.js';
 import { formatAttachmentSize } from './AttachmentTray.js';
 /** Extensions attempted as an `<img>` even when `attachment.kind` says otherwise — see module doc. */
@@ -64,9 +64,9 @@ function looksLikeTextAttachment(name) {
  * environment can actually exercise avoids a test-only monkeypatch of a browser primitive whose
  * production behavior isn't in question - only its jsdom coverage was.
  */
-function readFileAsText(file) {
+export function readFileAsText({ file }, { createReader = () => new FileReader() } = {}) {
     return new Promise((resolve, reject) => {
-        const reader = new FileReader();
+        const reader = createReader();
         reader.onload = () => resolve(typeof reader.result === 'string' ? reader.result : '');
         reader.onerror = () => reject(reader.error ?? new Error('Failed to read attachment as text'));
         reader.readAsText(file);
@@ -81,6 +81,47 @@ function readFileAsText(file) {
 function canCreateObjectUrl() {
     return typeof URL !== 'undefined' && typeof URL.createObjectURL === 'function';
 }
+/**
+ * Opens `dialog` as a modal and returns the matching close, which also restores focus to whatever
+ * was focused when it opened — see this module's doc on why the restore is explicit rather than left
+ * to the browser's own (jsdom-absent) default.
+ */
+function openModalDialog(dialog) {
+    const trigger = document.activeElement;
+    if (typeof dialog.showModal === 'function') {
+        if (!dialog.open)
+            dialog.showModal();
+    }
+    else {
+        dialog.setAttribute('open', '');
+    }
+    return () => {
+        if (typeof dialog.close === 'function') {
+            if (dialog.open)
+                dialog.close();
+        }
+        else {
+            dialog.removeAttribute('open');
+        }
+        if (trigger instanceof HTMLElement)
+            trigger.focus();
+    };
+}
+/**
+ * The `<dialog>`'s callback ref: open on attach, close + restore focus on detach. A callback ref
+ * rather than an effect reading a ref object, so the element is always in hand — there is no
+ * "not attached" case to guard. React 18 and 19 both call it with the element on mount and `null`
+ * on unmount, and attach always precedes detach, so `close` is set by the time it is called.
+ */
+function createDialogRef() {
+    let close;
+    return (dialog) => {
+        if (dialog)
+            close = openModalDialog(dialog);
+        else
+            close();
+    };
+}
 /**
  * Drives one `AttachmentPreviewModal` instance for `attachment`. The caller conditionally mounts
  * this (one open attachment at a time per `MessageRow`), so mount = open and unmount = close; there
@@ -89,9 +130,12 @@ function canCreateObjectUrl() {
  * read on mount (bounded in practice by the upload route's own 20 MB per-attachment cap, and by
  * {@link MAX_TEXT_PREVIEW_CHARS} for what actually renders).
  */
-export function useAttachmentPreviewModal({ attachment, onClose }) {
-    const dialogRef = useRef(null);
-    const triggerRef = useRef(null);
+export function useAttachmentPreviewModal({ attachment, onClose }, { readText = readFileAsText } = {}) {
+    // Lazy state, not `useCallback`: a new ref identity would make React detach and re-attach it,
+    // closing and reopening the dialog. The caller mounts a fresh instance per opened attachment (never
+    // reuses one instance across two different open attachments), so there is no "attachment changed
+    // while still open" transition for the ref to react to.
+    const [dialogRef] = useState(createDialogRef);
     const [imageFailed, setImageFailed] = useState(false);
     const [imageUrl, setImageUrl] = useState(undefined);
     const [text, setText] = useState(undefined);
@@ -120,7 +164,7 @@ export function useAttachmentPreviewModal({ attachment, onClose }) {
         }
         let canceled = false;
         setTextLoading(true);
-        readFileAsText(cachedFile)
+        readText({ file: cachedFile })
             .then((full) => {
             if (canceled)
                 return;
@@ -142,36 +186,6 @@ export function useAttachmentPreviewModal({ attachment, onClose }) {
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [attemptText, cachedFile]);
-    // Open on mount, close + restore focus on unmount — see this module's doc on why the restore is
-    // explicit rather than left to the browser's own (jsdom-absent) default.
-    useEffect(() => {
-        const dialog = dialogRef.current;
-        if (!dialog)
-            return undefined;
-        triggerRef.current = document.activeElement;
-        if (typeof dialog.showModal === 'function') {
-            if (!dialog.open)
-                dialog.showModal();
-        }
-        else {
-            dialog.setAttribute('open', '');
-        }
-        return () => {
-            if (typeof dialog.close === 'function') {
-                if (dialog.open)
-                    dialog.close();
-            }
-            else {
-                dialog.removeAttribute('open');
-            }
-            if (triggerRef.current instanceof HTMLElement)
-                triggerRef.current.focus();
-        };
-        // Mount/unmount only: the caller mounts a fresh instance per opened attachment (never reuses one
-        // instance across two different open attachments), so there is no "attachment changed while
-        // still open" transition for this effect to react to.
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, []);
     function handleNativeCancel(event) {
         // Always prevented, same reasoning as `ConfirmDialog.hooks.tsx`: the effect above is the single
         // source of truth for open/closed, so Escape still closes — it just does so through `onClose`
@@ -182,7 +196,8 @@ export function useAttachmentPreviewModal({ attachment, onClose }) {
     function handleBackdropClick(event) {
         // A `<dialog>` element's own box is sized to its content; a click landing on the `<dialog>`
         // element itself (rather than a descendant) is a click on the backdrop area outside that box.
-        if (event.target === dialogRef.current)
+        // The handler is bound on the `<dialog>`, so `currentTarget` is that element.
+        if (event.target === event.currentTarget)
             onClose();
     }
     return {