@jini-ai/chat 0.5.1 → 0.5.3

package/dist/react/ext-event-renderer-registry.d.ts

@@ -40,6 +40,13 @@ export interface ExtEventRenderProps {
     /** Whether the owning run is still streaming — more events with this `name` may still arrive. */
     runStreaming: boolean;
     runSucceeded: boolean;
+    /**
+     * Whether the owning run is waiting on the person — a card (form, confirm, sign-in) sits on a
+     * still-open tool call (`isAwaitingAnswer` in `core/run-activity.ts`). A "still working" notice
+     * should hide while this is true. Always `false` once the run stops streaming. Optional so a host
+     * that builds these props itself (tests, wrappers) keeps compiling; `MessageRow` always sets it.
+     */
+    awaitingAnswer?: boolean;
     /** The owning message's `ChatMessage.runId`, if known — a renderer that needs to send something back to this specific run (e.g. an A2UI action) needs this; omitted (`undefined`) for a message with no run association. */
     runId: string | undefined;
     /** See {@link ExtEventCall}. Absent when the group's first event arrived outside any tool call. */

package/dist/react/features/chat-pane/components/ChatPane.d.ts

@@ -6,5 +6,5 @@ import type { ChatPaneProps } from '../types.js';
  * @complexity Time/space: O(n) in rendered messages, agents, and suggestions.
  * @overallScore 100/100
  */
-export declare function ChatPane({ transport, agents: injectedAgents, runtimeAccess, runtimeStatusPollMs, title, variant, initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents, daemonOnline, executionMode, apiModeAvailable, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, validateAttachments, composerHandle, placeholder, placeholders, suggestions, workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement, projectFileNames, uploadAttachments, attachmentAccept, disabled, runtimePickerPlacement, composerSlots, header, leadingAccessory, footer, className, style, }: ChatPaneProps): import("react").JSX.Element;
+export declare function ChatPane({ transport, agents: injectedAgents, runtimeAccess, runtimeStatusPollMs, title, variant, initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents, daemonOnline, executionMode, apiModeAvailable, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions, workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement, projectFileNames, uploadAttachments, attachmentAccept, disabled, runtimePickerPlacement, composerSlots, header, leadingAccessory, footer, className, style, }: ChatPaneProps): import("react").JSX.Element;
 //# sourceMappingURL=ChatPane.d.ts.map

package/dist/react/features/chat-pane/components/ChatPane.js

@@ -6,7 +6,7 @@ import { appendComposerDiscovery } from '../../../components/composer-discovery.
 import { MessageList } from '../../../components/MessageList.js';
 import { useT } from '../../../hooks/context.js';
 import { definedProps } from '../../../util/defined-props.js';
-import { isChatPaneApiModeConfigured } from '../rules.js';
+import { describeTypedAnswerNotice, isChatPaneApiModeConfigured } from '../rules.js';
 import { useChatPane } from '../hooks/useChatPane.hooks.js';
 import { useChatPaneAgentControl } from '../hooks/useChatPaneAgentControl.hooks.js';
 import { useChatPaneComposerPlaceholder } from '../hooks/useChatPaneComposerPlaceholder.hooks.js';
@@ -73,8 +73,8 @@ function ChatPaneNoUsableCliMessage({ executionMode, apiModeAvailable, onExecuti
 }
 /** The pane's stack of mutually-independent error/status banners — each condition is its own
  * source of truth, so they are rendered as siblings rather than folded into one derived state. */
-function ChatPaneStatusMessages({ unavailable, scanningAgents, connectingAgents, executionMode, apiModeAvailable, onExecutionModeChange, conversationError, attachmentError, dropReadError, workingDirectoryError, workingDirectoryPending, workingDirectoryInvalid, runtimeInventoryError, t, }) {
-    return (_jsxs(_Fragment, { children: [unavailable && connectingAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Connecting to the assistant…') })) : unavailable && scanningAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Loading available CLIs') })) : unavailable ? (_jsx(ChatPaneNoUsableCliMessage, { executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, t: t })) : null, conversationError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: conversationError.message })) : null, attachmentError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: attachmentError.message })) : null, dropReadError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: dropReadError })) : null, workingDirectoryError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: workingDirectoryError.message })) : null, workingDirectoryPending ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Checking working directory…') })) : workingDirectoryInvalid ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: t('Working directory is unavailable.') })) : null, runtimeInventoryError && !connectingAgents ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: runtimeInventoryError.message })) : null] }));
+function ChatPaneStatusMessages({ unavailable, scanningAgents, connectingAgents, executionMode, apiModeAvailable, onExecutionModeChange, conversationError, attachmentError, dropReadError, workingDirectoryError, workingDirectoryPending, workingDirectoryInvalid, runtimeInventoryError, typedAnswerNotice, onSendAsNewMessage, t, }) {
+    return (_jsxs(_Fragment, { children: [unavailable && connectingAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Connecting to the assistant…') })) : unavailable && scanningAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Loading available CLIs') })) : unavailable ? (_jsx(ChatPaneNoUsableCliMessage, { executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, t: t })) : null, conversationError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: conversationError.message })) : null, attachmentError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: attachmentError.message })) : null, dropReadError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: dropReadError })) : null, workingDirectoryError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: workingDirectoryError.message })) : null, workingDirectoryPending ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Checking working directory…') })) : workingDirectoryInvalid ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: t('Working directory is unavailable.') })) : null, runtimeInventoryError && !connectingAgents ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: runtimeInventoryError.message })) : null, typedAnswerNotice ? (_jsxs("div", { className: "jini-chat-pane__error", role: "alert", children: [t(describeTypedAnswerNotice({ notice: typedAnswerNotice })), typedAnswerNotice === 'not-pending' ? (_jsxs(_Fragment, { children: [' ', _jsx("button", { type: "button", className: "jini-chat-pane__error-action", onClick: onSendAsNewMessage, children: t('Send as a new message') })] })) : null] })) : null] }));
 }
 function ChatPaneWorkingDirectoryBlock({ workingDirectoryAccess, workingDirectoryControlPlacement, pane, t, }) {
     if (workingDirectoryAccess && workingDirectoryControlPlacement === 'below') {
@@ -178,7 +178,7 @@ function ChatPaneComposerArea({ fileDrop, uploadAttachments, pane, disabled, una
  * @complexity Time/space: O(n) in rendered messages, agents, and suggestions.
  * @overallScore 100/100
  */
-export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, runtimeAccess, runtimeStatusPollMs = 5_000, title, variant = 'workspace', initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents = false, daemonOnline = true, executionMode = 'local', apiModeAvailable = false, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, validateAttachments, composerHandle, placeholder, placeholders, suggestions = [], workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement = 'below', projectFileNames, uploadAttachments, attachmentAccept, disabled = false, runtimePickerPlacement = 'up', composerSlots, header, leadingAccessory, footer, className, style, }) {
+export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, runtimeAccess, runtimeStatusPollMs = 5_000, title, variant = 'workspace', initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents = false, daemonOnline = true, executionMode = 'local', apiModeAvailable = false, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions = [], workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement = 'below', projectFileNames, uploadAttachments, attachmentAccept, disabled = false, runtimePickerPlacement = 'up', composerSlots, header, leadingAccessory, footer, className, style, }) {
     const t = useT();
     const composerPlaceholder = useChatPaneComposerPlaceholder({ placeholder: placeholder, placeholders: placeholders });
     const inventory = useChatPaneRuntimeInventory(definedProps({ source: {
@@ -210,6 +210,7 @@ export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, run
             onChangeWorkingDirectory,
             workingDirectoryAccess,
             apiModeConfigured,
+            deliverTypedAnswer,
         } }));
     // Mirrors `Composer.tsx`'s own `draftRef`: `composerHandle.insertText` (below) is called from
     // OUTSIDE any render, so it cannot close over `pane.composer.draft` directly — that would freeze
@@ -262,6 +263,6 @@ export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, run
             footerAccessories: (_jsx(AgentRuntimePicker, { agents: runtimeView.agents, value: pane.selection, onChange: pane.setSelection, ...definedProps({ source: { onRescan: runtimeView.rescanAgents } }), scanning: runtimeView.scanningAgents, daemonOnline: runtimeView.daemonOnline, placement: runtimePickerPlacement, executionMode: executionMode, apiModeAvailable: apiModeAvailable, ...definedProps({ source: { onExecutionModeChange, byokRuntime, onByokModelChange } }) })),
         } });
     const { rootRef, controlsRef } = useChatPaneControlsHeight();
