@jini-ai/chat 0.6.17 → 0.6.19

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.6.19
+
+- A direct MCP call (`mcp__<server>__X`, any CLI) shows as one row even when the MCP server normalized its arguments before the bridge saw them: once the CLI's own result has arrived, the call pairs by name with the bridge's `X` row between the two. Equal-input pairing still runs first across the turn; refusals and open calls never pair by name.
+- The chat model picker names raw catalog ids friendly ("Claude Opus 5.5", context and date suffixes kept), shows "Offline fallback" only once the live model list has actually failed rather than while the host is still probing, and closes on Escape from the menu or its trigger even when an ancestor stops the keydown.
+- A reply's "Done · time" runs from the person's send to the run's end for every CLI; the CLI's own reported duration, which leaves out its start-up wait, is only the fallback.
+- Keep failed tool receipts visible unless a matching canonical call also failed, including buffered CLI receipts.
+- Remove an obsolete hook lint directive for an uninstalled rule.
+- Document the two 0.6.x fetch fallback exceptions, inject fetch in repo hosts, and redact expiry/React callback exception logs.
+
 ## 0.6.17
 
 ### Patch Changes

package/dist/core/events.d.ts

@@ -56,6 +56,12 @@ export type AgentEvent = {
     id: string;
     name: string;
     input: unknown;
+    bridgeCall?: {
+        name: string;
+        input: unknown;
+        buffered?: boolean;
+    };
+    toolOrigin?: 'bridge';
 } | {
     kind: 'tool_result';
     toolUseId: string;

package/dist/core/run-events/entry.js

@@ -5,8 +5,19 @@
  * Authenticated routing, ownership, boot repair and storage transactions remain host responsibilities. */
 import { decodeSseFrames, parseSseRecord } from "@jini-ai/core/primitives";
 import { assistantContentFromEvents } from "../assistant-content.js";
+import { recoverableSurfaceResource } from '../surface-recovery.js';
 import { mergeAdjacentTextEvents } from "../compact-events.js";
 import { dedupeToolUsesById } from "../tool-events.js";
+/** Retain executor-decoded display correlation through both live and saved chat reduction.
+ * Only the delegated bridge marks canonical rows; malformed optional metadata is ignored. O(1). */
+function toolCallCorrelation({ payload }) {
+    const call = payload.bridgeCall;
+    return {
+        ...(payload.toolOrigin === 'bridge' ? { toolOrigin: 'bridge' } : {}),
+        ...(isRecord(call) && typeof call.name === 'string' ? { bridgeCall: { name: call.name, input: call.input,
+                ...(call.buffered === true ? { buffered: true } : {}) } } : {}),
+    };
+}
 function wireString(v) {
     if (typeof v === "string")
         return v;
@@ -84,7 +95,8 @@ export function translateRunAgentPayload({ payload }, _options = {}) {
         case "thinking_delta":
             return { kind: "thinking", text: wireString(payload.delta) };
         case "tool_use":
-            return { kind: "tool_use", id: wireString(payload.id), name: wireString(payload.name), input: payload.input };
+            return { kind: "tool_use", id: wireString(payload.id), name: wireString(payload.name), input: payload.input,
+                ...toolCallCorrelation({ payload }) };
         case "tool_result":
             return toolResultEvent(payload);
         case "usage":
@@ -126,7 +138,8 @@ function translateEnvelopePayload(payload) {
         // worst possible failure for a confirmation dialog. Unwrapping here is what makes the two ends
         // meet. `name` must stay `"mcp-ui"` to match `MCP_UI_EXT_EVENT_NAME`.
         case "mcp-ui":
-            return { kind: "ext", name: "mcp-ui", data: payload.resource };
+            return { kind: "ext", name: "mcp-ui", data: recoverableSurfaceResource({ resource: payload.resource,
+                    exchange: 'surfaceExchange' in payload ? payload.surfaceExchange : undefined }) };
         // A2UI's own agent->renderer envelope (`@jini-ai/core`'s `SurfaceEmission` with
         // `channel: "a2ui"`, injected by `@jini-ai/daemon`'s `delegated-tool-bridge.ts` as
         // `{type: "a2ui", message: <AgentToRendererMessage>}`). Unwrapped to the bare `.message` here,

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

@@ -0,0 +1,19 @@
+/** Wire metadata belongs to the channel adapter, never to rendered HTML or model context. */
+export declare const SURFACE_EXCHANGE_META = "jini/surface-exchange";
+export interface SurfaceRecoveryInfo {
+    readonly exchangeId: string;
+    readonly toolId: string;
+    readonly runId: string;
+}
+/** Read only server-issued exchange identity; original tool arguments never cross this boundary.
+ * @complexity O(1). */
+export declare function surfaceRecoveryInfo({ value }: {
+    value: unknown;
+}, _options?: {}): SurfaceRecoveryInfo | undefined;
+/** Preserve the existing bare-resource renderer contract while attaching recovery identity.
+ * @complexity O(1), shallow copies only. Malformed resources remain the renderer's responsibility. */
+export declare function recoverableSurfaceResource({ resource, exchange }: {
+    resource: unknown;
+    exchange: unknown;
+}, _options?: {}): unknown;
+//# sourceMappingURL=surface-recovery.d.ts.map

package/dist/core/surface-recovery.js

@@ -0,0 +1,26 @@
+/** Wire metadata belongs to the channel adapter, never to rendered HTML or model context. */
+export const SURFACE_EXCHANGE_META = 'jini/surface-exchange';
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Read only server-issued exchange identity; original tool arguments never cross this boundary.
+ * @complexity O(1). */
+export function surfaceRecoveryInfo({ value }, _options = {}) {
+    if (!record(value))
+        return undefined;
+    if (typeof value.exchangeId !== 'string' || typeof value.toolId !== 'string' || typeof value.runId !== 'string')
+        return undefined;
+    if (!value.exchangeId || !value.toolId || !value.runId)
+        return undefined;
+    return { exchangeId: value.exchangeId, toolId: value.toolId, runId: value.runId };
+}
+/** Preserve the existing bare-resource renderer contract while attaching recovery identity.
+ * @complexity O(1), shallow copies only. Malformed resources remain the renderer's responsibility. */
+export function recoverableSurfaceResource({ resource, exchange }, _options = {}) {
+    const info = surfaceRecoveryInfo({ value: exchange });
+    if (!info || !record(resource) || !record(resource.resource))
+        return resource;
+    const meta = record(resource.resource._meta) ? resource.resource._meta : {};
+    return { ...resource, resource: { ...resource.resource, _meta: { ...meta, [SURFACE_EXCHANGE_META]: info } } };
+}
+//# sourceMappingURL=surface-recovery.js.map

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

@@ -45,9 +45,14 @@ export declare function isDelegatedWrapperToolName({ name }: {
  * 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.
  *

package/dist/core/tool-events.js

@@ -61,15 +61,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 +94,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 +117,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 +143,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.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.

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) {