@jini-ai/chat 0.6.17 → 0.6.21

package/dist/core/tool-events.js

@@ -1,21 +1,6 @@
 import { canonicalJson } from '@jini-ai/core/records';
 import { toolPresentation } from './tool-presentation.js';
-/**
- * Drop repeated `tool_use` events that share an `id`. A retried/duplicated
- * stream can replay the same tool-call id (e.g. reconnect-and-replay landing
- * an event twice); rendering it twice would show a phantom second call.
- * Non-`tool_use` events (and the first occurrence of each id) pass through
- * unchanged and in original order.
- *
- * @param events - The event list to dedupe, or `undefined` for an empty conversation turn.
- * @returns A new array with later duplicate `tool_use` events removed, or the
- *   original array reference when nothing needed to change (cheap no-op for
- *   the common case).
- * @complexity O(n) time / O(k) extra space, where `n` is `events.length` and
- *   `k` is the number of distinct `tool_use` ids seen — one linear pass with
- *   a `Set` membership check.
- */
-export function dedupeToolUsesById({ events }) {
+export function dedupeToolUsesById({ events }, _optional) {
     if (!events || events.length === 0)
         return [];
     const seen = new Set();
@@ -61,15 +46,21 @@ function directMcpToolName({ name }) {
  * Antigravity's adapter-described wrappers require equal inner inputs but may arrive buffered.
  */
 function wrapperCall({ event }, _options = {}) {
-    const wrapper = toolPresentation(event).wrapper;
+    const wrapper = event.bridgeCall ?? toolPresentation(event).wrapper;
+    const bridgeOnly = event.bridgeCall !== undefined;
+    const buffered = bridgeOnly ? event.bridgeCall?.buffered === true : wrapper !== undefined;
     const call = wrapper ?? event;
     if (!isDelegatedWrapperToolName({ name: call.name })) {
         const name = wrapper ? wrapper.name : directMcpToolName({ name: call.name });
-        return name ? { name, input: call.input, matchInput: true, buffered: wrapper !== undefined } : undefined;
+        return name ? { name, input: call.input, matchInput: true, buffered, bridgeOnly } : undefined;
     }
-    const args = call.input !== null && typeof call.input === 'object' ? call.input : {};
-    const name = args.toolId;
-    return typeof name === 'string' && name ? { name, input: args.input, matchInput: wrapper !== undefined, buffered: wrapper !== undefined } : undefined;
+    const inner = delegatedCall({ input: call.input });
+    return inner ? { ...inner, matchInput: wrapper !== undefined, buffered, bridgeOnly } : undefined;
+}
+/** The shared delegated gateway contract, independent of the CLI's envelope. Pure, O(1). */
+function delegatedCall({ input }, _options = {}) {
+    const args = input !== null && typeof input === 'object' ? input : {};
+    return typeof args.toolId === 'string' && args.toolId ? { name: args.toolId, input: args.input } : undefined;
 }
 /**
  * Drop each delegated or direct MCP wrapper call that the daemon also reported as its own canonical row,
@@ -88,9 +79,14 @@ function wrapperCall({ event }, _options = {}) {
  * Antigravity buffers CLI receipts: its adapter-described wrappers match equal inner inputs
  * anywhere in this assistant turn, in appearance order among equal keys. Pass only one turn's events;
  * no state is retained across calls. Wrapper and bridge rows are each claimed at most once.
+ * Receipt and canonical failure states must match: a success cannot consume a failed row,
+ * and an identical successful or pending call cannot account for a refusal before the bridge,
+ * regardless of buffered receipt ordering.
  * A legacy gateway folds onto the first LATER canonical `tool_use` whose name equals its `input.toolId`.
  * A direct call folds onto the first LATER `X` row with structurally equal JSON input that arrives
- * before the CLI's own result for it. No canonical row is claimed twice, and a folded wrapper's
+ * before the CLI's own result for it; failing that, once that result has arrived, onto the first
+ * unclaimed same-name row between the two, since argument normalization can change the bridge's
+ * input (see {@link findCanonicalRow}). No canonical row is claimed twice, and a folded wrapper's
  * `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.
  *
@@ -106,19 +102,24 @@ export function foldDelegatedWrapperCalls({ events }, _options = {}) {
         return [];
     const claimed = new Set();
     const folded = new Set();
-    events.forEach((event, i) => {
-        if (event.kind !== 'tool_use')
-            return;
-        const call = wrapperCall({ event });
-        // A replayed wrapper (same id) must not claim a second canonical row.
-        if (call === undefined || folded.has(event.id))
-            return;
-        const match = findCanonicalRow({ events, wrapper: event, wrapperIndex: i, call, claimed });
-        if (match === -1)
-            return;
-        claimed.add(match);
-        folded.add(event.id);
-    });
+    const failedResults = new Set(events.flatMap(event => event.kind === 'tool_result' && event.isError ? [event.toolUseId] : []));
+    // Equal inputs pair first across the whole turn, so a by-name pairing never takes the row an
+    // exact match needed; only then may a direct call pair by name inside its closed window.
+    for (const byName of [false, true]) {
+        events.forEach((event, i) => {
+            if (event.kind !== 'tool_use')
+                return;
+            const call = wrapperCall({ event });
+            // A replayed wrapper (same id) must not claim a second canonical row.
+            if (call === undefined || folded.has(event.id))
+                return;
+            const match = findCanonicalRow({ events, wrapper: event, wrapperIndex: i, call, claimed, failedResults }, { byName });
+            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)) ||
@@ -127,29 +128,60 @@ export function foldDelegatedWrapperCalls({ events }, _options = {}) {
 /**
  * Index of the first unclaimed canonical row in the wrapper's matching window, or -1. Legacy gateways match
  * on name alone; direct calls and adapter-described wrappers also require equal inner input.
+ *
+ * `byName` (the second pass) lets a direct `mcp__<server>__X` call pair with a same-name row whose
+ * input differs, but only inside a CLOSED window: after the call and before the CLI's own result for
+ * it. The MCP server normalizes arguments before the bridge sees them (an integer string read as the
+ * integer, an alias renamed, see `@jini-ai/mcp`'s `tool-arguments.ts`), so the bridge row's input is
+ * not always the CLI's (demo practice run, 2026-11-02: every such call showed twice). The CLI's result
+ * only returns after the bridge row its call caused, so a same-name row in that window is that call.
+ * An open window (no CLI result yet) and buffered or legacy wrappers never pair by name.
  * @throws CanonicalJsonError if a direct call's input contains non-JSON values.
  * @complexity O(n·s): n events, s canonical input serialization cost.
  */
-function findCanonicalRow({ events, wrapper, wrapperIndex, call, claimed }) {
-    const inputKey = call.matchInput ? canonicalJson({ value: { input: call.input } }) : undefined;
-    const [start, end] = canonicalSearchWindow({ events, wrapper, wrapperIndex, call });
+function findCanonicalRow({ events, wrapper, wrapperIndex, call, claimed, failedResults }, { byName = false } = {}) {
+    const [start, end, closed] = canonicalSearchWindow({ events, wrapper, wrapperIndex, call });
+    const match = matchRule({ call, byName, closed });
+    if (match === undefined)
+        return -1;
+    const inputKey = match.compareInput ? canonicalJson({ value: { input: call.input } }) : undefined;
+    const wrapperFailed = failedResults.has(wrapper.id);
     for (let j = start; j < end; j += 1) {
         const other = events[j];
-        if (claimed.has(j) || other.kind !== 'tool_use' || other.name !== call.name)
-            continue;
-        if (inputKey === undefined || canonicalJson({ value: { input: other.input } }) === inputKey)
+        if (!claimed.has(j) && isCandidateRow({ other, call, wrapperFailed, failedResults, inputKey }))
             return j;
     }
     return -1;
 }
+/** How one pass matches `call`, or undefined when this pass must skip it. Pass two (`byName`) only
+ * revisits direct calls whose window is closed; everything else already had its chance. Pure; O(1). */
+function matchRule({ call, byName, closed }, _options = {}) {
+    if (!byName)
+        return { compareInput: call.matchInput };
+    return closed && call.matchInput && !call.buffered ? { compareInput: false } : undefined;
+}
+/** Whether `other` is an unclaimed row's possible canonical twin: a same-name `tool_use` with the same
+ * outcome and, when `inputKey` is given, structurally equal input. Pure; O(s) input serialization. */
+function isCandidateRow({ other, call, wrapperFailed, failedResults, inputKey }, _options = {}) {
+    if (other.kind !== 'tool_use' || other.name !== call.name)
+        return false;
+    // Adapter-proposed bare/native matches must be bridge rows, never independent CLI executions.
+    if (call.bridgeOnly && other.toolOrigin !== 'bridge')
+        return false;
+    // Outcome parity keeps successes from consuming failed rows and duplicating later refusals.
+    if (wrapperFailed !== failedResults.has(other.id))
+        return false;
+    return inputKey === undefined || canonicalJson({ value: { input: other.input } }) === inputKey;
+}
 /** Pure matching bounds within one turn; O(n) time, O(1) space for n events.
  * Antigravity's buffered receipts cannot establish arrival/result boundaries. Direct MCP calls
  * retain their later-only window so a completed/refused call cannot consume a separate retry.
+ * `closed` is true only when the CLI's own result ends the window (the by-name pass needs it).
  */
 function canonicalSearchWindow({ events, wrapper, wrapperIndex, call }, _options = {}) {
     if (call.buffered)
-        return [0, events.length];
+        return [0, events.length, false];
     const resultIndex = !call.matchInput ? -1 : events.findIndex(other => other.kind === 'tool_result' && other.toolUseId === wrapper.id);
-    return [wrapperIndex + 1, resultIndex === -1 ? events.length : resultIndex];
+    return resultIndex === -1 ? [wrapperIndex + 1, events.length, false] : [wrapperIndex + 1, resultIndex, true];
 }
 //# sourceMappingURL=tool-events.js.map

package/dist/core/turn-usage.d.ts

@@ -40,7 +40,7 @@ export declare function turnUsage({ events }: {
     agentId?: string;
 }): UsageEvent | undefined;
 /** Derive per-turn charges and prefix totals from persisted events_json, for live and reloaded
- * chats alike. Single replies without reported duration use the message's elapsed run time.
+ * chats alike. A single reply's duration is the message's elapsed run time, from send to finish.
  * A message with mid-run replies also gets per-reply `segments`. O(e + m) for e events
  * and m messages; no per-row transcript scans or I/O.
  * @example conversationUsage({ messages: savedMessages }).get('assistant-2') */

package/dist/core/turn-usage.js

@@ -113,7 +113,7 @@ function addUsage({ total, usage }, _optional = {}) {
     return next;
 }
 /** Derive per-turn charges and prefix totals from persisted events_json, for live and reloaded
- * chats alike. Single replies without reported duration use the message's elapsed run time.
+ * chats alike. A single reply's duration is the message's elapsed run time, from send to finish.
  * A message with mid-run replies also gets per-reply `segments`. O(e + m) for e events
  * and m messages; no per-row transcript scans or I/O.
  * @example conversationUsage({ messages: savedMessages }).get('assistant-2') */
@@ -157,9 +157,11 @@ function messageUsage({ message, sessions, totalCostUsd }, _optional = {}) {
     }
     return { usage, segments, totalCostUsd: prefixTotal };
 }
-/** Use the message's elapsed run time when no reply reported a duration; invalid timestamps stay unknown. */
+/** Time one reply from the person's send (`startedAt`) to the run's end, the same way for every CLI.
+ * A CLI's own reported duration leaves out its start-up wait (Claude Code said 42 s for a turn that took
+ * 46.5 s from send to finish), so it is only the fallback when the timestamps are missing or invalid. */
 function fillRunDuration({ usage, message }, _optional = {}) {
-    if (usage.durationMs !== undefined || message.startedAt === undefined || message.endedAt === undefined)
+    if (message.startedAt === undefined || message.endedAt === undefined)
         return;
     const durationMs = message.endedAt - message.startedAt;
     if (Number.isFinite(durationMs) && durationMs >= 0)

package/dist/embed-widget/browser/frontend-session-bridge.d.ts

@@ -72,9 +72,22 @@ export interface FrontendSessionBridge {
         sessionId: string;
         bindToken: string;
     }>;
+    /**
+     * Ensure a connection and wait for its current attachment; an already live binding is reused.
+     * Call after successful host activation. Unlike `ready`, prior readiness cannot satisfy this wait.
+     * Cancellation rejects only this caller's wait; park/failure/close rejects all current waiters.
+     * @example await bridge.rebind({ signal }, {});
+     * @complexity O(1) per waiter; one shared stream, no automatic reconnect after park/failure.
+     */
+    rebind(required?: {
+        signal?: AbortSignal;
+    }, optional?: Record<string, never>): Promise<{
+        sessionId: string;
+        bindToken: string;
+    }>;
     /**
      * The token for the attachment that is live *now*, or `undefined` before the first attach and
-     * after {@link FrontendSessionBridge.close}. Read it at run-start; see the module doc.
+     * after park, suspension, failure or {@link FrontendSessionBridge.close}. Read it at run-start.
      */
     bindToken(): string | undefined;
     close(): void;

package/dist/embed-widget/browser/frontend-session-bridge.js

@@ -27,13 +27,13 @@ import { decodeSseFrames } from '@jini-ai/core/primitives';
  * - **The bind token never leaves this module except to the host.** It arrives on the `attached`
  *   event and must ride to run-start; it deliberately does not appear in any URL (see
  *   `@jini-ai/daemon`'s `FrontendSessionHandle`).
- * - **Read the bind token at send time, not once.** `EventSource` reconnects on its own — after a
- *   daemon restart, a sleeping laptop, or an ordinary network blip — and each reattach mints a new
+ * - **Read the bind token at send time, not once.** After a
+ *   daemon restart, a sleeping laptop, or an ordinary network blip, each reattach mints a new
  *   session and a new token. A host that captured `ready`'s token keeps sending a dead one, every
  *   later run fails to bind, and the only trace is a daemon-side log line: the agent is simply told
  *   "no frontend is bound to this run". `ready` therefore answers "has it attached at least once";
  *   {@link FrontendSessionBridge.bindToken} answers "what is valid now", and only the latter
- *   belongs in a run request.
+ *   belongs in a run request. Park/failure closes the transport; hosts explicitly rebind after wake.
  */
 import { CHAT_CAPABILITIES } from '../../core/index.js';
 import { PAGE_CAPABILITIES, executePageCapability } from '@jini-ai/agentic';
@@ -119,6 +119,8 @@ function readFrame(data) {
  */
 export function createFrontendSessionBridge({ baseUrl: base, openStream, request, fetch, endpointPrefix = '/api/frontend-sessions', headers }, options = {}) {
     const capabilities = claimedCapabilities(options);
+    // 0.6.x compatibility: fetch was optional for published hosts;
+    // remove when fetch injection becomes required in the next minor.
     // The only caller (`respond`) never passes its own signal, so the deadline is the whole signal.
     const send = request ?? (({ url, init, timeoutMs }) => (fetch ?? globalThis.fetch)(url, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
     let sessionId;
@@ -138,6 +140,9 @@ export function createFrontendSessionBridge({ baseUrl: base, openStream, request
     /** Invocation ids already run here, so a stream reconnect cannot double-click a button. */
     const executed = new Set();
     const pending = new Map();
+    const attachments = new Set();
+    let source;
+    let closed = false;
     // A page driver owns one live screen. Serialize its observations, effect and acknowledgement;
     // otherwise a second invocation could overwrite the first one's host-bound navigation plan.
     let pageQueue = Promise.resolve();
@@ -148,7 +153,29 @@ export function createFrontendSessionBridge({ baseUrl: base, openStream, request
         pending.clear();
     };
     const query = capabilities.map((id) => `capability=${encodeURIComponent(id)}`).join('&');
-    const source = openStream({ url: `${base}${endpointPrefix}/stream?${query}`, ...(headers ? { headers: headers() } : {}) });
+    /** Invalidate before any reopen; queued and running page work cannot cross attachments.
+     * O(pending invocations + attachment waiters), with no retained settled waiters. */
+    function invalidate({ error }) {
+        abortPending();
+        pageQueue = Promise.resolve();
+        // The daemon deletes a session's bind token the instant that connection drops, so by the time
+        // this fires the token in hand is already gone from the registry. Holding it until the next
+        // `attached` frame leaves a window where `bindToken()` hands back something dead, and a run
+        // started in that window fails to bind — reported to the agent only as "no frontend is bound
+        // to this run", with the real reason (a reconnect it never saw) nowhere in view.
+        // Reporting no token is the honest answer for a surface that is, right now, not attached.
+        currentBindToken = undefined;
+        sessionId = undefined;
+        for (const waiter of attachments)
+            waiter.reject(error);
+        attachments.clear();
+    }
+    function disconnect({ error }) {
+        const previous = source;
+        source = undefined;
+        invalidate({ error });
+        previous?.close();
+    }
     async function respond(invocationId, body) {
         if (sessionId === undefined)
             throw new Error('the surface is not attached yet');
@@ -169,7 +196,9 @@ export function createFrontendSessionBridge({ baseUrl: base, openStream, request
         const args = { capabilityId: action.capabilityId, input };
         if (options.pageApproval && !options.pageApproval.isDirect(args)) {
             await respond(action.invocationId, { phase: 'approval-pending' });
+            signal.throwIfAborted();
             const answer = await options.pageApproval.request({ ...args, input: structuredClone(input), signal });
+            signal.throwIfAborted();
             // Report the decision before effects, including decline/expiry; the server audits it.
             await respond(action.invocationId, { phase: 'execution-started', decision: answer.confirmed ? 'approved' : answer.reason });
             if (!answer.confirmed)
@@ -197,6 +226,8 @@ export function createFrontendSessionBridge({ baseUrl: base, openStream, request
         }
         catch (error) {
             pending.delete(action.invocationId);
+            if (controller.signal.aborted)
+                return;
             await respondError(action.invocationId, errorMessage(error)).catch(options.onError ?? (() => undefined));
             return;
         }
@@ -207,6 +238,7 @@ export function createFrontendSessionBridge({ baseUrl: base, openStream, request
         try {
             signal.throwIfAborted();
             const projected = await options.onBeforeResponse?.({ action, output });
+            signal.throwIfAborted();
             const acceptedOutput = projected ?? output;
             await respondSuccess(action.invocationId, acceptedOutput);
             signal.throwIfAborted();
@@ -250,44 +282,60 @@ export function createFrontendSessionBridge({ baseUrl: base, openStream, request
         else
             void serveLocally(action, controller);
     }
-    source.addEventListener('message', (event) => {
-        const frame = readFrame(event.data);
-        switch (frame.kind) {
-            case 'cancelled':
-                pending.get(frame.invocationId)?.abort();
+    function connect() {
+        const current = openStream({ url: `${base}${endpointPrefix}/stream?${query}`, ...(headers ? { headers: headers() } : {}) });
+        source = current;
+        current.addEventListener('message', (event) => {
+            if (source !== current)
                 return;
-            case 'attached':
-                abortPending();
-                sessionId = frame.sessionId;
-                currentBindToken = frame.bindToken;
-                // A no-op after the first attach — which is exactly why `currentBindToken` exists.
-                resolveReady({ sessionId, bindToken: currentBindToken });
-                return;
-            case 'refused':
-                rejectReady(new Error(frame.message));
-                return;
-            case 'malformed':
-                options.onError?.(frame.error);
-                return;
-            case 'invocation':
-                handleInvocation(frame.action);
-                return;
-            case 'ignored':
+            const frame = readFrame(event.data);
+            switch (frame.kind) {
+                case 'cancelled':
+                    pending.get(frame.invocationId)?.abort();
+                    return;
+                case 'attached':
+                    abortPending();
+                    sessionId = frame.sessionId;
+                    currentBindToken = frame.bindToken;
+                    // A no-op after the first attach — which is exactly why `currentBindToken` exists.
+                    resolveReady({ sessionId, bindToken: currentBindToken });
+                    for (const waiter of attachments)
+                        waiter.resolve({ sessionId, bindToken: currentBindToken });
+                    attachments.clear();
+                    return;
+                case 'refused': {
+                    const error = new Error(frame.message);
+                    rejectReady(error);
+                    disconnect({ error });
+                    return;
+                }
+                case 'malformed':
+                    options.onError?.(frame.error);
+                    return;
+                case 'invocation':
+                    handleInvocation(frame.action);
+                    return;
+                case 'ignored':
+                    return;
+            }
+        });
+        current.addEventListener('parked', () => {
+            if (source === current)
+                disconnect({ error: new Error('the surface is parked') });
+        });
+        // Intentional visibility pauses keep their transport owner, which reopens on visibility/activity.
+        current.addEventListener('suspended', () => {
+            if (source === current)
+                invalidate({ error: new Error('the surface is suspended') });
+        });
+        current.addEventListener('error', (event) => {
+            if (source !== current)
                 return;
-        }
-    });
-    source.addEventListener('error', (event) => {
-        abortPending();
-        // The daemon deletes a session's bind token the instant that connection drops, so by the time
-        // this fires the token in hand is already gone from the registry. Holding it until the next
-        // `attached` frame leaves a window where `bindToken()` hands back something dead, and a run
-        // started in that window fails to bind — reported to the agent only as "no frontend is bound
-        // to this run", with the real reason (a reconnect it never saw) nowhere in view.
-        // Reporting no token is the honest answer for a surface that is, right now, not attached.
-        currentBindToken = undefined;
-        sessionId = undefined;
-        options.onError?.(event);
-    });
+            disconnect({ error: new Error('the frontend stream failed') });
+            options.onError?.(event);
+        });
+    }
+    connect();
     const bridgeAccess = {
         subscribe(onAction) {
             chatListeners.add(onAction);
@@ -301,21 +349,46 @@ export function createFrontendSessionBridge({ baseUrl: base, openStream, request
         bridgeAccess,
         ready,
         bindToken: () => currentBindToken,
+        async rebind({ signal } = {}, _optional = {}) {
+            signal?.throwIfAborted();
+            if (closed)
+                throw new Error('the frontend bridge is closed');
+            if (sessionId !== undefined && currentBindToken !== undefined)
+                return { sessionId, bindToken: currentBindToken };
+            return new Promise((resolve, reject) => {
+                const cleanup = () => { attachments.delete(waiter); signal?.removeEventListener('abort', abort); };
+                const waiter = {
+                    resolve: (value) => { cleanup(); resolve(value); },
+                    reject: (error) => { cleanup(); reject(error); },
+                };
+                const abort = () => waiter.reject(signal?.reason);
+                attachments.add(waiter);
+                signal?.addEventListener('abort', abort, { once: true });
+                if (!source) {
+                    try {
+                        connect();
+                    }
+                    catch (error) {
+                        disconnect({ error });
+                    }
+                }
+            });
+        },
         close() {
-            abortPending();
-            source.close();
-            chatListeners.clear();
+            closed = true;
             // A closed bridge serves nothing, so binding a run to it would strand that run rather than
             // fail it — this is what stops a torn-down surface (a StrictMode remount, a route change)
             // from handing its dead token to the next run.
-            currentBindToken = undefined;
-            sessionId = undefined;
+            disconnect({ error: new Error('the frontend bridge is closed') });
+            chatListeners.clear();
         },
     };
 }
 /** Authenticated streaming replacement for EventSource when credentials belong in headers.
  * Uses the shared SSE decoder; reconnect creates a new attachment and clears the old token.
  * O(stream bytes), bounded frame buffer; close aborts fetch/readers and the reconnect timer. */
+// 0.6.x compatibility: existing hosts may omit fetch;
+// remove when fetch injection becomes required in the next minor.
 export function openFetchFrontendStream({ url, headers }, { fetch: send = globalThis.fetch, reconnectMs = 1000 } = {}) {
     const events = new EventTarget();
     const abort = new AbortController();
@@ -331,14 +404,14 @@ export function openFetchFrontendStream({ url, headers }, { fetch: send = global
             for await (const frame of decodeSseFrames({ source: streamChunks(response.body) }, { maxBufferChars: 128_000 })) {
                 delay = reconnectMs; // A delivered event proves the connection recovered.
                 if (!abort.signal.aborted)
-                    events.dispatchEvent(new MessageEvent('message', { data: frame.data }));
+                    events.dispatchEvent(new MessageEvent(frame.event === 'parked' ? 'parked' : 'message', { data: frame.data }));
             }
         }
         catch { /* The stream error has one value-free notification below. */ }
         if (abort.signal.aborted)
             return;
         events.dispatchEvent(new Event('error'));
-        if (retryable) {
+        if (retryable && !abort.signal.aborted) {
             retry = setTimeout(() => { void connect(); }, delay);
             delay = Math.min(delay * 2, 30_000);
         }

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

@@ -30,9 +30,9 @@ export interface ComposerProps {
     /** Cancels the in-flight run. Required when `running` is true; ignored otherwise. */
     onCancel?: () => void;
     /**
-     * Cmd/Ctrl+Enter: end the run in flight and send this draft next. Optional — without it the
-     * modifier falls through to the ordinary Enter path, so a host that has not opted in keeps
-     * exactly its previous behavior.
+     * Cmd/Ctrl+Enter: optional host send shortcut. ChatPane shares the ordinary mid-run delivery
+     * path so sending keeps the current run going. Without this callback the modifier falls
+     * through to ordinary Enter, so a host that has not opted in keeps its previous behavior.
      */
     onInterrupt?: () => void;
     /**

package/dist/react/components/Composer.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { formatErrorForLog } from '@jini-ai/core';
 /**
  * @module Composer
  *
@@ -21,7 +22,7 @@ import { AttachmentTray } from './AttachmentTray.js';
 import { ComposerDiscoveryMenu, ComposerSlashMenu } from './ComposerDiscovery.js';
 import { appendComposerDiscovery, composerDiscoveryMenuPosition, composerSlashMenuPosition, filterComposerDiscovery, parseComposerSlashQuery, replaceComposerSlashTrigger, resolveComposerSlashInvocation, resolveComposerSlashKeyAction, } from './composer-discovery.js';
 function reportComposerHostEffectFailure(effectName, error) {
-    console.error(`[@jini-ai/chat] Composer ${effectName} host effect failed:`, error);
+    console.error(`[@jini-ai/chat] Composer ${effectName} host effect failed:`, formatErrorForLog({ error }));
 }
 /**
  * Invokes host code synchronously, then observes either its synchronous result or async failure.
@@ -272,9 +273,9 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
     function submitFromEnter(event) {
         if (disabled || !composer.canSubmit)
             return;
-        // Cmd/Ctrl+Enter ends the current run and sends this next; plain Enter queues behind it.
-        // `sendDisabled` is deliberately NOT consulted on the interrupt path — while a run streams it
-        // is set precisely BECAUSE of that run, which is the one case this modifier exists to act on.
+        // Cmd/Ctrl+Enter uses the host shortcut; ChatPane routes it through the ordinary send guards.
+        // `sendDisabled` is deliberately NOT consulted here: hosts can offer a shortcut while a run
+        // itself blocks ordinary sends. ChatPane queues or delivers live without cancelling the run.
         if ((event.metaKey || event.ctrlKey) && onInterrupt) {
             onInterrupt();
             return;

package/dist/react/components/ConversationList.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { formatErrorForLog } from '@jini-ai/core';
 /**
  * @module ConversationList
  *
@@ -33,7 +34,7 @@ import { ConversationTitleEditor } from './ConversationTitleEditor.js';
  */
 const DOUBLE_CLICK_GRACE_MS = 500;
 function reportConversationListHostEffectFailure(effectName, error) {
-    console.error(`[@jini-ai/chat] ConversationList ${effectName} host effect failed:`, error);
+    console.error(`[@jini-ai/chat] ConversationList ${effectName} host effect failed:`, formatErrorForLog({ error }));
 }
 /** Invokes a host callback and reports a synchronous throw or async rejection without leaving it unhandled. */
 function runConversationListHostEffect(effectName, effect) {

package/dist/react/components/ConversationTitleEditor.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import { formatErrorForLog } from '@jini-ai/core';
 import { useRef, useState } from 'react';
 import { MAX_CONVERSATION_TITLE_LENGTH } from '../../core/conversation-title.js';
 import { useT } from '../hooks/context.js';
@@ -28,7 +29,7 @@ export function ConversationTitleEditor({ title, onCommit, onCancel, className =
             await onCommit(next);
         }
         catch (error) {
-            console.error('[@jini-ai/chat] ConversationTitleEditor onCommit host effect failed:', error);
+            console.error('[@jini-ai/chat] ConversationTitleEditor onCommit host effect failed:', formatErrorForLog({ error }));
         }
     };
     return _jsx("input", { autoFocus: true, className: className, "aria-label": t('Rename chat'), "data-testid": testId, maxLength: MAX_CONVERSATION_TITLE_LENGTH, value: draft, onChange: (event) => setDraft(event.currentTarget.value), onBlur: () => { void finish(); }, onKeyDown: (event) => {

package/dist/react/components/ExtEventErrorBoundary.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import { formatErrorForLog } from '@jini-ai/core';
 /**
  * @module ExtEventErrorBoundary
  *
@@ -25,7 +26,7 @@ export class ExtEventErrorBoundary extends Component {
         // React already surfaces this in the dev console via its own error-boundary reporting; this
         // adds the ext-event `name` React's generic report has no way to know, and gives a host a
         // hook to route it into its own error reporting.
-        console.error(`[ExtEventErrorBoundary] ext event "${this.props.name}" failed to render:`, error);
+        console.error(`[ExtEventErrorBoundary] ext event "${this.props.name}" failed to render:`, formatErrorForLog({ error }));
         this.props.onError?.(error, info);
     }
     render() {

package/dist/react/components/McpUiSurfaceCard.js

@@ -71,6 +71,7 @@ import { useT } from '../hooks/context.js';
 import { useSurfaceExpiry } from '../hooks/useSurfaceExpiry.js';
 import { closedSurfaceLabel, reportDeliveredAnswer } from './mcp-ui-surface-state.js';
 import { surfaceQuestionInput } from './mcp-ui-question-input.js';
+import { useSurfaceRecovery } from '../hooks/useSurfaceRecovery.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. */
@@ -147,18 +148,24 @@ function surfaceInteraction({ resource, answered, onToolCall, onAnswered, onAnsw
 /** Registered against `ext-event-renderer-registry.ts`'s `'mcp-ui'` name — see module doc. */
 export function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLink, maxHeight, call, runStreaming, expiryClock, answered, onAnswered, onAnswerText, answerText, answerRecorded }) {
     const t = useT();
-    const resources = useMemo(() => latestResourcesByUri(events), [events]);
+    const originalResources = useMemo(() => latestResourcesByUri(events), [events]);
+    const recovery = useSurfaceRecovery({ resource: originalResources.length === 1 ? originalResources[0] : undefined,
+        call, runStreaming, onToolCall });
+    const resources = recovery.restored && recovery.resource ? [recovery.resource] : originalResources;
     // 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 single = resources.length === 1 ? resources[0] : undefined;
-    const { displayCall, input, standalone } = useSurfaceQuestionCall({ events, call });
-    const { expiresAtMs, toolCall } = surfaceInteraction({ resource: single, answered, onToolCall, onAnswered, onAnswerText, call: displayCall });
+    const currentEvents = recovery.restored && recovery.resource ? [recovery.resource] : events;
+    const currentCall = recovery.restored ? undefined : call;
+    const { displayCall, input, standalone } = useSurfaceQuestionCall({ events: currentEvents, call: currentCall });
+    const { expiresAtMs, toolCall } = surfaceInteraction({ resource: single, answered, onToolCall: recovery.onToolCall, onAnswered, onAnswerText, call: displayCall });
     const expiry = useSurfaceExpiry({ expiresAtMs }, expiryClock === undefined ? {} : { clock: expiryClock });
     const closed = single === undefined
         ? undefined
-        : closedSurfaceLabel({ t, call, runStreaming, documentsForUri: events.length, expired: expiry?.expired === true });
+        : closedSurfaceLabel({ t, call: currentCall, runStreaming: recovery.live || runStreaming,
+            documentsForUri: currentEvents.length, expired: expiry?.expired === true });
     // A completed call answered the original document; a replacement outcome or retry owns its view.
-    const answer = (events.length === 1 ? questionAnswerFromResult({ result: call?.result, input }) : undefined) ?? answerText;
+    const answer = (currentEvents.length === 1 ? questionAnswerFromResult({ result: currentCall?.result, input }) : undefined) ?? answerText;
     return _jsx(SurfaceCardContent, { resources: resources, single: single, answerRecorded: answerRecorded, answer: answer, closed: closed, call: displayCall, standalone: standalone, t: t, sandboxProxyUrl: sandboxProxyUrl, toolCall: toolCall, onOpenLink: onOpenLink, maxHeight: maxHeight, expiry: expiry });
 }
 /** A standalone form's call may lack the question; its current document supplies the title and

package/dist/react/components/MessageList.js

@@ -38,7 +38,8 @@ export const MessageList = memo(function MessageList({ messages: sourceMessages,
                 message,
                 isLast: message.id === messages[messages.length - 1]?.id,
                 // A reply's start is accepted together with its user turn (`inputPending` clears then).
-                sending: messages[index - 1]?.inputPending === true,
+                // A run id also proves acceptance after reload, when a legacy pending flag can survive.
+                sending: message.runId === undefined && messages[index - 1]?.inputPending === true,
                 isStreaming,
                 usageSummary: usageByMessage.get(message.id),
             }, rowProps)), (pendingPrompts ?? (pendingPrompt ? [pendingPrompt] : [])).map((prompt, index) => (_jsx(QueuedMessage, { prompt: prompt, renderAttachment: rowProps.renderAttachment }, prompt.id ?? index))), awayFromLatest && _jsx(JumpToLatest, { onJump: jumpToLatest })] }));