-    return (_jsxs("section", { className: chatPaneClassName(variant, className), style: style, "data-activity": pane.activity, ref: rootRef, children: [_jsx("style", { "data-jini-chat-pane-styles": "true", children: CHAT_PANE_STYLES }), resolveChatPaneHeader(header, title, pane.reset, t), _jsxs("div", { className: "jini-chat-pane__body", children: [_jsx(MessageList, { messages: pane.conversation.messages, isStreaming: pane.conversation.isStreaming, scrollIntent: pane.conversation.scrollIntent, onScrolled: pane.conversation.acknowledgeScroll, pendingPrompt: pane.queuedPrompt === null ? null : { text: pane.queuedPrompt, onCancel: pane.cancelQueued }, ...(projectFileNames === undefined ? {} : { projectFileNames: new Set(projectFileNames) }) }), _jsxs("div", { className: "jini-chat-pane__controls", ref: controlsRef, children: [_jsx(ChatPaneSuggestionsRow, { suggestions: suggestions, onSelect: pane.composer.setDraft, t: t }), _jsx(ChatPaneStatusMessages, { unavailable: unavailable, scanningAgents: runtimeView.scanningAgents, connectingAgents: runtimeView.connectingAgents, executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, conversationError: pane.conversation.error, attachmentError: pane.attachmentError, dropReadError: fileDrop.dropReadError, workingDirectoryError: pane.workingDirectoryError, workingDirectoryPending: pane.workingDirectoryPending, workingDirectoryInvalid: pane.workingDirectoryInvalid, runtimeInventoryError: inventory.runtimeInventoryError, t: t }), _jsx(ChatPaneComposerArea, { fileDrop: fileDrop, uploadAttachments: uploadAttachments, pane: pane, disabled: disabled, unavailable: unavailable, placeholder: composerPlaceholder, slots: slots, attachmentAccept: attachmentAccept, workingDirectoryAccess: workingDirectoryAccess, workingDirectoryControlPlacement: workingDirectoryControlPlacement, t: t })] })] }), footer] }));
+    return (_jsxs("section", { className: chatPaneClassName(variant, className), style: style, "data-activity": pane.activity, ref: rootRef, children: [_jsx("style", { "data-jini-chat-pane-styles": "true", children: CHAT_PANE_STYLES }), resolveChatPaneHeader(header, title, pane.reset, t), _jsxs("div", { className: "jini-chat-pane__body", children: [_jsx(MessageList, { messages: pane.conversation.messages, isStreaming: pane.conversation.isStreaming, scrollIntent: pane.conversation.scrollIntent, onScrolled: pane.conversation.acknowledgeScroll, pendingPrompt: pane.queuedPrompt === null ? null : { text: pane.queuedPrompt, onCancel: pane.cancelQueued }, ...(projectFileNames === undefined ? {} : { projectFileNames: new Set(projectFileNames) }) }), _jsxs("div", { className: "jini-chat-pane__controls", ref: controlsRef, children: [_jsx(ChatPaneSuggestionsRow, { suggestions: suggestions, onSelect: pane.composer.setDraft, t: t }), _jsx(ChatPaneStatusMessages, { unavailable: unavailable, scanningAgents: runtimeView.scanningAgents, connectingAgents: runtimeView.connectingAgents, executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, conversationError: pane.conversation.error, attachmentError: pane.attachmentError, dropReadError: fileDrop.dropReadError, workingDirectoryError: pane.workingDirectoryError, workingDirectoryPending: pane.workingDirectoryPending, workingDirectoryInvalid: pane.workingDirectoryInvalid, runtimeInventoryError: inventory.runtimeInventoryError, typedAnswerNotice: pane.typedAnswerNotice, onSendAsNewMessage: () => void pane.sendAsNewMessage(), t: t }), _jsx(ChatPaneComposerArea, { fileDrop: fileDrop, uploadAttachments: uploadAttachments, pane: pane, disabled: disabled, unavailable: unavailable, placeholder: composerPlaceholder, slots: slots, attachmentAccept: attachmentAccept, workingDirectoryAccess: workingDirectoryAccess, workingDirectoryControlPlacement: workingDirectoryControlPlacement, t: t })] })] }), footer] }));
 }
 //# sourceMappingURL=ChatPane.js.map

