@jini-ai/chat 0.6.11 → 0.6.15-rc.1

package/CHANGELOG.md

@@ -1,3 +1,40 @@
+## 0.6.13
+
+### Patch Changes
+
+- 3feabff: Keep standalone MCP-UI questions answered across history replay through resource-bound accepted-input receipts. Preserve readable question and option labels, accessible frame titles, and waiting activity until an answer is recorded.
+- e5f4969: Chat transcript fixes: answered approval/option cards show "<title>: <option label>" instead of raw values; mid-run follow-ups read "Queued — read after the current step" until consumed, render as ordinary transcript rows at the point they were sent; standalone approval forms show "Waiting for your answer above"; text from separate assistant steps is joined with a paragraph break.
+- f1b2266: Keep collapsed tool details compact, bound and redact error previews and tooltips, and show complete stored tool text on expansion. Add long-chat DOM and page-reader regression coverage.
+- 0728914: Engine guard clean-up (`pnpm guard` 106 -> 0): layer, subpath-isolation and module-state findings fixed by moving
+  shared contracts to their owners instead of reaching across domains. Additive public API: `@jini-ai/core/filesystem`
+  (guarded-reader contracts), `useFetchQueryScope` from `@jini-ai/ui` fetch-query (per-provider query scope),
+  `@jini-ai/chat/react` re-exports of the accepted-input, run-state and agent-plugin chat-state helpers. The Claude
+  filesystem probe cache in `@jini-ai/agent-runtime` is instance-owned. No behaviour change intended; host-facing
+  breaks are listed in `owner-store-to-server` and `guard-host-ports`.
+- 0a2b903: Share accessible eye toggles across React credential fields, including multiline question answers,
+  CLI overrides, provider keys, login, new users, password resets, and source configuration. Preserve
+  autofill protection, translated toggle names, agent handles, and secret-answer redaction. Hidden
+  source environment blocks keep names visible and stored values masked until explicitly revealed.
+
+  Chat and user-management require `@jini-ai/ui ^0.5.7` for the new `SecretInput` and `SecretTextarea`
+  exports. Release UI 0.5.7 (or adjust those peer floors to the actual release containing these exports)
+  with these consumers; older UI versions cannot satisfy their imports. Hosts supply `.jini-secret`,
+  `.jini-secret-toggle`, and `.jini-secret--multiline` visual rules.
+
+- Updated dependencies [7479159]
+- Updated dependencies [c31264d]
+- Updated dependencies [0728914]
+- Updated dependencies [6ecbdb2]
+- Updated dependencies [63bacc5]
+  - @jini-ai/core@0.6.13
+
+## 0.6.12
+
+### Patch Changes
+
+- chat: typing while a choice card waits queues the message instead of cancelling its tool call; answered choice cards keep their question and report option labels, not values; mid-run follow-ups read "Queued" until consumed; one steady thinking clock.
+  - @jini-ai/core@0.6.12
+
 ## 0.6.11
 
 ### Patch Changes

package/dist/contracts/chat-bubble-style.d.ts

@@ -1,3 +1,4 @@
-/** Shared bubble styles for server placeholders and mounted DOM widgets; no runtime dependencies. */
-export declare const CHAT_BUBBLE_STYLE = ".jini-chat-bubble{position:fixed;right:var(--jini-embed-right,24px);bottom:24px;width:56px;height:56px;border:0;border-radius:50%;background:var(--jini-chat-accent,var(--color-primary,#2563eb));color:var(--jini-chat-accent-text,#fff);box-shadow:0 4px 16px #0003;cursor:pointer;z-index:var(--jini-embed-z-index,1000);display:grid;place-items:center}\n.jini-chat-bubble[hidden]{display:none!important}\n.jini-chat-bubble svg{width:24px;height:24px}\n.jini-chat-bubble:focus-visible{outline:3px solid var(--jini-chat-accent,#2563eb);outline-offset:3px}\n@media(max-width:480px){.jini-chat-bubble{right:16px;bottom:16px}}\n.jini-chat-bubble[aria-busy=\"true\"]{cursor:progress;opacity:.65}\n.jini-chat-bubble[data-load-failed=\"true\"]{outline:2px solid var(--jini-chat-error,#b91c1c);outline-offset:3px}";
+/** Shared bubble styles for server placeholders and mounted DOM widgets; no runtime dependencies.
+ * Consent can suspend floating UI without moving a tall open panel beyond the viewport. */
+export declare const CHAT_BUBBLE_STYLE = ".jini-chat-vanilla{display:var(--jini-floating-ui-display,block)}.jini-chat-bubble{position:fixed;right:var(--jini-embed-right,24px);bottom:24px;width:56px;height:56px;border:0;border-radius:50%;background:var(--jini-chat-accent,var(--color-primary,#2563eb));color:var(--jini-chat-accent-text,#fff);box-shadow:0 4px 16px #0003;cursor:pointer;z-index:var(--jini-embed-z-index,1000);display:var(--jini-floating-ui-display,grid);place-items:center}\n.jini-chat-bubble[hidden]{display:none!important}\n.jini-chat-bubble svg{width:24px;height:24px}\n.jini-chat-bubble:focus-visible{outline:3px solid var(--jini-chat-accent,#2563eb);outline-offset:3px}\n@media(max-width:480px){.jini-chat-bubble{right:16px;bottom:16px}}\n.jini-chat-bubble[aria-busy=\"true\"]{cursor:progress;opacity:.65}\n.jini-chat-bubble[data-load-failed=\"true\"]{outline:2px solid var(--jini-chat-error,#b91c1c);outline-offset:3px}";
 //# sourceMappingURL=chat-bubble-style.d.ts.map

