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

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.js

@@ -1,5 +1,6 @@
 import { acceptedInputEvent, acceptedInputUserEvent, projectAcceptedInputEvents } from '../../../../core/accepted-input.js';
 import { useUserTextGuard } from '../../../hooks/useUserTextGuard.js';
+import { isAwaitingAnswer } from '../../../../core/run-activity.js';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { appendQueuedTurn, describeChatPaneSendBlocker, findAwaitedTypedAnswerId, findChatPaneSendBlocker, findMidRunMessageRunId, isChatPaneQueueableBlocker, resolveChatPaneSelection, } from '../rules.js';
 import { definedProps } from '../../../util/defined-props.js';
@@ -108,11 +109,17 @@ function resolveChatPaneActivity(selectedAgent, conversation) {
         return 'streaming';
     return 'ready';
 }
+/** Hold new input until its uploads or human gate settle; the existing queue owns the retry.
+ * @complexity O(e) in the newest message's events, with no I/O.
+ */
+function waitingForLiveInput({ uploadPending, messages }, _options = {}) {
+    return uploadPending || isAwaitingAnswer({ events: messages.at(-1)?.events });
+}
 /**
  * The host delivery and live run a send can go INTO instead of queueing behind, or `null` when the
  * host offers no mid-run delivery or no run can take it ({@link findMidRunMessageRunId}).
  *
- * @complexity O(1).
+ * @complexity O(e) in the newest message's events.
  */
 function findMidRunTarget({ deliver, blocker, attachmentCount, messages }) {
     if (deliver === undefined)
@@ -181,10 +188,11 @@ export function useChatPane(options) {
     const [storedQueuedInputs, setQueuedInputs] = useState([]);
     // MOVE: Uploads belong to the input that submitted them, even if a later message is queued first.
     const queuedUploadOwnersRef = useRef(new Map());
-    // A send during upload resumes once pixels arrive; a rejected live delivery waits for run end.
-    const queuedForUploadRef = useRef(false);
+    // A send held for uploads or a human card resumes live; a refused delivery waits for run end.
+    const queuedForLiveDeliveryRef = useRef(false);
     const submittedComposerRef = useRef(null);
     const startingPromptRef = useRef(false);
+    const refusedSendRef = useRef(null);
     const [typedAnswerNotice, setTypedAnswerNotice] = useState(null);
     // Shared delivery lock: a second Enter cannot submit the same answer or screenshot twice.
     const deliveringTypedAnswerRef = useRef(false);
@@ -407,11 +415,14 @@ export function useChatPane(options) {
             const last = messages.at(-1);
             if (last?.role !== 'assistant')
                 return messages;
+            const { atEventCount, ...eventBubble } = bubble;
             const event = acceptedInputUserEvent({ input: { id: inputs[0].id, text: bubble.text,
                     ...(inputs[0].deliveryState ? { deliveryState: inputs[0].deliveryState } : {}) },
-                inputs, ...bubble }, { receipt });
+                inputs, ...eventBubble }, { receipt });
+            const events = last.events ?? [];
+            const position = atEventCount ?? events.length;
             return [...messages.slice(0, -1), { ...last,
-                    events: projectAcceptedInputEvents({ events: [...(last.events ?? []), event] }) }];
+                    events: projectAcceptedInputEvents({ events: [...events.slice(0, position), event, ...events.slice(position)] }) }];
         });
     }, [composer, conversation.setMessages]);
     /** Both accepted send paths consume the sent files and rotate the same upload batch. */
@@ -434,18 +445,35 @@ export function useChatPane(options) {
                 latestComposerRef.current.addAttachment(attachment);
         }
     }, []);