package/dist/react/features/chat-pane/create-typed-answer-poster.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @module create-typed-answer-poster
+ *
+ * The client half of a typed answer: a ready-made {@link DeliverTypedAnswer} that posts text the
+ * human typed into the composer to the MCP-UI tool-call route, for the question a running agent is
+ * holding open. Pass it as `ChatPane`'s `deliverTypedAnswer`.
+ *
+ * ```tsx
+ * <ChatPane deliverTypedAnswer={createTypedAnswerPoster({ baseUrl: '', fetch, toolName: 'ask_choice' })} />
+ * ```
+ *
+ * Sibling of `create-mcp-ui-tool-caller.ts`, and the same wire shape: `{toolName, params}` to the
+ * same route. The difference is what the params carry and what the caller needs back.
+ *
+ * ## Why the body names no exchange
+ *
+ * A human typing into the composer has never seen an exchange id; the only client-side copy lives
+ * inside the surface's own (model-influenced, sandboxed) HTML. So the body carries only the tool and
+ * the text under {@link TYPED_ANSWER_PARAM}, and the server resolves which open exchange — for that
+ * tool and the request's own authenticated principal — the answer is for (`@jini-ai/daemon`'s
+ * `findTypedAnswerTarget`).
+ *
+ * ## Why it resolves an outcome instead of throwing
+ *
+ * The pane must tell three cases apart and act differently on each, never by queueing the text as a
+ * new run: 202 delivered it; 409 means nothing is waiting any more (answered, expired, or never
+ * open); anything else is a failure the human can retry. A rejection would collapse the last two.
+ */
+import type { DeliverTypedAnswer } from './types.js';
+export interface CreateTypedAnswerPosterOptions {
+    /** Path appended to `baseUrl`. Defaults to `/api/mcp-ui/tool-calls`, as for `createMcpUiToolCaller`. */
+    readonly path?: string;
+    /** Abandon a post after this many ms (reported as `'failed'`). Defaults to 30s. */
+    readonly timeoutMs?: number;
+    /** Extra headers per request (e.g. a CSRF token). `content-type` is always set and cannot be overridden. */
+    readonly headers?: Readonly<Record<string, string>>;
+}
+/**
+ * Builds a {@link DeliverTypedAnswer} that POSTs `{toolName, params: {__typedAnswer: text}}`.
+ *
+ * @param deps.baseUrl - Origin to call; `''` for same-origin.
+ * @param deps.fetch - The fetch to use (the browser's, in production).
+ * @param deps.toolName - The host's question tool id — the server only routes typed answers to a
+ *   tool that opted in, so this package cannot pick it.
+ * @returns Resolves to the outcome; never rejects. Carries `toolName`, which also tells the pane
+ *   which tool's open card is a question awaiting typed text.
+ * @complexity O(1) — one request per call.
+ */
+export declare function createTypedAnswerPoster({ baseUrl, fetch, toolName }: {
+    baseUrl: string;
+    fetch: typeof globalThis.fetch;
+    toolName: string;
+}, options?: CreateTypedAnswerPosterOptions): DeliverTypedAnswer;
+//# sourceMappingURL=create-typed-answer-poster.d.ts.map