package/dist/contracts/chat-bubble-style.js

@@ -1,3 +1,4 @@
-/** Shared bubble styles for server placeholders and mounted DOM widgets; no runtime dependencies. */
-export const CHAT_BUBBLE_STYLE = '.jini-chat-bubble{position:fixed;right:var(--jini-embed-right,24px);bottom:24px;width:56px;height:56px;border:0;border-radius:50%;background:var(--jini-chat-accent,var(--color-primary,#2563eb));color:var(--jini-chat-accent-text,#fff);box-shadow:0 4px 16px #0003;cursor:pointer;z-index:var(--jini-embed-z-index,1000);display:grid;place-items:center}\n.jini-chat-bubble[hidden]{display:none!important}\n.jini-chat-bubble svg{width:24px;height:24px}\n.jini-chat-bubble:focus-visible{outline:3px solid var(--jini-chat-accent,#2563eb);outline-offset:3px}\n@media(max-width:480px){.jini-chat-bubble{right:16px;bottom:16px}}\n.jini-chat-bubble[aria-busy="true"]{cursor:progress;opacity:.65}\n.jini-chat-bubble[data-load-failed="true"]{outline:2px solid var(--jini-chat-error,#b91c1c);outline-offset:3px}';
+/** Shared bubble styles for server placeholders and mounted DOM widgets; no runtime dependencies.
+ * Consent can suspend floating UI without moving a tall open panel beyond the viewport. */
+export const CHAT_BUBBLE_STYLE = '.jini-chat-vanilla{display:var(--jini-floating-ui-display,block)}.jini-chat-bubble{position:fixed;right:var(--jini-embed-right,24px);bottom:24px;width:56px;height:56px;border:0;border-radius:50%;background:var(--jini-chat-accent,var(--color-primary,#2563eb));color:var(--jini-chat-accent-text,#fff);box-shadow:0 4px 16px #0003;cursor:pointer;z-index:var(--jini-embed-z-index,1000);display:var(--jini-floating-ui-display,grid);place-items:center}\n.jini-chat-bubble[hidden]{display:none!important}\n.jini-chat-bubble svg{width:24px;height:24px}\n.jini-chat-bubble:focus-visible{outline:3px solid var(--jini-chat-accent,#2563eb);outline-offset:3px}\n@media(max-width:480px){.jini-chat-bubble{right:16px;bottom:16px}}\n.jini-chat-bubble[aria-busy="true"]{cursor:progress;opacity:.65}\n.jini-chat-bubble[data-load-failed="true"]{outline:2px solid var(--jini-chat-error,#b91c1c);outline-offset:3px}';
 //# sourceMappingURL=chat-bubble-style.js.map

package/dist/core/accepted-input.d.ts

@@ -3,6 +3,10 @@ import type { ChatAttachment, ChatMessage } from './messages.js';
 export interface AcceptedChatInput {
     id: string;
     text: string;
+    /** Standalone questions have no owning tool id; a receipt answers the preceding document at its URI. */
+    surfaceUri?: string;
+    /** The card's answer without its title; text retains the complete user bubble. */
+    answerText?: string;
     /** Absent for legacy/ordinary inputs; consumed only after a CLI UUID receipt. */
     deliveryState?: 'queued' | 'consumed';
     attachments?: ChatAttachment[];
@@ -27,10 +31,25 @@ type UserMessageEvent = Extract<AgentEvent, {
         inputs?: AcceptedChatInput[];
     };
 };