-    const finishPromptSend = useCallback(({ accepted, inputs, redaction, submittedDraft, attachments }, _options = {}) => {
+    /** A refused composer send is kept for Retry and goes back only into a composer that is still
+     * empty: text typed (or files staged) while it was sending are never overwritten. */
+    const restoreRefusedDraft = useCallback(({ redaction, draft, attachments }, _options = {}) => {
+        refusedSendRef.current = { redaction, draft, attachments };
+        if (latestDraftRef.current.trim() !== '' || latestAttachmentsRef.current.length > 0)
+            return;
+        latestComposerRef.current.setDraft(draft);
+        for (const attachment of attachments)
+            latestComposerRef.current.addAttachment(attachment);
+    }, []);
+    const finishPromptSend = useCallback(({ accepted, inputs, redaction, submittedDraft, attachments, composerDraft }, _options = {}) => {
         if (!accepted) {
-            restoreQueuedDraft({ inputs, text: redaction.text, attachments });
+            if (composerDraft === undefined)
+                restoreQueuedDraft({ inputs, text: redaction.text, attachments });
+            else
+                restoreRefusedDraft({ redaction, draft: composerDraft, attachments });
             return;
         }
-        if (inputs === undefined && latestDraftRef.current === submittedDraft) {
+        refusedSendRef.current = null;
+        // A composer send emptied the composer when it started; what is there now was typed since.
+        if (composerDraft === undefined && inputs === undefined && latestDraftRef.current === submittedDraft) {
             latestComposerRef.current.setDraft('');
             latestComposerRef.current.closeMention();
         }
         consumeDeliveredAttachments({ attachments });
-    }, [consumeDeliveredAttachments, restoreQueuedDraft]);
-    const sendGuardedPrompt = useCallback(async ({ redaction, inputs, attachments = composer.attachments }, _options = {}) => {
+    }, [consumeDeliveredAttachments, restoreQueuedDraft, restoreRefusedDraft]);
+    /** `composerDraft`: the composer text this send already took out of the composer, so the
+     * composer is never cleared again on acceptance and a refusal hands the text back. */
+    const sendGuardedPrompt = useCallback(async ({ redaction, inputs, attachments = composer.attachments, composerDraft }, _options = {}) => {
         const trimmed = redaction.text.trim();
         assertPromptSendable({ trimmed, sendBlocker });
         if (startingPromptRef.current)
@@ -473,7 +501,7 @@ export function useChatPane(options) {
                 } }));
             if (!mountedRef.current || generation !== typedAnswerGenerationRef.current)
                 return;
-            finishPromptSend({ accepted, inputs, redaction, submittedDraft, attachments });
+            finishPromptSend({ accepted, inputs, redaction, submittedDraft, attachments, composerDraft });
         }
         finally {
             startingPromptRef.current = false;
@@ -483,6 +511,27 @@ export function useChatPane(options) {
     const sendPrompt = useCallback(async (prompt) => {
         await sendGuardedPrompt({ redaction: guard.redact({ text: prompt.trim() }, {}) });
     }, [guard.redact, sendGuardedPrompt]);
+    // Owner, 2026-10-27: the sent text sat in the composer for seconds until the server accepted the
+    // run. The composer empties on send; the text waits here until the start is accepted or refused.
+    const sendComposerPrompt = useCallback(async (prompt) => {
+        if (sendBlocker !== null || startingPromptRef.current)
+            return;
+        const draft = latestDraftRef.current;
+        const attachments = latestAttachmentsRef.current;
+        latestComposerRef.current.setDraft('');
+        latestComposerRef.current.closeMention();
+        for (const attachment of attachments)
+            latestComposerRef.current.removeAttachment(attachment.path);
+        const redaction = guard.redact({ text: prompt.trim() }, {});
+        try {
+            await sendGuardedPrompt({ redaction, attachments, composerDraft: draft });
+        }
+        catch (error) {
+            // A host hook that throws (run context, activity) must not cost the typed text either.
+            restoreRefusedDraft({ redaction, draft, attachments });
+            throw error;
+        }
+    }, [guard.redact, restoreRefusedDraft, sendBlocker, sendGuardedPrompt]);
     // MOVE: Every queue path retains per-message receipts; appendQueuedTurn owns their one-turn delivery.
     // A turn queued against another conversation is not joined — it would never be flushed there anyway.
     const enqueueTurn = useCallback(({ turn, inputs, attachments = composer.attachments }, _options = {}) => {
@@ -532,7 +581,7 @@ export function useChatPane(options) {
             latestComposerRef.current.setDraft('');
     }, []);
     /** HTTP acceptance retains fallback ownership; only an actual consumption receipt removes it. */
-    const retainAcceptedMidRunInput = useCallback(({ outcome, inputs, turn, attachments, afterInputId }, _options = {}) => {
+    const retainAcceptedMidRunInput = useCallback(({ outcome, inputs, turn, attachments, afterInputId, atEventCount }, _options = {}) => {
         const accepted = inputs ?? [{ id: createChatLocalId({}), text: turn.text, attachments,
                 ...(turn.secretRedacted ? { secretRedaction: { secretRedacted: true, count: turn.count } } : {}) }];
         const id = typeof outcome === 'object' ? outcome.id : accepted[0].id;
@@ -545,16 +594,16 @@ export function useChatPane(options) {
         queuedConversationIdRef.current = options.conversationId;
         setQueuedInputs(queued => [...queued, ...retained]);
         recordAcceptedInput({ inputs: retained,
-            bubble: { text: turn.text, ...(afterInputId === undefined ? {} : { afterInputId }) } }, typeof outcome === 'object' ? { receipt: 'accepted' } : {});
+            bubble: { text: turn.text, atEventCount, ...(afterInputId === undefined ? {} : { afterInputId }) } }, typeof outcome === 'object' ? { receipt: 'accepted' } : {});
     }, [options.conversationId, recordAcceptedInput]);
-    const finishMidRunSend = useCallback(({ outcome, inputs, turn, attachments, afterInputId, submittedDraft }, _options = {}) => {
+    const finishMidRunSend = useCallback(({ outcome, inputs, turn, attachments, afterInputId, submittedDraft, atEventCount }, _options = {}) => {
         if (outcome === 'failed') {
             restoreQueuedDraft({ inputs, text: turn.text, attachments });
             setTypedAnswerNotice('failed');
             return;
         }
         if (outcome === 'delivered' || typeof outcome === 'object') {
-            retainAcceptedMidRunInput({ outcome, inputs, turn, attachments, afterInputId });
+            retainAcceptedMidRunInput({ outcome, inputs, turn, attachments, afterInputId, atEventCount });
             clearDeliveredDraft({ inputs, submittedDraft });
             consumeDeliveredAttachments({ attachments });
             return;
@@ -579,19 +628,22 @@ export function useChatPane(options) {
         deliveringTypedAnswerRef.current = false;
         if (!mountedRef.current || generation !== typedAnswerGenerationRef.current)
             return;
-        finishMidRunSend({ outcome, inputs, turn, attachments, afterInputId, submittedDraft });
+        // The reply may stream before HTTP 202 resolves. Anchor the bubble to send time, not response time.
+        finishMidRunSend({ outcome, inputs, turn, attachments, afterInputId, submittedDraft, atEventCount: priorEvents.length });
     }, [composer, conversation, finishMidRunSend]);
     // The ordinary next-turn path: into the running run, else queue behind it, else send now.
     const sendOrdinaryTurn = useCallback(async (prompt) => {
         if (!isChatPaneQueueableBlocker({ blocker: sendBlocker })) {
             if (canSend)
-                await sendPrompt(prompt);
+                await sendComposerPrompt(prompt);
             return;
         }
         const turn = guard.redact({ text: prompt }, {});
         const uploadPending = activeUploadsRef.current.size > 0 || attachmentError !== null;
-        if (uploadPending)
-            queuedForUploadRef.current = queuedTurn === null || queuedForUploadRef.current;
+        // Retry live delivery after the human gate settles, using the same queue as pending uploads.
+        if (waitingForLiveInput({ uploadPending, messages: conversation.messages })) {
+            queuedForLiveDeliveryRef.current = queuedTurn === null || queuedForLiveDeliveryRef.current;
+        }
         // MOVE: The existing queue owns its files; a later steer must join it to preserve send order.
         const target = uploadPending || queuedInputs.some(input => input.liveMessageId === undefined) ? null : findMidRunTarget({
             deliver: options.deliverMidRunMessage,
@@ -617,7 +669,7 @@ export function useChatPane(options) {
         queuedInputs,
         sendBlocker,
         sendIntoRunningTurn,
-        sendPrompt,
+        sendComposerPrompt,
         guard.redact,
     ]);
     const send = useCallback(async () => {
@@ -651,6 +703,16 @@ export function useChatPane(options) {
         sendBlocker,
         sendOrdinaryTurn,
     ]);
+    const retrySend = useCallback(async () => {
+        const refused = refusedSendRef.current;
+        if (refused === null || latestDraftRef.current === refused.draft) {
+            await send();
+            return;
+        }
+        if (sendBlocker !== null || startingPromptRef.current)
+            return;
+        await sendGuardedPrompt({ redaction: refused.redaction, attachments: refused.attachments, composerDraft: refused.draft });
+    }, [send, sendBlocker, sendGuardedPrompt]);
     const sendAsNewMessage = useCallback(async () => {
         const prompt = composerPrompt(composer);
         if (!prompt || composerDeliveryBlocked({ delivering: deliveringTypedAnswerRef.current, starting: startingPromptRef.current, composer, submitted: submittedComposerRef.current }))
@@ -679,7 +741,7 @@ export function useChatPane(options) {
     }, []);
     const cancelQueued = useCallback(() => {
         submittedComposerRef.current = null;
-        queuedForUploadRef.current = false;
+        queuedForLiveDeliveryRef.current = false;
         queuedConversationIdRef.current = undefined;
         discardQueuedUploads({});
         setQueuedInputs([]);
@@ -693,7 +755,7 @@ export function useChatPane(options) {
     // clear blocker. Clear the slot before awaiting so re-renders cannot send it twice.
     useEffect(() => {
         if (queuedTurn === null) {
-            queuedForUploadRef.current = false;
+            queuedForLiveDeliveryRef.current = false;
             return;
         }
         if (queuedConversationIdRef.current !== options.conversationId) {
@@ -705,13 +767,13 @@ export function useChatPane(options) {
         }
         if (activeUploadCount > 0 || attachmentError !== null)
             return;
-        const target = queuedForUploadRef.current ? findMidRunTarget({
+        const target = queuedForLiveDeliveryRef.current ? findMidRunTarget({
             deliver: options.deliverMidRunMessage,
             blocker: sendBlocker, attachmentCount: queuedInputs.flatMap(input => input.attachments).length, messages: conversation.messages,
         }) : null;
         if (target === null && (sendBlocker !== null || awaitingRunReceipts({ inputs: queuedInputs, messages: conversation.messages })))
             return;
-        queuedForUploadRef.current = false;
+        queuedForLiveDeliveryRef.current = false;
         const inputs = queuedInputs;
         const attachments = inputs.flatMap(input => input.attachments);
         setQueuedInputs([]);
@@ -740,9 +802,10 @@ export function useChatPane(options) {
         // `conversation.cancel()` above clears the streaming blocker — the flush effect fires it into
         // the just-reset conversation instead of discarding it like the rest of this turn's state.
         queuedConversationIdRef.current = undefined;
-        queuedForUploadRef.current = false;
+        queuedForLiveDeliveryRef.current = false;
         queuedUploadOwnersRef.current.clear();
         setQueuedInputs([]);
+        refusedSendRef.current = null;
     }, [composer, conversation, options.initialMessages]);
     return {
         secretRedacted: guard.secretRedacted,
@@ -761,6 +824,7 @@ export function useChatPane(options) {
         addAttachments,
         send,
         sendPrompt,
+        retrySend,
         queuedPrompt: queuedTurn?.text ?? null,
         // Accepted live messages already have queued bubbles in the transcript. Their private fallback
         // copy must not create a second composer row whose Cancel button cannot revoke daemon input.

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

@@ -146,13 +146,16 @@ export declare function isTypedAnswerTurn({ blocker, attachmentCount, messages,
  * turn with a known `runId`.
  * Attachment support is decided by the host's delivery, never by dropping them here.
  *
- * @complexity O(1).
+ * A native live-input transport can reject a pending human gate when given another user turn.
+ * Keep ordinary text in the pane's queue until the card's tool settles; typed question answers
+ * have their own delivery path and never pass this guard.
+ * @complexity O(e) in the newest message's events.
  */
 export declare function findMidRunMessageRunId({ blocker, messages }: {
     blocker: ChatPaneSendBlocker | null;
     attachmentCount: number;
     messages: readonly ChatMessage[];
-}): string | null;
+}, _options?: {}): string | null;
 /**
  * MOVE: Display is per-message; delivery is ONE queued turn. A second message behind the same run
  * is appended to that delivery (a blank line apart) rather than replacing it:

package/dist/react/features/chat-pane/rules.js

@@ -1,6 +1,7 @@
 import { configuredPickerModel, pickerModelOptions, isConcretePickerModel } from './model-options.js';
 import { isTerminalRunStatus } from '../../../core/messages.js';
 import { acceptedInputEvent } from '../../../core/accepted-input.js';
+import { isAwaitingAnswer } from '../../../core/run-activity.js';
 function preferredOptionId(options) {
     return options?.find((option) => option.id === 'default')?.id ?? options?.[0]?.id;
 }
@@ -234,12 +235,17 @@ export function isTypedAnswerTurn({ blocker, attachmentCount, messages, toolName
  * turn with a known `runId`.
  * Attachment support is decided by the host's delivery, never by dropping them here.
  *
- * @complexity O(1).
+ * A native live-input transport can reject a pending human gate when given another user turn.
+ * Keep ordinary text in the pane's queue until the card's tool settles; typed question answers
+ * have their own delivery path and never pass this guard.
+ * @complexity O(e) in the newest message's events.
  */
-export function findMidRunMessageRunId({ blocker, messages }) {
+export function findMidRunMessageRunId({ blocker, messages }, _options = {}) {
     if (!isChatPaneQueueableBlocker({ blocker }))
         return null;
     const last = messages.at(-1);
+    if (isAwaitingAnswer({ events: last?.events }))
+        return null;
     return last?.role === 'assistant' && last.runId ? last.runId : null;
 }
 /**

package/dist/react/hooks/useAnsweredCards.js

@@ -8,7 +8,28 @@
  */
 import { useCallback, useMemo, useState } from 'react';
 import { isTerminalRunStatus } from '../../core/messages.js';
-import { acceptedInputEvent } from '../../core/accepted-input.js';
+import { acceptedInputEvent, recordedSurfaceAnswers } from '../../core/accepted-input.js';
+/** Index durable receipts by their existing tool or standalone resource identity.
+ * @complexity O(e + g) time/space for events and groups; no mutation of caller data or I/O.
+ */
+function recordedCardAnswers({ events, groups }, _options = {}) {
+    const receipts = new Map();
+    const surfaces = recordedSurfaceAnswers({ events });
+    for (const event of events) {
+        const receipt = acceptedInputEvent({ event });
+        if (receipt?.data.toolUseId)
+            receipts.set(receipt.data.toolUseId, receipt.data.text);
+    }
+    return new Map(groups.flatMap(group => {
+        const latest = group.events.at(-1);
+        const receipt = group.call?.id === undefined ? undefined : receipts.get(group.call.id);
+        // Grouping binds the call to its FIRST document. Even a late result cannot answer its replacement.
+        // Tool receipts keep their optimistic bubble's position, so projected order is not causal.
+        const originalDocument = group.name !== 'mcp-ui' || group.events.length === 1;
+        const text = surfaces.get(latest) ?? (originalDocument ? receipt : undefined);
+        return text === undefined ? [] : [[group.slot, text]];
+    }));
+}
 /**
  * @param slotOf - Maps an ext event to its render slot (`extEventSlot`).
  * @param events - Accepted-input-projected events, including persisted or optimistic answer receipts.
@@ -20,27 +41,22 @@ import { acceptedInputEvent } from '../../core/accepted-input.js';
  */
 export function useAnsweredCards({ slotOf, events = [], groups = [], runStreaming, runStatus }) {
     const [answered, setAnswered] = useState(() => new Map());
+    // MCP-UI replaces documents in one slot; other protocols retain their stream-wide answer state.
+    const documents = useMemo(() => new Map(groups.map(group => [group.slot,
+        group.name === 'mcp-ui' ? group.events.at(-1) : group.slot])), [groups]);
     // MOVE: Match by tool identity so receipt replay hides only its own card, even for equal answers.
-    const recorded = useMemo(() => {
-        const receipts = new Map();
-        for (const event of events) {
-            const receipt = acceptedInputEvent({ event });
-            if (receipt?.data.toolUseId)
-                receipts.set(receipt.data.toolUseId, receipt.data.text);
-        }
-        const slots = new Map();
-        for (const group of groups) {
-            const text = group.call?.id === undefined ? undefined : receipts.get(group.call.id);
-            if (text !== undefined)
-                slots.set(group.slot, text);
-        }
-        return slots;
-    }, [events, groups]);
+    const recorded = useMemo(() => recordedCardAnswers({ events, groups }), [events, groups]);
     const markAnswered = useCallback((slot, answerText) => {
-        setAnswered((current) => (current.has(slot) ? current : new Map(current).set(slot, answerText)));
-    }, []);
-    const isAnswered = useCallback((slot) => recorded.has(slot) || answered.has(slot), [answered, recorded]);
-    const answerText = useCallback((slot) => recorded.get(slot) ?? answered.get(slot), [answered, recorded]);
+        const document = documents.get(slot);
+        setAnswered(current => current.get(slot)?.document === document && current.has(slot)
+            ? current : new Map(current).set(slot, { document, text: answerText }));
+    }, [documents]);
+    const liveAnswer = useCallback((slot) => {
+        const answer = answered.get(slot);
+        return answer?.document === documents.get(slot) ? answer : undefined;
+    }, [answered, documents]);
+    const isAnswered = useCallback((slot) => recorded.has(slot) || liveAnswer(slot) !== undefined, [liveAnswer, recorded]);
+    const answerText = useCallback((slot) => recorded.get(slot) ?? liveAnswer(slot)?.text, [liveAnswer, recorded]);
     const isRecorded = useCallback((slot) => recorded.has(slot), [recorded]);
     const isAnsweredCard = useCallback((card) => isAnswered(slotOf(card)), [isAnswered, slotOf]);
     // MOVE: Finished runs must keep orphaned questions closed even when the host still reports streaming.

package/dist/react/hooks/useConversation.d.ts

@@ -36,6 +36,12 @@ export interface UseConversationResult {
     conversationId: string | null;
     isStreaming: boolean;
     error: Error | null;
+    /**
+     * Why the newest send never became a run (refused, unreachable, or the connection dropped before
+     * acceptance), or `null`. Its optimistic bubbles are already gone, so a host shows this beside the
+     * composer and offers to send the refused text again. Cleared by the next send.
+     */
+    sendError: Error | null;
     /** `true` when new content just arrived and nothing has told the hook the user already scrolled away — a `<MessageList>` reads this to decide whether to auto-scroll. */
     scrollIntent: boolean;
     sendMessage: (content: string, options?: SendMessageOptions) => Promise<void>;

package/dist/react/hooks/useConversation.js

@@ -39,6 +39,7 @@ export function useConversation(options) {
     const { transport, conversationId = null, agentId, createMessageId = defaultCreateMessageId } = options;
     const [messages, setMessagesState] = useState(() => redactUserHistory({ history: options.initialMessages ?? [] }, { ...(options.redactUserText ? { redactUserText: options.redactUserText } : {}) }));
     const [scrollIntent, setScrollIntent] = useState(false);
+    const [sendRefused, setSendRefused] = useState(false);
     const run = useRunStream({ transport });
     // The assistant message id the currently-active run is writing into.
     const activeAssistantIdRef = useRef(null);
@@ -159,12 +160,13 @@ export function useConversation(options) {
             else if (run.status === 'canceled')
                 runStatus = 'canceled';
             const nextRunId = run.runId ?? m.runId;
+            const events = projectAcceptedInputEvents({ events: mergeRunEvents({ saved: m.events, incoming: run.events }, {}) });
             return {
                 ...m,
                 ...(nextRunId !== undefined ? { runId: nextRunId } : {}),
-                events: projectAcceptedInputEvents({ events: mergeRunEvents({ saved: m.events, incoming: run.events }, {}) }),
+                events,
                 // Replayed completion prefixes cannot erase a saved interrupted segment.
-                content: preserveAssistantContent({ saved: m.content, incoming: assistantContentFromEvents({ events: run.events }) }, {}),
+                content: preserveAssistantContent({ saved: m.content, incoming: assistantContentFromEvents({ events }) }, {}),
                 runStatus,
                 ...(isTerminalRunStatus({ status: runStatus }) ? { endedAt: Date.now() } : {}),
             };
@@ -194,6 +196,7 @@ export function useConversation(options) {
             startedAt: Date.now(),
         };
         activeAssistantIdRef.current = assistantMessage.id;
+        setSendRefused(false);
         const history = redactUserHistory({ history: [...messagesRef.current, userMessage] }, options);
         // Functional, never `[...history, assistantMessage]`: `messagesRef` is the last RENDER's
         // snapshot, and a host that sends from an effect (`useChatPane`'s queued-prompt flush) runs in
@@ -212,7 +215,9 @@ export function useConversation(options) {
             ...(sendOptions.context !== undefined ? { context: sendOptions.context } : {}),
         });
         if (!accepted) {
+            // The bubbles go, but the reason must not: it was rendered only on the assistant bubble.
             setMessagesState(prev => prev.filter(message => message.id !== userMessage.id && message.id !== assistantMessage.id));
+            setSendRefused(true);
             return;
         }
         const inputs = sendOptions.acceptedInputs ?? [{ id: userMessage.id, text: userMessage.content }];
@@ -258,6 +263,8 @@ export function useConversation(options) {
         conversationId,
         isStreaming: run.isStreaming,
         error: run.error,
+        // A Stop before acceptance also returns no run, but leaves no error: nothing to report.
+        sendError: sendRefused ? run.error : null,
         scrollIntent,
         sendMessage,
         cancel,
@@ -265,6 +272,6 @@ export function useConversation(options) {
         setMessages,
         acknowledgeScroll,
         suppressScroll,
-    }), [messages, conversationId, run.isStreaming, run.error, scrollIntent, sendMessage, cancel, retry, setMessages, acknowledgeScroll, suppressScroll]);
+    }), [messages, conversationId, run.isStreaming, run.error, sendRefused, scrollIntent, sendMessage, cancel, retry, setMessages, acknowledgeScroll, suppressScroll]);
 }
 //# sourceMappingURL=useConversation.js.map

package/dist/react/index.d.ts

@@ -168,4 +168,11 @@ export { createAssistantChatsClient } from "./hooks/assistant-chats.js";
 export type { AssistantChatsPort, AssistantChatsClientPorts, AssistantChatsClient, UseAssistantChats } from "./hooks/assistant-chats-contracts.js";
 export { useFabPosition } from "./hooks/fab-position.js";
 export type { FabPositionInput, FabPositionResult } from "./hooks/fab-position.js";
+export type { ChatMessage } from '../core/messages.js';
+export { isTerminalRunStatus } from '../core/messages.js';
+export { AGENT_PLUGIN_STATE_CHANGED, readAgentPluginChatState, writeAgentPluginChatState } from '../core/agent-plugin-chat-state.js';
+export type { AgentPluginUsage, AgentPluginUsage as Usage } from '../core/agent-plugin-chat-state.js';
+export { acceptedInputEvent, acceptedInputUserEvent, projectAcceptedInputEvents } from '../core/accepted-input.js';
+export type { AcceptedChatInput } from '../core/accepted-input.js';
+export { isAwaitingAnswer } from '../core/run-activity.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/react/index.js

@@ -143,4 +143,8 @@ export { cacheAttachmentPreviewSource } from './hooks/attachment-preview-cache.j
 export { readCachedAttachmentBatchId, writeCachedAttachmentBatchId } from './hooks/composer-draft-cache.js';
 export { createAssistantChatsClient } from "./hooks/assistant-chats.js";
 export { useFabPosition } from "./hooks/fab-position.js";
+export { isTerminalRunStatus } from '../core/messages.js';
+export { AGENT_PLUGIN_STATE_CHANGED, readAgentPluginChatState, writeAgentPluginChatState } from '../core/agent-plugin-chat-state.js';
+export { acceptedInputEvent, acceptedInputUserEvent, projectAcceptedInputEvents } from '../core/accepted-input.js';
+export { isAwaitingAnswer } from '../core/run-activity.js';
 //# sourceMappingURL=index.js.map

package/dist/react/message-blocks.d.ts

@@ -85,6 +85,12 @@ export type MessageBlock<Row> = {
     readonly text: string;
     readonly key: string;
 };
+/** Split assistant sections around user receipts so each bubble can be an ordinary transcript row.
+ * @complexity O(b) time/space for b blocks; preserves every block and its order.
+ */
+export declare function splitMidRunBlocks<Row>({ blocks }: {
+    blocks: readonly MessageBlock<Row>[];
+}, _options?: {}): MessageBlock<Row>[][];
 type SlotOf = (ev: {
     readonly name: string;
     readonly data: unknown;

package/dist/react/message-blocks.js

@@ -1,10 +1,32 @@
 import { assistantContentFromEvents, isReplyBoundary, legacyAssistantContentFromEvents } from '../core/index.js';
+import { isAssistantStepBoundary } from '../core/assistant-content.js';
+import { MID_RUN_USER_MESSAGE_EVENT_NAME } from '../core/turn-usage.js';
+/** Split assistant sections around user receipts so each bubble can be an ordinary transcript row.
+ * @complexity O(b) time/space for b blocks; preserves every block and its order.
+ */
+export function splitMidRunBlocks({ blocks }, _options = {}) {
+    const sections = [];
+    let assistant = [];
+    for (const block of blocks) {
+        if (block.kind === 'ext' && block.name === MID_RUN_USER_MESSAGE_EVENT_NAME) {
+            if (assistant.length > 0)
+                sections.push(assistant);
+            sections.push([block]);
+            assistant = [];
+        }
+        else
+            assistant.push(block);
+    }
+    if (assistant.length > 0)
+        sections.push(assistant);
+    return sections;
+}
 /** Whether there is anything besides plain text to place: a tool row, an ext event, or (when asked
  * for) non-blank thinking. With none of these the flat path is identical. */
 function hasSomethingToInterleave({ events, rows }, { includeThinking }) {
     if (rows.length > 0)
         return true;
-    return events.some((ev) => ev.kind === 'ext' || (includeThinking && ev.kind === 'thinking' && ev.text.trim() !== ''));
+    return events.some((ev) => isAssistantStepBoundary({ event: ev }) || (includeThinking && ev.kind === 'thinking' && ev.text.trim() !== ''));
 }
 /** Whether `content` is demonstrably built from the text events. */
 function contentMatchesEvents({ events, content }) {
@@ -71,6 +93,10 @@ function placeEvent({ state, ev }, { slotOf, includeThinking }) {
             placeThinking({ state, text: ev.text });
         return;
     }
+    // Usage and step-start markers separate paragraphs even when no tool/card renders there.
+    // Tool and card events keep their own placement rules (a folded card or repeated tool id never splits).
+    if ((ev.kind === 'usage' || ev.kind === 'status') && isAssistantStepBoundary({ event: ev }))
+        flushText({ state });
     // Emitted per boundary, before any slot dedupe below, so every reply gets its own end marker.
     if (isReplyBoundary({ event: ev }))
         placeReplyEnd({ state });

package/dist/server/durable-runs/accept.d.ts

@@ -11,6 +11,10 @@ export interface RunAcceptancePorts {
         run: DurableRun;
         request: AcceptedRunRequest;
     }, optional: {}) => Promise<void>;
+    /** Observes only a newly committed logical run; replays and recovery never invoke it. */
+    readonly onAccepted?: (required: {
+        run: DurableRun;
+    }, optional: {}) => void;
     readonly attach: (required: DurableRun, optional: {}) => void;
 }
 export declare function createRunAcceptance(ports: RunAcceptancePorts, _optional?: {}): {

package/dist/server/durable-runs/accept.js

@@ -2,9 +2,16 @@ export function createRunAcceptance(ports, _optional = {}) {
     return {
         async accept(required, _options = {}) {
             const request = { ...required.request, contextRef: ports.sanitizeContextRef({ contextRef: required.request.contextRef }, {}) };
-            const run = await ports.store.accept({ ...required, request, runId: ports.mintRunId(), now: ports.now() }, {});
+            const runId = ports.mintRunId();
+            const run = await ports.store.accept({ ...required, request, runId, now: ports.now() }, {});
             if (!run)
                 return null;
+            if (run.runId === runId) {
+                try {
+                    ports.onAccepted?.({ run }, {});
+                }
+                catch { /* An optional observer cannot prevent dispatch of a committed run. */ }
+            }
             // The stub and accepted input are committed BEFORE dispatch. The daemon uses the stored
             // attempt id as its idempotency key, so duplicate POSTs cannot start two executors.
             if (run.message.runStatus === "queued" && run.recoveryCount === 0 && !run.cancelReason) {

package/dist/server/durable-runs/recover.js

@@ -4,8 +4,8 @@ import { continuationRequest } from "../../core/durable-runs/continuation.js";
 import { isAwaitingAnswer } from "../../core/run-activity.js";
 import { RECOVERY_LIMIT, RECOVERY_WINDOW_MS, RUN_STALENESS_MS, SAVED_WORK_NOTICE, AWAITING_ANSWER_NOTICE, EXHAUSTED_NOTICE } from "../../core/durable-runs/policies.js";
 export { RECOVERY_LIMIT, RECOVERY_WINDOW_MS, RUN_STALENESS_MS, SAVED_WORK_NOTICE, AWAITING_ANSWER_NOTICE, EXHAUSTED_NOTICE } from "../../core/durable-runs/policies.js";
-// translateRunFrame saves a run error frame as a status label holding only its message: the
-// daemon's MCP_BRIDGE_UNAVAILABLE code is dropped, so the bridge failure is matched by its text.
+// Older saved run error frames hold only their message: the daemon's MCP_BRIDGE_UNAVAILABLE
+// code was dropped, so the bridge failure is still matched by its text.
 const MCP_BRIDGE_FAILURE = /The assistant's tools did not load \(MCP bridge "jini" status: [^\r\n]*/;
 const STOPPED_NOTICE = "Stopped. Saved work is above.";
 /** Index of the last event matching `match`, or -1.
@@ -33,10 +33,11 @@ function diagnosticLine({ line }, _optional = {}) {
     }
     return [line];
 }
-/** A saved raw event may hold several JSONL lines; filter each before failure classification. */
+/** A saved raw event may hold several JSONL lines; filter each before failure classification.
+ * A status's typed code counts too: a launch `*_UNSUPPORTED` code (any CLI) cannot heal on retry. */
 function diagnosticLines({ event }, _optional = {}) {
     if (event.kind === "status")
-        return [event.label, event.detail ?? ""];
+        return [event.code ?? "", event.label, event.detail ?? ""];
     if (event.kind !== "raw")
         return [];
     return event.line.split(/\r?\n/).flatMap(line => diagnosticLine({ line }));