package/dist/react/features/chat-pane/create-typed-answer-poster.js

@@ -0,0 +1,46 @@
+/**
+ * The params key a typed answer travels under. Spelled here rather than imported because this
+ * browser package cannot depend on `@jini-ai/daemon`, which owns the canonical
+ * `SURFACE_TYPED_ANSWER_PARAM`; `@jini-ai/mcp`'s ask-choice tool keeps its own copy for the same
+ * reason. All three must agree.
+ */
+const TYPED_ANSWER_PARAM = '__typedAnswer';
+const DEFAULT_PATH = '/api/mcp-ui/tool-calls';
+const DEFAULT_TIMEOUT_MS = 30_000;
+/** Maps the route's status onto an outcome. Only 202 is a delivery; a 200 would be a fresh execution. */
+function deliveryFor(status) {
+    if (status === 202)
+        return 'delivered';
+    return status === 409 ? 'not-pending' : 'failed';
+}
+/**
+ * Builds a {@link DeliverTypedAnswer} that POSTs `{toolName, params: {__typedAnswer: text}}`.
+ *
+ * @param deps.baseUrl - Origin to call; `''` for same-origin.
+ * @param deps.fetch - The fetch to use (the browser's, in production).
+ * @param deps.toolName - The host's question tool id — the server only routes typed answers to a
+ *   tool that opted in, so this package cannot pick it.
+ * @returns Resolves to the outcome; never rejects. Carries `toolName`, which also tells the pane
+ *   which tool's open card is a question awaiting typed text.
+ * @complexity O(1) — one request per call.
+ */
+export function createTypedAnswerPoster({ baseUrl, fetch, toolName }, options = {}) {
+    const endpoint = `${baseUrl.replace(/\/$/u, '')}${options.path ?? DEFAULT_PATH}`;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const deliver = async ({ text }) => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        const outcome = await fetch(endpoint, {
+            method: 'POST',
+            // Same-origin cookie session: the human's own credentials authorize the answer.
+            credentials: 'same-origin',
+            headers: { ...options.headers, 'content-type': 'application/json' },
+            body: JSON.stringify({ toolName, params: { [TYPED_ANSWER_PARAM]: text } }),
+            signal: controller.signal,
+        }).then((response) => deliveryFor(response.status), () => 'failed');
+        clearTimeout(timer);
+        return outcome;
+    };
+    return Object.assign(deliver, { toolName });
+}
+//# sourceMappingURL=create-typed-answer-poster.js.map

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

@@ -1,5 +1,5 @@
 import { type ChatPaneSendBlocker } from '../rules.js';
-import type { ChatPaneActivity, ChatPaneAgent, ChatPaneAttachmentUploadOptions, ChatPaneAgentSelection, ChatPaneRunContext, ChatPaneWorkingDirectoryAccess } from '../types.js';
+import type { ChatPaneActivity, ChatPaneAgent, ChatPaneAttachmentUploadOptions, ChatPaneAgentSelection, ChatPaneRunContext, ChatPaneWorkingDirectoryAccess, DeliverTypedAnswer, TypedAnswerNotice } from '../types.js';
 import type { ChatAttachment, ChatMessage } from '@jini-ai/chat';
 import type { ChatTransport } from '@jini-ai/chat';
 import { type UseComposerResult } from '../../../hooks/useComposer.js';