+/** Hosts can recover standalone form labels without adding a DOM dependency to core. */
+export interface AcceptedInputProjectionOptions {
+    answerContexts?: ReadonlyMap<string, {
+        input: unknown;
+        includeTitle?: boolean;
+    }>;
+}
 /** Reads the existing event-backed user bubble without depending on a host renderer. */
 export declare function acceptedInputEvent({ event }: {
     event: AgentEvent;
 }, _options?: {}): UserMessageEvent | null;
+/** Bind each unique receipt to the preceding document, never a later outcome or retry at its URI.
+ * Both transcript closure and activity use this projection; resource identity alone is not an answer.
+ * @returns Answer labels keyed by the original ext-event data; no caller mutation or I/O.
+ * @complexity O(e) time/space for events, including replay deduplication by accepted-input id.
+ */
+export declare function recordedSurfaceAnswers({ events }: {
+    events: readonly AgentEvent[];
+}, _options?: {}): ReadonlyMap<unknown, string>;
 /** Builds the same bubble for delivered answers and steering; queues use the existing pending row. */
 export declare function acceptedInputUserEvent({ input, inputs, toolUseId, afterInputId }: {
     input: AcceptedChatInput;
@@ -47,7 +66,7 @@ export declare function acceptedInputUserEvent({ input, inputs, toolUseId, after
  */
 export declare function projectAcceptedInputEvents({ events }: {
     events: readonly AgentEvent[];
-}, _options?: {}): AgentEvent[];
+}, options?: AcceptedInputProjectionOptions): AgentEvent[];
 /** The sole transcript-to-recall projection. A merged queued turn retains its original inputs. */
 export declare function acceptedInputsFromMessages({ messages }: {
     messages: readonly ChatMessage[];

package/dist/core/accepted-input.js

@@ -1,5 +1,5 @@
 /** Accepted composer input has one identity across optimistic display, replay and recall. */
-import { questionAnswerFromResult } from './question-answer.js';
+import { questionAnswerFromResult, questionAnswerLabel } from './question-answer.js';
 import { MID_RUN_USER_MESSAGE_EVENT_NAME } from './turn-usage.js';
 /** Display queue constituents using their accepted identities; storage and delivery retain one turn.
  * MOVE: Receipts travel in events_json, so separate bubbles survive a history reload without another store.
@@ -28,22 +28,53 @@ export function acceptedInputEvent({ event }, _options = {}) {
     const data = event.data;
     return data && typeof data.id === 'string' && typeof data.text === 'string' ? event : null;
 }
+/** Read resource identity without importing the browser/UI parser into core. */
+function surfaceUriOf({ event }, _options = {}) {
+    if (event.kind !== 'ext' || event.name !== 'mcp-ui')
+        return undefined;
+    const data = event.data;
+    return typeof data?.resource?.uri === 'string' ? data.resource.uri : undefined;
+}
+/** Bind each unique receipt to the preceding document, never a later outcome or retry at its URI.
+ * Both transcript closure and activity use this projection; resource identity alone is not an answer.
+ * @returns Answer labels keyed by the original ext-event data; no caller mutation or I/O.
+ * @complexity O(e) time/space for events, including replay deduplication by accepted-input id.
+ */
+export function recordedSurfaceAnswers({ events }, _options = {}) {
+    const latest = new Map();
+    const answers = new Map();
+    const seen = new Set();
+    for (const event of events) {
+        const uri = surfaceUriOf({ event });
+        if (uri !== undefined && event.kind === 'ext')
+            latest.set(uri, event.data);
+        const receipt = acceptedInputEvent({ event })?.data;
+        if (typeof receipt?.surfaceUri !== 'string' || seen.has(receipt.id))
+            continue;
+        seen.add(receipt.id);
+        const document = latest.get(receipt.surfaceUri);
+        if (document !== undefined)
+            answers.set(document, typeof receipt.answerText === 'string' ? receipt.answerText : receipt.text);
+    }
+    return answers;
+}
 /** Project a persisted answer through the same receipt owner as composer input. */
-function questionAnswerEvent({ event, input }, _options = {}) {
+function questionAnswerEvent({ event, input }, { includeTitle = false } = {}) {
     if (event.kind !== 'tool_result')
         return null;
     const text = questionAnswerFromResult({ result: event, input });
     if (text === undefined)
         return null;
+    // A standalone form's bubble reads like its closed card: "<title>: <answer>".
     return { kind: 'ext', name: MID_RUN_USER_MESSAGE_EVENT_NAME,
-        data: { id: `answer:${event.toolUseId}`, text, toolUseId: event.toolUseId } };
+        data: { id: `answer:${event.toolUseId}`, text: includeTitle ? questionAnswerLabel({ input, text }) : text, toolUseId: event.toolUseId } };
 }
 /** Builds the same bubble for delivered answers and steering; queues use the existing pending row. */
 export function acceptedInputUserEvent({ input, inputs, toolUseId, afterInputId }, { receipt = 'optimistic' } = {}) {
     return { kind: 'ext', name: MID_RUN_USER_MESSAGE_EVENT_NAME,
         data: { ...input, ...(receipt === 'optimistic' ? { optimistic: true } : {}), ...(inputs === undefined ? {} : { inputs }), ...(afterInputId === undefined ? {} : { afterInputId }), ...(toolUseId === undefined ? {} : { toolUseId }) } };
 }
-function expandQuestionAnswers({ events }, _options = {}) {
+function expandQuestionAnswers({ events }, { answerContexts } = {}) {
     const savedAnswers = new Set(events.flatMap(event => {
         const input = acceptedInputEvent({ event });
         return input && !input.data.optimistic && input.data.toolUseId ? [input.data.toolUseId] : [];
@@ -51,7 +82,9 @@ function expandQuestionAnswers({ events }, _options = {}) {
     // MOVE: Persisted picks carry values; the original tool input retains their human-readable labels.
     const questions = new Map(events.flatMap(event => event.kind === 'tool_use' ? [[event.id, event.input]] : []));
     const answers = new Map(events.flatMap(event => {
-        const answer = questionAnswerEvent({ event, input: event.kind === 'tool_result' ? questions.get(event.toolUseId) : undefined });
+        const context = event.kind === 'tool_result' ? answerContexts?.get(event.toolUseId) : undefined;
+        const input = context ? context.input : event.kind === 'tool_result' ? questions.get(event.toolUseId) : undefined;
+        const answer = questionAnswerEvent({ event, input }, { includeTitle: context?.includeTitle === true });
         return answer ? [[answer.data.toolUseId, answer]] : [];
     }));
     return events.flatMap(event => {
@@ -87,10 +120,17 @@ function matchOptimisticInput({ input, optimistic, seen }, _options = {}) {
     // Keep predecessor testing before the caller adds this receipt's ids to seen.
     return input.data.toolUseId ? optimistic.byQuestion.get(input.data.toolUseId) : follows ? next : undefined;
 }
+/** Apply authoritative receipt data while retaining local identity and queued constituents. */
 function mergeAcceptedReceipt({ input, pending }, _options = {}) {
-    return { ...input, data: { ...input.data, id: pending.data.id,
-            ...(pending.data.inputs ? { inputs: pending.data.inputs.map(item => ({ ...item, ...(input.data.deliveryState ? { deliveryState: input.data.deliveryState } : {}) })) } : {}),
-            aliases: [...new Set([...(input.data.aliases ?? []), input.data.id, ...(pending.data.aliases ?? [])])] } };
+    // Replayed queue acceptance cannot undo confirmed consumption.
+    const deliveryState = pending.data.deliveryState === 'consumed' ? 'consumed' : input.data.deliveryState ?? pending.data.deliveryState;
+    const { optimistic: _optimistic, afterInputId: _afterInputId, ...pendingData } = pending.data;
+    const aliases = [...new Set([...(input.data.aliases ?? []), input.data.id, ...(pending.data.aliases ?? [])])].filter(id => id !== pending.data.id);
+    return { ...input, data: { ...pendingData, ...input.data, id: pending.data.id,
+            // Legacy acceptance receipts omit state; HTTP acceptance still means queued until consumption.
+            ...(deliveryState === undefined ? {} : { deliveryState }),
+            ...(pending.data.inputs ? { inputs: pending.data.inputs.map(item => ({ ...item, ...(deliveryState ? { deliveryState } : {}) })) } : {}),
+            ...(aliases.length > 0 ? { aliases } : {}) } };
 }
 function acceptedInputIds({ input }, _options = {}) {
     return [input.data.id, ...(input.data.toolUseId ? [`answer:${input.data.toolUseId}`] : []), ...(input.data.aliases ?? [])];
@@ -114,8 +154,9 @@ function reconcileAcceptedInput({ event, optimistic, state }, _options = {}) {
     for (const id of [pending.data.id, ...(pending.data.aliases ?? [])])
         seen.add(id);
     optimistic.byQuestion.delete(input.data.toolUseId ?? '');
-    replaced.add(pending);
-    replacements.set(event, mergeAcceptedReceipt({ input, pending }));
+    // Acceptance can arrive after the reply it triggered. Keep the position where the person sent it.
+    replaced.add(event);
+    replacements.set(pending, mergeAcceptedReceipt({ input, pending }));
 }
 function advanceOptimisticInput({ input, optimistic }, _options = {}) {
     const candidates = optimistic.byText.get(input.data.text);
@@ -130,12 +171,9 @@ function collapseDeliveryReceipts({ events }, _options = {}) {
     for (const event of events) {
         const input = acceptedInputEvent({ event });
         const position = input ? positions.get(input.data.id) : undefined;
-        if (input && position !== undefined && input.data.deliveryState) {
+        if (input && position !== undefined && !input.data.optimistic) {
             const original = acceptedInputEvent({ event: result[position] });
-            // Replayed queue acceptance cannot undo confirmed consumption.
-            const deliveryState = original.data.deliveryState === 'consumed' ? 'consumed' : input.data.deliveryState;
-            result[position] = { ...original, data: { ...original.data, deliveryState,
-                    ...(original.data.inputs ? { inputs: original.data.inputs.map(input => ({ ...input, deliveryState })) } : {}) } };
+            result[position] = mergeAcceptedReceipt({ input, pending: original });
             continue;
         }
         if (input)
@@ -150,8 +188,18 @@ function collapseDeliveryReceipts({ events }, _options = {}) {
  * match by text; two real events with equal text always remain distinct.
  * @complexity O(e + u + a) time, O(e + u) space for e events, u user inputs and total answer-label lookup cost a.
  */
-export function projectAcceptedInputEvents({ events }, _options = {}) {
-    const expanded = expandQuestionAnswers({ events: collapseDeliveryReceipts({ events }) });
+export function projectAcceptedInputEvents({ events }, options) {
+    if (options !== undefined)
+        return projectEvents({ events }, options);
+    // Event arrays are replaced, never mutated, so a transcript update re-projects only changed messages.
+    let projected = defaultProjections.get(events);
+    if (!projected)
+        defaultProjections.set(events, projected = projectEvents({ events }, {}));
+    return projected;
+}
+const defaultProjections = new WeakMap();
+function projectEvents({ events }, options) {
+    const expanded = expandQuestionAnswers({ events: collapseDeliveryReceipts({ events }) }, options);
     const optimistic = collectOptimisticInputs({ events: expanded });
     const state = { replacements: new Map(), replaced: new Set(), seen: new Set() };
     for (const event of expanded)

package/dist/core/ag-ui/entry.d.ts

@@ -72,10 +72,8 @@ export declare function createAgUiToAgentTranslationState({ customEventNames }:
  * Translates one AG-UI event into zero or more chat-core `AgentEvent`s, threading `state` across
  * calls within a single run for tool-call argument accumulation.
  *
- * `TEXT_MESSAGE_START`/`END` and the `REASONING_*` boundary markers translate to nothing: chat-core
- * groups renderable output by a change in `AgentEvent.kind` alone (no message-boundary concept),
- * the same asymmetry `translateRunAgentPayload` already has reducing the OTHER leg of this round
- * trip (daemon wire -> `AgentEvent`) — this function is that reduction's mirror image. The two cases
+ * `TEXT_MESSAGE_START` preserves an explicit step boundary so two assistant messages cannot fuse
+ * into one word. End/reasoning markers carry no text. The two cases
  * with real internal branching (`TOOL_CALL_END`, `CUSTOM`) and the one with a guard (`TOOL_CALL_ARGS`)
  * are pulled into their own named functions above so this switch's own cost is just its case count.
  */

package/dist/core/ag-ui/entry.js

@@ -145,6 +145,14 @@ function accumulateToolCallArgs(toolCallId, delta, state) {
     if (call)
         call.argsJson += delta;
 }
+/** `TEXT_MESSAGE_START` keeps an explicit step boundary so two assistant messages cannot fuse into
+ *  one word; every other unmapped event translates to nothing. Split out so this `if` is scored in
+ *  its own complexity budget rather than the switch's. */
+function translateAgUiStepStart({ event }, _options = {}) {
+    if (event.type !== EventType.TEXT_MESSAGE_START)
+        return [];
+    return [{ kind: 'status', code: 'step_start', label: '', data: { messageId: event.messageId } }];
+}
 /** The `TOOL_CALL_END` case of {@link translateAgUiEventToAgentEvent} — parses the accumulated
  *  args buffer (already removed from `state` by the caller) into one `tool_use` event, or `[]` for
  *  an id with no matching `TOOL_CALL_START`. */
@@ -177,10 +185,8 @@ function translateAgUiCustomEvent(event, names) {
  * Translates one AG-UI event into zero or more chat-core `AgentEvent`s, threading `state` across
  * calls within a single run for tool-call argument accumulation.
  *
- * `TEXT_MESSAGE_START`/`END` and the `REASONING_*` boundary markers translate to nothing: chat-core
- * groups renderable output by a change in `AgentEvent.kind` alone (no message-boundary concept),
- * the same asymmetry `translateRunAgentPayload` already has reducing the OTHER leg of this round
- * trip (daemon wire -> `AgentEvent`) — this function is that reduction's mirror image. The two cases
+ * `TEXT_MESSAGE_START` preserves an explicit step boundary so two assistant messages cannot fuse
+ * into one word. End/reasoning markers carry no text. The two cases
  * with real internal branching (`TOOL_CALL_END`, `CUSTOM`) and the one with a guard (`TOOL_CALL_ARGS`)
  * are pulled into their own named functions above so this switch's own cost is just its case count.
  */
@@ -211,7 +217,7 @@ export function translateAgUiEventToAgentEvent({ event, state }, _options = {})
         case EventType.CUSTOM:
             return translateAgUiCustomEvent(event, state.customEventNames);
         default:
-            return [];
+            return translateAgUiStepStart({ event });
     }
 }
 //# sourceMappingURL=entry.js.map

package/dist/core/assistant-client/ag-ui-transport.js

@@ -79,7 +79,7 @@ export function createAgUiRunClient({ ports }, _options = {}) {
             handlers.onDone(collected);
         };
         const state = createAgUiToAgentTranslationState({ customEventNames: ports.customEventNames }, {});
-        // Deliberately racing the Observable's first `next`/`error` against this Promise rather than
+        // Deliberately racing the Observable's first `next`/`error`/`complete` against this Promise rather than
         // awaiting it directly — `HttpAgent.run()` returns a cold Observable, never a Promise (module
         // doc). The subscription itself keeps running after this Promise settles, driving `handlers`
         // through to `finish()` in the background — matching `startByokRun`'s "resolves once STARTED, not
@@ -115,6 +115,11 @@ export function createAgUiRunClient({ ports }, _options = {}) {
                     finish();
                 },
                 complete: () => {
+                    // An empty stream has no first notification to settle the start promise.
+                    if (!startSettled) {
+                        startSettled = true;
+                        resolve({ runId });
+                    }
                     finish();
                 },
             });

package/dist/core/assistant-client/durable-run-subscription.d.ts

@@ -28,7 +28,8 @@ type CheckpointHandlers = RunHandlers & {
     onCheckpoint?: (message: ChatMessage) => void;
 };
 /** SSE is a view of one attempt. The saved message owns terminal state and can point at a new
- * attempt after recovery; neither a browser 404 nor a closed stream may fail the logical run. */
+ * attempt after recovery; neither a browser 404 nor a closed stream may fail the logical run.
+ * An explicit "gone" result ends observation and releases the caller's streaming state. */
 export declare function followDurableRun({ runId: initialRunId, handlers, signal, binding, ports, notices, bindings }: {
     runId: string;
     handlers: CheckpointHandlers;

package/dist/core/assistant-client/durable-run-subscription.js

@@ -1,6 +1,7 @@
 import { translateRunFrame } from "../run-events/entry.js";
 /** SSE is a view of one attempt. The saved message owns terminal state and can point at a new
- * attempt after recovery; neither a browser 404 nor a closed stream may fail the logical run. */
+ * attempt after recovery; neither a browser 404 nor a closed stream may fail the logical run.
+ * An explicit "gone" result ends observation and releases the caller's streaming state. */
 export function followDurableRun({ runId: initialRunId, handlers, signal, binding, ports, notices, bindings }, { logger = console } = {}) {
     let streamEpoch = 0;
     let runId = initialRunId;
@@ -93,6 +94,7 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
                 return;
             if (message === "gone") {
                 stop();
+                handlers.onDone([]);
                 return;
             }
             applySavedMessage(message);

package/dist/core/assistant-client/transport.js

@@ -406,7 +406,11 @@ export function createAssistantTransportClient({ ports }, _options = {}) {
         const runId = mintByokRunId();
         const controller = new AbortController();
         byokAbortControllers.set(runId, controller);
-        input.signal?.addEventListener("abort", () => controller.abort());
+        // Conversation adoption may have yielded while the subscription was torn down.
+        if (input.signal?.aborted)
+            controller.abort();
+        else
+            input.signal?.addEventListener("abort", () => controller.abort());
         let response;
         try {
             response = await ports.fetch(ports.byokTurnUrl, {

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

@@ -17,6 +17,13 @@
 import type { AgentEvent } from './events.js';
 /** What separates two text runs that a tool call or card sat between. */
 export declare const ASSISTANT_STEP_SEPARATOR = "\n\n";
+/** Only explicit step transitions separate text. Thinking-token heartbeats and raw diagnostics
+ * may occur inside a streamed step and must never split its deltas.
+ * @complexity O(1); no mutation or I/O.
+ */
+export declare function isAssistantStepBoundary({ event }: {
+    event: AgentEvent;
+}, _options?: {}): boolean;
 /**
  * A turn's text, with a paragraph break between runs separated by a tool call or card.
  * A replay of an already-seen tool ID is not a new step, matching the saved-event projection.
@@ -26,7 +33,7 @@ export declare const ASSISTANT_STEP_SEPARATOR = "\n\n";
  */
 export declare function assistantContentFromEvents({ events }: {
     events: readonly AgentEvent[] | undefined;
-}): string;
+}, _options?: {}): string;
 /** The pre-2026-09-27 rule (plain concatenation), kept only so older saved rows still match. */
 export declare function legacyAssistantContentFromEvents({ events }: {
     events: readonly AgentEvent[] | undefined;

package/dist/core/assistant-content.js

@@ -1,11 +1,24 @@
 import { dedupeToolUsesById } from './tool-events.js';
 /** What separates two text runs that a tool call or card sat between. */
 export const ASSISTANT_STEP_SEPARATOR = '\n\n';
-function separatorBefore(out, text) {
+function separatorBefore({ out, text }, _options = {}) {
     if (out.length === 0 || out.endsWith(ASSISTANT_STEP_SEPARATOR) || text.startsWith('\n'))
         return '';
     return out.endsWith('\n') ? '\n' : ASSISTANT_STEP_SEPARATOR;
 }
+/** Only explicit step transitions separate text. Thinking-token heartbeats and raw diagnostics
+ * may occur inside a streamed step and must never split its deltas.
+ * @complexity O(1); no mutation or I/O.
+ */
+export function isAssistantStepBoundary({ event }, _options = {}) {
+    if (event.kind === 'tool_use' || event.kind === 'ext' || event.kind === 'usage')
+        return true;
+    if (event.kind !== 'status')
+        return false;
+    if (event.code !== undefined)
+        return event.code === 'step_start';
+    return event.label === 'thinking' || event.label === 'running';
+}
 /**
  * A turn's text, with a paragraph break between runs separated by a tool call or card.
  * A replay of an already-seen tool ID is not a new step, matching the saved-event projection.
@@ -13,15 +26,15 @@ function separatorBefore(out, text) {
  * @param events - The turn's events, in arrival order.
  * @complexity O(n + total text length) time and O(n) space for n events.
  */
-export function assistantContentFromEvents({ events }) {
+export function assistantContentFromEvents({ events }, _options = {}) {
     let out = '';
     let stepBoundary = false;
     for (const ev of dedupeToolUsesById({ events: events ? [...events] : undefined })) {
-        if (ev.kind === 'tool_use' || ev.kind === 'ext') {
+        if (isAssistantStepBoundary({ event: ev })) {
             stepBoundary = true;
         }
         else if (ev.kind === 'text' && ev.text.length > 0) {
-            out += (stepBoundary ? separatorBefore(out, ev.text) : '') + ev.text;
+            out += (stepBoundary ? separatorBefore({ out, text: ev.text }) : '') + ev.text;
             stepBoundary = false;
         }
     }

package/dist/core/durable-runs/continuation.js

@@ -16,8 +16,12 @@ function delegatedCall(event) {
         return { toolId: input.toolId, input: input.input };
     return { toolId: event.name, input: event.input };
 }
+/** Results that settle their call. An outcome-unknown result does not: the call may have run. */
+function settledResults({ events }, _optional = {}) {
+    return new Map(events.flatMap((event) => event.kind === "tool_result" && event.outcome !== "unknown" ? [[event.toolUseId, event]] : []));
+}
 export function hasUnknownToolCall({ events, toolId, input }, _optional = {}) {
-    const completed = new Set(events.filter((event) => event.kind === "tool_result").map((event) => event.toolUseId));
+    const completed = settledResults({ events }, {});
     const canonical = canonicalToolInput({ value: input }, {});
     return events.some((event) => {
         if (event.kind !== "tool_use" || completed.has(event.id))
@@ -30,7 +34,7 @@ export function hasUnknownToolCall({ events, toolId, input }, _optional = {}) {
     });
 }
 function toolHistory(events) {
-    const results = new Map(events.filter((event) => event.kind === "tool_result").map((event) => [event.toolUseId, event]));
+    const results = settledResults({ events }, {});
     return events.filter((event) => event.kind === "tool_use").map((event) => {
         const result = results.get(event.id);
         return JSON.stringify({ call: delegatedCall(event), result: result ?? "OUTCOME UNKNOWN: verify state before repeating" });

package/dist/core/events.d.ts

@@ -60,6 +60,9 @@ export type AgentEvent = {
     /** Typed media (currently just images) a renderer may show directly. Absent for the
      *  overwhelming majority of tool results, which carry none. */
     media?: readonly ToolResultMediaBlock[];
+    /** Set when the call may or may not have run (its tool RPC connection broke after sending).
+     *  Such a result does not complete the call: a repeat must verify state first. */
+    outcome?: 'unknown';
 } | {
     kind: 'usage';
     inputTokens?: number;

package/dist/core/index.d.ts

@@ -38,4 +38,5 @@ export * from './history-tool-metadata.js';
 export { turnUsage, conversationUsage, replySegments, isReplyBoundary, MID_RUN_USER_MESSAGE_EVENT_NAME, type ChatUsageSummary } from './turn-usage.js';
 export { formatUsageCost } from './usage-format.js';
 export * from './accepted-input.js';
+export * from './question-answer.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -37,4 +37,5 @@ export * from './history-tool-metadata.js';
 export { turnUsage, conversationUsage, replySegments, isReplyBoundary, MID_RUN_USER_MESSAGE_EVENT_NAME } from './turn-usage.js';
 export { formatUsageCost } from './usage-format.js';
 export * from './accepted-input.js';
+export * from './question-answer.js';
 //# sourceMappingURL=index.js.map

package/dist/core/question-answer.d.ts

@@ -1,3 +1,11 @@
+/** @module question-answer — plain transcript text from the ask-choice result contract. */
+/** Optional question context on an MCP-UI resource, before HTML presentation flattens its labels. */
+export declare const SURFACE_QUESTION_META_KEY = "x-jini-chat/question";
+/** The shared title/answer format for closed cards and standalone form receipts. */
+export declare function questionAnswerLabel({ input, text }: {
+    input: unknown;
+    text: string;
+}, _options?: {}): string;
 /** Read a classified result or delivered callback as plain user text. Decline wins over other fields;
  * expiry, invalid answers and unrecognized results produce no user message.
  * @returns Answer text, or undefined when no supported human answer is present; never throws.

package/dist/core/question-answer.js

@@ -1,13 +1,25 @@
 /** @module question-answer — plain transcript text from the ask-choice result contract. */
+/** Optional question context on an MCP-UI resource, before HTML presentation flattens its labels. */
+export const SURFACE_QUESTION_META_KEY = 'x-jini-chat/question';
 function record(value) {
     return typeof value === 'object' && value !== null ? value : {};
 }
+/** The shared title/answer format for closed cards and standalone form receipts. */
+export function questionAnswerLabel({ input, text }, _options = {}) {
+    const question = record(input);
+    const title = [question.title, question.question, question.prompt]
+        .find(value => typeof value === 'string' && value.trim() !== '');
+    return typeof title === 'string' ? `${title}: ${text}` : text;
+}
 /** Resolve a stored option value through the question that offered it. Unknown values stay readable. */
-function optionLabel(group, value) {
+function optionLabel({ group, value }, _options = {}) {
     const options = record(group).options;
     if (!Array.isArray(options))
         return value;
-    const option = options.find(candidate => record(candidate).value === value);
+    const option = options.find(candidate => {
+        const offered = record(candidate);
+        return (offered.value ?? offered.id ?? offered.label) === value;
+    });
     const label = record(option).label;
     return typeof label === 'string' ? label : value;
 }
@@ -15,11 +27,11 @@ function selectedAnswerText({ result, input }, _options = {}) {
     const question = record(input);
     const labels = [];
     if (typeof result.choice === 'string')
-        labels.push(optionLabel(question.singleSelect ?? question, result.choice));
+        labels.push(optionLabel({ group: question.singleSelect ?? question, value: result.choice }));
     if (Array.isArray(result.selections)) {
         for (const selection of result.selections) {
             if (typeof selection === 'string')
-                labels.push(optionLabel(question.multiSelect ?? question, selection));
+                labels.push(optionLabel({ group: question.multiSelect ?? question, value: selection }));
         }
     }
     if (labels.length > 0)

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

@@ -55,7 +55,7 @@ export interface RunActivityOptions {
  * 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.
+ * @complexity O(n) time in events, O(open tool calls + answered surfaces) extra space.
  */
 export declare function deriveRunActivity({ events }: {
     events: readonly AgentEvent[] | undefined;