@jini-ai/chat 0.6.12 → 0.6.15-rc.2

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.d.ts

@@ -82,6 +82,12 @@ export interface UseChatPaneResult extends UseChatPaneWorkingDirectoryResult {
      * silent no-op.
      */
     sendPrompt: (prompt: string) => Promise<void>;
+    /**
+     * Sends the newest refused composer send again (see `conversation.sendError`). When that text is
+     * back in the composer it goes out from there like {@link send}; when something new was typed
+     * since, the refused text goes out on its own and the composer keeps the new typing.
+     */
+    retrySend: () => Promise<void>;
     /**
      * The prompt waiting for the in-flight run to finish, or `null` when nothing is queued. Exposed
      * so the pane can SHOW it — a queued turn that is invisible is indistinguishable from one that

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

@@ -20,15 +20,18 @@ function unconsumedQueuedInputs({ inputs, messages }) {
             const receipt = acceptedInputEvent({ event });
             if (receipt?.data.deliveryState !== 'consumed')
                 continue;
-            for (const input of [receipt.data, ...(receipt.data.inputs ?? [])]) {
-                consumed.add(input.id);
-                for (const alias of input.aliases ?? [])
-                    consumed.add(alias);
-            }
+            recordConsumedInputs({ receipt: receipt.data, consumed });
         }
     }
     return inputs.filter(input => !consumed.has(input.liveMessageId ?? input.id));
 }
+function recordConsumedInputs({ receipt, consumed }) {
+    for (const input of [receipt, ...(receipt.inputs ?? [])]) {
+        consumed.add(input.id);
+        for (const alias of input.aliases ?? [])
+            consumed.add(alias);
+    }
+}
 /** The conversation copies run events onto its messages one effect after streaming stops, so a
  * consumed receipt can still be missing from the transcript when the send blocker clears. A
  * live-accepted copy therefore waits until the run's own message reaches a terminal status. */
@@ -192,6 +195,7 @@ export function useChatPane(options) {
     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);
@@ -414,11 +418,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. */
@@ -441,18 +448,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)
@@ -480,7 +504,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;
@@ -490,6 +514,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 = {}) => {
@@ -539,7 +584,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;
@@ -552,16 +597,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;
@@ -586,13 +631,14 @@ 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 }, {});
@@ -626,7 +672,7 @@ export function useChatPane(options) {
         queuedInputs,
         sendBlocker,
         sendIntoRunningTurn,
-        sendPrompt,
+        sendComposerPrompt,
         guard.redact,
     ]);
     const send = useCallback(async () => {
@@ -660,6 +706,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 }))
@@ -752,6 +808,7 @@ export function useChatPane(options) {
         queuedForLiveDeliveryRef.current = false;
         queuedUploadOwnersRef.current.clear();
         setQueuedInputs([]);
+        refusedSendRef.current = null;
     }, [composer, conversation, options.initialMessages]);
     return {
         secretRedacted: guard.secretRedacted,
@@ -770,6 +827,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/hooks/useChatPaneAgentControl.hooks.js

@@ -1,18 +1,7 @@
 import { useEffect, useRef } from 'react';
+import { getAgentModelContext } from '@jini-ai/agentic/dom';
 import { CHAT_PANE_AGENT_TOOLS } from '../agent-tools.js';
 import { definedProps } from '../../../util/defined-props.js';
-function getModelContext() {
-    const doc = globalThis.document;
-    if (isModelContext(doc?.modelContext))
-        return doc.modelContext;
-    const nav = globalThis.navigator;
-    if (isModelContext(nav?.modelContext))
-        return nav.modelContext;
-    return undefined;
-}
-function isModelContext(value) {
-    return typeof value === 'object' && value !== null && typeof value.registerTool === 'function';
-}
 function requireStringField(input, key) {
     const value = input[key];
     if (typeof value !== 'string' || value.length === 0)
@@ -206,26 +195,33 @@ export function useChatPaneAgentControl({ pane }, options = {}) {
         const cleanups = [];
         // Not registered unless the host opted in: see `webmcp`'s own doc for why this path cannot be
         // gated and therefore must not be on by default.
-        const modelContext = options.webmcp === true ? getModelContext() : undefined;
+        // Feature-detect the draft surface through its shared owner; no `@mcp-b/*` dependency.
+        const modelContext = options.webmcp === true ? getAgentModelContext({
+            host: { candidates: () => [
+                    globalThis.document?.modelContext,
+                    globalThis.navigator?.modelContext,
+                ] },
+        }) : undefined;
         if (modelContext) {
             const controller = new AbortController();
             for (const tool of CHAT_PANE_AGENT_TOOLS) {
                 // `registerTool` is async per the draft IDL, and a polyfill may return undefined instead.
                 // Normalize both, then swallow: registration is best-effort, and a rejected one must not
                 // surface as an unhandled rejection from a React effect.
-                const registered = modelContext.registerTool({
-                    name: tool.id,
-                    description: tool.description,
-                    inputSchema: tool.inputSchema,
-                    execute: (args) => runChatPaneAction(paneRef.current, tool.id, args ?? {}),
-                }, { signal: controller.signal });
+                const registered = modelContext.registerTool({ tool: {
+                        name: tool.id,
+                        description: tool.description,
+                        inputSchema: tool.inputSchema,
+                        execute: (args) => runChatPaneAction(paneRef.current, tool.id, args ?? {}),
+                    } }, { signal: controller.signal });
                 void Promise.resolve(registered).catch(() => undefined);
             }
             cleanups.push(() => {
+                // Aborting the signal is the spec cleanup path; unregisterTool is optional for polyfills.
                 controller.abort();
                 if (modelContext.unregisterTool) {
                     for (const tool of CHAT_PANE_AGENT_TOOLS)
-                        modelContext.unregisterTool(tool.id);
+                        modelContext.unregisterTool({ name: tool.id });
                 }
             });
         }

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/react/tool-call-display.js

@@ -58,8 +58,7 @@ function hideToolCalls({ blocks, runFailed }) {
         const rows = toolRowsForDisplay({ rows: block.rows, mode: 'hidden' }, { recovered, runFailed: failedReply });
         if (rows.length > 0)
             out.push({ ...block, rows });
-        if (block.rows.some((row) => row.status === 'complete'))
-            recovered = true;
+        recovered = block.rows.some((row) => row.status === 'complete') || recovered;
     }
     return collapseToolCalls({ blocks: out.reverse() });
 }

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 }));