@@ -30,6 +30,8 @@ export interface UseChatPaneOptions {
      * behavior: no selected agent always blocks sending.
      */
     apiModeConfigured?: boolean;
+    /** See `ChatPaneProps.deliverTypedAnswer`. Omitted keeps today's queue-while-streaming behavior. */
+    deliverTypedAnswer?: DeliverTypedAnswer;
 }
 export interface UseChatPaneResult extends UseChatPaneWorkingDirectoryResult {
     conversation: UseConversationResult;
@@ -76,6 +78,20 @@ export interface UseChatPaneResult extends UseChatPaneWorkingDirectoryResult {
     queuedPrompt: string | null;
     /** Drops the queued prompt without ever sending it. */
     cancelQueued: () => void;
+    /**
+     * Why the last typed answer was NOT sent, or `null`. Set when `deliverTypedAnswer` reports the
+     * question no longer waiting or could not be reached, and when {@link send} holds back an answer
+     * whose question has since closed; the draft stays in the composer. Cleared by the next send and
+     * by `reset()`.
+     */
+    typedAnswerNotice: TypedAnswerNotice | null;
+    /**
+     * Sends the composer draft as an ordinary next turn (queued behind a running run, as {@link send}
+     * does) even though it was typed as an answer to a question that has since closed. The one way
+     * past {@link send}'s hold on such a draft other than clearing it: the human chose a new, possibly
+     * paid, run on purpose.
+     */
+    sendAsNewMessage: () => Promise<void>;
     /**
      * Cancels the run in flight and sends the composer draft as soon as it stops — the modifier-key
      * counterpart to {@link send}, which queues behind the run instead of ending it. Implemented as

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

@@ -1,7 +1,8 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { describeChatPaneSendBlocker, findChatPaneSendBlocker, isChatPaneQueueableBlocker, resolveChatPaneSelection, } from '../rules.js';
+import { describeChatPaneSendBlocker, findAwaitedTypedAnswerId, findChatPaneSendBlocker, isChatPaneQueueableBlocker, isTypedAnswerTurn, resolveChatPaneSelection, } from '../rules.js';
 import { definedProps } from '../../../util/defined-props.js';
 import { cacheAttachmentPreviewSource } from '../../../hooks/attachment-preview-cache.js';
+import { readCachedAttachmentBatchId, writeCachedAttachmentBatchId, } from '../../../hooks/composer-draft-cache.js';
 import { useComposer } from '../../../hooks/useComposer.js';
 import { useConversation, } from '../../../hooks/useConversation.js';
 import { useChatPaneWorkingDirectory, } from './useChatPaneWorkingDirectory.hooks.js';
@@ -18,6 +19,20 @@ function createAttachmentBatchId() {
     return globalThis.crypto?.randomUUID?.()
         ?? `chat-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 }
+/**
+ * Hands one typed answer to the host. A throw counts as `'failed'`: the host could not say whether
+ * anything was waiting, and the one outcome that must never follow is queueing the text as a new run.
+ *
+ * @complexity O(1) plus the host's own request.
+ */
+async function deliverTypedAnswerSafely({ deliver, text }) {
+    try {
+        return await deliver({ text });
+    }
+    catch {
+        return 'failed';
+    }
+}
 /** Module scope so each branch costs 1 cognitive point instead of 2 (nested one level inside
  * `useChatPane` where it used to live as a ternary chain). */
 function resolveChatPaneActivity(selectedAgent, conversation) {
@@ -61,13 +76,33 @@ export function useChatPane(options) {
     const [activeUploadCount, setActiveUploadCount] = useState(0);
     const [attachmentError, setAttachmentError] = useState(null);
     const [queuedPrompt, setQueuedPrompt] = useState(null);
+    const [typedAnswerNotice, setTypedAnswerNotice] = useState(null);
+    // Set across the await of one typed-answer delivery so a second Enter cannot post the same text
+    // twice — the second post would find the question already answered and wrongly report it closed.
+    const deliveringTypedAnswerRef = useRef(false);
+    // The question (tool-use id) the current draft was typed for, or null. Set while a non-empty draft
+    // sits in the composer as a question waits, and kept after that question closes (answered
+    // elsewhere, expired, 409), so `send` cannot slip the draft into the queue as a new paid run.
+    // Released only by an empty draft, a delivery, `reset()`, or `sendAsNewMessage`.
+    const heldAnswerQuestionIdRef = useRef(null);
+    // The question the last delivery answered: typing more while its card is still drawn open (its
+    // tool_result has not streamed in yet) is a follow-up, not another answer to hold.
+    const answeredQuestionIdRef = useRef(null);
+    // Bumped by `reset()` and a conversation switch; a delivery that settles under a different value
+    // belongs to a composer that no longer exists and must neither clear the draft nor set a notice.
+    const typedAnswerGenerationRef = useRef(0);
     // The conversation `queuedPrompt` was queued against. Compared with `options.conversationId` at
     // flush time so a prompt queued behind a streaming run in one conversation can never be posted
     // into a different one the caller switched to before that run finished.
     const queuedConversationIdRef = useRef(undefined);
     const mountedRef = useRef(true);
     const attachmentGenerationRef = useRef(0);
-    const attachmentBatchIdRef = useRef(createAttachmentBatchId());
+    // Every attachment staged for one turn must share one upload batch (the daemon refuses a turn
+    // spanning two). So a mount that will restore cached attachments starts in THEIR batch rather
+    // than a new one; see `readCachedAttachmentBatchId`.
+    const [initialAttachmentBatchId] = useState(() => readCachedAttachmentBatchId({ conversationId: options.conversationId }) ?? createAttachmentBatchId());
+    const attachmentBatchIdRef = useRef(initialAttachmentBatchId);
+    const batchConversationIdRef = useRef(options.conversationId);
     const activeUploadsRef = useRef(new Set());
     const [internalSelection, setInternalSelection] = useState(options.initialSelection ?? { agentId: '' });
     const workingDirectoryState = useChatPaneWorkingDirectory(definedProps({ source: {
@@ -150,10 +185,51 @@ export function useChatPane(options) {
         ...(options.apiModeConfigured === undefined ? {} : { apiModeConfigured: options.apiModeConfigured }),
     });
     const canSend = sendBlocker === null && composer.canSubmit;
+    // Read after `await` in `answerWaitingQuestion`, where the render-time `composer.draft` is stale.
+    const latestDraftRef = useRef(composer.draft);
+    latestDraftRef.current = composer.draft;
+    const awaitedQuestionId = options.deliverTypedAnswer === undefined
+        ? null
+        : findAwaitedTypedAnswerId({ messages: conversation.messages, toolName: options.deliverTypedAnswer.toolName });
+    const hasDraft = composer.draft.trim() !== '';
+    useEffect(() => {
+        if (!hasDraft) {
+            heldAnswerQuestionIdRef.current = null;
+            return;
+        }
+        if (awaitedQuestionId !== null && awaitedQuestionId !== answeredQuestionIdRef.current) {
+            heldAnswerQuestionIdRef.current = awaitedQuestionId;
+        }
+    }, [awaitedQuestionId, hasDraft]);
+    useEffect(() => {
+        typedAnswerGenerationRef.current += 1;
+        heldAnswerQuestionIdRef.current = null;
+    }, [options.conversationId]);
+    // A conversation switch without a remount: adopt the batch of the attachments the composer is
+    // about to restore for the new conversation, else start a fresh one so two conversations never
+    // share a batch directory (the agent is granted the whole directory, not just the claimed files).
+    // An id arriving where there was none is the same conversation finally getting a key — the
+    // composer keeps what is staged (see `useComposer`), so the batch stays too.
+    useEffect(() => {
+        const previousConversationId = batchConversationIdRef.current;
+        if (options.conversationId === previousConversationId)
+            return;
+        batchConversationIdRef.current = options.conversationId;
+        const restoredBatchId = readCachedAttachmentBatchId({ conversationId: options.conversationId });
+        if (restoredBatchId !== null) {
+            attachmentBatchIdRef.current = restoredBatchId;
+            return;
+        }
+        if (previousConversationId == null)
+            return;
+        attachmentBatchIdRef.current = createAttachmentBatchId();
+    }, [options.conversationId]);
     const addAttachments = useCallback(async (files) => {
         if (files.length === 0 || options.uploadAttachments === undefined)
             return;
         const generation = attachmentGenerationRef.current;
+        const batchId = attachmentBatchIdRef.current;
+        const conversationId = options.conversationId;
         const controller = new AbortController();
         activeUploadsRef.current.add(controller);
         setActiveUploadCount(activeUploadsRef.current.size);
@@ -162,7 +238,7 @@ export function useChatPane(options) {
             await uploadAttachmentBatch(files, {
                 upload: options.uploadAttachments,
                 signal: controller.signal,
-                batchId: attachmentBatchIdRef.current,
+                batchId,
                 stillWanted: () => mountedRef.current
                     && !controller.signal.aborted
                     && generation === attachmentGenerationRef.current,
@@ -172,6 +248,9 @@ export function useChatPane(options) {
                 // `attachment-preview-cache.ts`'s module doc for why this is the only place that copy can
                 // ever be captured.
                 onAttachment: (attachment, file) => {
+                    // Recorded before staging so the cache entry that persists this attachment carries its
+                    // batch, which is what lets a later mount restore the batch along with the attachment.
+                    writeCachedAttachmentBatchId({ conversationId, batchId });
                     composer.addAttachment(attachment);
                     if (file)
                         cacheAttachmentPreviewSource({ path: attachment.path, file });
@@ -184,7 +263,7 @@ export function useChatPane(options) {
                 setActiveUploadCount(activeUploadsRef.current.size);
             }
         }
-    }, [composer, options.uploadAttachments]);
+    }, [composer, options.conversationId, options.uploadAttachments]);
     const sendPrompt = useCallback(async (prompt) => {
         const trimmed = prompt.trim();
         if (!trimmed)
@@ -220,10 +299,30 @@ export function useChatPane(options) {
         sendBlocker,
         workingDirectoryState.workingDirectory,
     ]);
-    const send = useCallback(async () => {
-        const prompt = composerPrompt(composer);
-        if (!prompt)
+    const answerWaitingQuestion = useCallback(async ({ deliver, text }) => {
+        const generation = typedAnswerGenerationRef.current;
+        const submittedDraft = latestDraftRef.current;
+        const questionId = awaitedQuestionId;
+        deliveringTypedAnswerRef.current = true;
+        const outcome = await deliverTypedAnswerSafely({ deliver, text });
+        deliveringTypedAnswerRef.current = false;
+        if (!mountedRef.current || generation !== typedAnswerGenerationRef.current)
             return;
+        // Anything but a delivery keeps the draft and says why — never the queue below, whose flush
+        // would post the answer as a brand-new (paid) run once this one ends.
+        if (outcome !== 'delivered') {
+            setTypedAnswerNotice(outcome);
+            return;
+        }
+        answeredQuestionIdRef.current = questionId;
+        heldAnswerQuestionIdRef.current = null;
+        // The textarea stays editable during delivery: clear only the text that went out, never a
+        // correction or next message typed while the host answered.
+        if (latestDraftRef.current === submittedDraft)
+            composer.setDraft('');
+    }, [awaitedQuestionId, composer]);
+    // The ordinary next-turn path: queue behind a running run, else send now.
+    const sendOrdinaryTurn = useCallback(async (prompt) => {
         // Queue instead of no-op'ing. `setDraft('')` and NOT `composer.reset()`: reset also discards
         // staged attachments, which this turn still needs when it finally goes out.
         if (isChatPaneQueueableBlocker({ blocker: sendBlocker })) {
@@ -236,6 +335,48 @@ export function useChatPane(options) {
             return;
         await sendPrompt(prompt);
     }, [canSend, composer, options.conversationId, sendBlocker, sendPrompt]);
+    const send = useCallback(async () => {
+        const prompt = composerPrompt(composer);
+        if (!prompt || deliveringTypedAnswerRef.current)
+            return;
+        setTypedAnswerNotice(null);
+        const deliver = options.deliverTypedAnswer;
+        if (deliver !== undefined && isTypedAnswerTurn({
+            blocker: sendBlocker,
+            attachmentCount: composer.attachments.length,
+            messages: conversation.messages,
+            toolName: deliver.toolName,
+        })) {
+            await answerWaitingQuestion({ deliver, text: prompt });
+            return;
+        }
+        // Typed for a question that has since closed: the human meant an answer, so going on to the
+        // queue would start a paid run they never asked for. Attachments mark a new turn (a typed answer
+        // carries text only), the same rule `isTypedAnswerTurn` applies.
+        if (heldAnswerQuestionIdRef.current !== null && composer.attachments.length === 0) {
+            setTypedAnswerNotice('not-pending');
+            return;
+        }
+        await sendOrdinaryTurn(prompt);
+    }, [
+        answerWaitingQuestion,
+        composer,
+        conversation.messages,
+        options.deliverTypedAnswer,
+        sendBlocker,
+        sendOrdinaryTurn,
+    ]);
+    const sendAsNewMessage = useCallback(async () => {
+        const prompt = composerPrompt(composer);
+        if (!prompt || deliveringTypedAnswerRef.current)
+            return;
+        setTypedAnswerNotice(null);
+        // Mark the question answered too, so the still-non-empty draft is not re-held by the effect
+        // while that question's card is drawn open.
+        answeredQuestionIdRef.current = heldAnswerQuestionIdRef.current ?? answeredQuestionIdRef.current;
+        heldAnswerQuestionIdRef.current = null;
+        await sendOrdinaryTurn(prompt);
+    }, [composer, sendOrdinaryTurn]);
     const interruptSend = useCallback(() => {
         const prompt = composerPrompt(composer);
         if (!prompt)
@@ -277,6 +418,9 @@ export function useChatPane(options) {
         conversation.setMessages(options.initialMessages ?? []);
         composer.reset();
         setAttachmentError(null);
+        setTypedAnswerNotice(null);
+        typedAnswerGenerationRef.current += 1;
+        heldAnswerQuestionIdRef.current = null;
         // Without this, a prompt queued behind a streaming run survives `reset()` and — once
         // `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.
@@ -301,6 +445,8 @@ export function useChatPane(options) {
         sendPrompt,
         queuedPrompt,
         cancelQueued,
+        typedAnswerNotice,
+        sendAsNewMessage,
         interruptSend,
         reset,
     };

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

@@ -1,8 +1,9 @@
-export type { AgentRuntimePickerProps, ByokRuntimeSummary, ChatPaneActivity, ChatPaneAgent, ChatPaneAgentBridgeAccess, ChatPaneAgentControlOptions, ChatPaneAgentOption, ChatPaneAgentSelection, ChatPaneAgentToolAction, ChatPaneAttachmentUploadOptions, ChatPaneComposerHandle, ChatPaneProps, ChatPaneRunContext, ChatPaneRunContextInput, ChatPaneRuntimeAccess, ChatPaneVariant, ChatPaneWorkingDirectoryAccess, RuntimePickerPlacement, } from './types.js';
+export type { AgentRuntimePickerProps, ByokRuntimeSummary, ChatPaneActivity, ChatPaneAgent, ChatPaneAgentBridgeAccess, ChatPaneAgentControlOptions, ChatPaneAgentOption, ChatPaneAgentSelection, ChatPaneAgentToolAction, ChatPaneAttachmentUploadOptions, ChatPaneComposerHandle, ChatPaneProps, ChatPaneRunContext, ChatPaneRunContextInput, ChatPaneRuntimeAccess, ChatPaneVariant, ChatPaneWorkingDirectoryAccess, DeliverTypedAnswer, RuntimePickerPlacement, TypedAnswerDelivery, TypedAnswerNotice, } from './types.js';
 export { CHAT_PANE_AGENT_TOOLS, type ChatPaneAgentToolDef, type ChatPaneAgentToolInputSchema, type ChatPaneAgentToolRisk, } from './agent-tools.js';
 export { defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, } from './rules.js';
 export { createDaemonAttachmentUploader, type CreateDaemonAttachmentUploaderOptions, } from './create-daemon-attachment-uploader.js';
 export { createMcpUiToolCaller, type CreateMcpUiToolCallerOptions, type McpUiToolCallRequest, } from './create-mcp-ui-tool-caller.js';
+export { createTypedAnswerPoster, type CreateTypedAnswerPosterOptions, } from './create-typed-answer-poster.js';
 export { useChatPane, type UseChatPaneOptions, type UseChatPaneResult, } from './hooks/useChatPane.hooks.js';
 export { useChatPaneAgentControl, type UseChatPaneAgentControlOptions, } from './hooks/useChatPaneAgentControl.hooks.js';
 export { useChatPaneWorkingDirectory, type UseChatPaneWorkingDirectoryOptions, type UseChatPaneWorkingDirectoryResult, } from './hooks/useChatPaneWorkingDirectory.hooks.js';

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

@@ -2,6 +2,7 @@ export { CHAT_PANE_AGENT_TOOLS, } from './agent-tools.js';
 export { defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, } from './rules.js';
 export { createDaemonAttachmentUploader, } from './create-daemon-attachment-uploader.js';
 export { createMcpUiToolCaller, } from './create-mcp-ui-tool-caller.js';
+export { createTypedAnswerPoster, } from './create-typed-answer-poster.js';
 export { useChatPane, } from './hooks/useChatPane.hooks.js';
 export { useChatPaneAgentControl, } from './hooks/useChatPaneAgentControl.hooks.js';
 export { useChatPaneWorkingDirectory, } from './hooks/useChatPaneWorkingDirectory.hooks.js';

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

@@ -1,4 +1,5 @@
-import type { ByokRuntimeSummary, ChatPaneAgent, ChatPaneAgentSelection } from './types.js';
+import type { ChatMessage } from '@jini-ai/chat';
+import type { ByokRuntimeSummary, ChatPaneAgent, ChatPaneAgentSelection, TypedAnswerNotice } from './types.js';
 export declare function defaultChatPaneSelection({ agent }: {
     agent: ChatPaneAgent;
 }): ChatPaneAgentSelection;
@@ -71,6 +72,63 @@ export declare function describeChatPaneSendBlocker(blocker: ChatPaneSendBlocker
 export declare function isChatPaneQueueableBlocker({ blocker }: {
     blocker: ChatPaneSendBlocker | null;
 }): boolean;
+/**
+ * Whether the run in flight is holding a question open for the human: the newest message is the
+ * assistant's, and it carries an interactive surface (`kind: 'ext'`, e.g. an MCP-UI card) that
+ * arrived inside a still-open call to the host's question tool (`toolName`). That is the one moment
+ * text typed into the composer is an ANSWER rather than a next turn — the tool is parked waiting on
+ * it, and queueing the text behind the run would only deliver it after the question had expired, as
+ * a new paid run.
+ *
+ * Only the question tool counts. Other tools park on cards too — a delete confirm, an approval —
+ * but they take no typed answer: the server routes typed text only to the question tool, so treating
+ * those as waiting would refuse the text with "no longer waiting" and drop it instead of queueing.
+ * A call is the question tool when ANY `tool_use` for its id names it, since the same call's
+ * `tool_use` can arrive more than once (the CLI re-emits it). A vendor's wrapper row
+ * (`execute_delegated_tool`) and the daemon's canonical row do NOT share an id — the wrapper carries
+ * the CLI's `toolu_…` id and the canonical row a fresh UUID from `@jini-ai/mcp`. The canonical row
+ * opens after its wrapper, so it is the newest open call when the surface arrives, and that is
+ * what attributes the surface to the question tool.
+ *
+ * A surface is attributed to the newest call still open when it arrived — the same rule
+ * `useExtEventGroups` uses to give a card its `call` — so an older call returning does not settle
+ * it. Once its call returns (answered, expired, abandoned), typing is a next turn again.
+ *
+ * @complexity O(e·c): e events in the newest message, c calls open at once (one or two in practice).
+ */
+export declare function isAwaitingTypedAnswer({ messages, toolName }: {
+    messages: readonly ChatMessage[];
+    toolName: string;
+}): boolean;
+/**
+ * The tool-use id of the question {@link isAwaitingTypedAnswer} sees waiting, or `null` — the newest
+ * one when several are open. The id lets the pane tell one question from the next: a draft typed
+ * for a question stays tied to THAT question after it closes (see `useChatPane`'s held answer).
+ *
+ * @complexity O(e·c), as {@link isAwaitingTypedAnswer}.
+ */
+export declare function findAwaitedTypedAnswerId({ messages, toolName }: {
+    messages: readonly ChatMessage[];
+    toolName: string;
+}): string | null;
+/**
+ * Whether a composer send is an answer to a waiting question rather than a next turn: a run is
+ * streaming ({@link isChatPaneQueueableBlocker}), the turn has no attachments (a typed answer
+ * carries text only), and that run is holding the `toolName` question open
+ * ({@link isAwaitingTypedAnswer}).
+ *
+ * @complexity O(e·c), from {@link isAwaitingTypedAnswer}.
+ */
+export declare function isTypedAnswerTurn({ blocker, attachmentCount, messages, toolName }: {
+    blocker: ChatPaneSendBlocker | null;
+    attachmentCount: number;
+    messages: readonly ChatMessage[];
+    toolName: string;
+}): boolean;
+/** The English copy (and i18n key) for why a typed answer was not sent. */
+export declare function describeTypedAnswerNotice({ notice }: {
+    notice: TypedAnswerNotice;
+}): string;
 export declare function orderChatPaneAgents({ agents }: {
     agents: readonly ChatPaneAgent[];
 }): ChatPaneAgent[];