@jini-ai/chat 0.5.6 → 0.5.8

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

@@ -1,6 +1,6 @@
 import { useUserTextGuard } from '../../../hooks/useUserTextGuard.js';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { describeChatPaneSendBlocker, findAwaitedTypedAnswerId, findChatPaneSendBlocker, isChatPaneQueueableBlocker, isTypedAnswerTurn, resolveChatPaneSelection, } from '../rules.js';
+import { appendQueuedTurn, describeChatPaneSendBlocker, findAwaitedTypedAnswerId, findChatPaneSendBlocker, findMidRunMessageRunId, 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';
@@ -34,6 +34,20 @@ async function deliverTypedAnswerSafely({ deliver, text }) {
         return 'failed';
     }
 }
+/**
+ * Hands one mid-run message to the host. A throw counts as `'failed'`, which queues the text — the
+ * host could not say whether the run took it, and a message must never be dropped.
+ *
+ * @complexity O(1) plus the host's own request.
+ */
+async function deliverMidRunMessageSafely({ deliver, runId, text }) {
+    try {
+        return await deliver({ runId, 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) {
@@ -129,6 +143,7 @@ export function useChatPane(options) {
             redactUserText: options.redactUserText,
             onSecretRedacted: guard.notifyRedaction,
             initialMessages: options.initialMessages,
+            refreshSignal: options.refreshSignal,
             conversationId: options.conversationId,
             // Keys off an empty string, not `undefined` — `selection.agentId` is always a string (never
             // absent), so only the falsy "no agent selected" case should omit the key.
@@ -344,20 +359,61 @@ export function useChatPane(options) {
         if (latestDraftRef.current === submittedDraft)
             composer.setDraft('');
     }, [awaitedQuestionId, composer, guard.redactText]);
-    // The ordinary next-turn path: queue behind a running run, else send now.
+    // Every queue path goes through here: a message joins the turn already queued behind this run
+    // (`appendQueuedTurn`) instead of replacing it, which dropped the earlier message. A turn queued
+    // against another conversation is not joined — it would never be flushed there anyway.
+    const enqueueTurn = useCallback((turn) => {
+        const sameConversation = queuedConversationIdRef.current === options.conversationId;
+        queuedConversationIdRef.current = options.conversationId;
+        setQueuedTurn((queued) => appendQueuedTurn({ queued: sameConversation ? queued : null, next: turn }));
+    }, [options.conversationId]);
+    // A text-only message sent while a run streams goes INTO that run when the host can deliver it.
+    // The draft clears before the await so the human sees it go out; whatever the outcome, the text
+    // ends up somewhere — in the run, or queued as the next turn (after stopping the run when the
+    // agent cannot take input mid-run). Never cancel on 'not-running'/'failed': the run is ending.
+    const sendIntoRunningTurn = useCallback(async ({ deliver, runId, turn }) => {
+        composer.setDraft('');
+        const outcome = await deliverMidRunMessageSafely({ deliver, runId, text: turn.text });
+        if (outcome === 'delivered' || !mountedRef.current)
+            return;
+        enqueueTurn(turn);
+        if (outcome === 'unsupported')
+            conversation.cancel();
+    }, [composer, conversation, enqueueTurn]);
+    // The ordinary next-turn path: into the running run, else queue behind it, 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 })) {
-            queuedConversationIdRef.current = options.conversationId;
-            setQueuedTurn(guard.redact({ text: prompt }, {}));
+            const turn = guard.redact({ text: prompt }, {});
+            const deliver = options.deliverMidRunMessage;
+            const runId = deliver === undefined ? null : findMidRunMessageRunId({
+                blocker: sendBlocker,
+                attachmentCount: composer.attachments.length,
+                messages: conversation.messages,
+            });
+            if (deliver !== undefined && runId !== null) {
+                await sendIntoRunningTurn({ deliver, runId, turn });
+                return;
+            }
+            // 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.
+            enqueueTurn(turn);
             composer.setDraft('');
             return;
         }
         if (!canSend)
             return;
         await sendPrompt(prompt);
-    }, [canSend, composer, options.conversationId, sendBlocker, sendPrompt, guard.redact]);
+    }, [
+        canSend,
+        composer,
+        conversation.messages,
+        enqueueTurn,
+        options.deliverMidRunMessage,
+        sendBlocker,
+        sendIntoRunningTurn,
+        sendPrompt,
+        guard.redact,
+    ]);
     const send = useCallback(async () => {
         const prompt = composerPrompt(composer);
         if (!prompt || deliveringTypedAnswerRef.current)
@@ -404,11 +460,10 @@ export function useChatPane(options) {
         const prompt = composerPrompt(composer);
         if (!prompt)
             return;
-        queuedConversationIdRef.current = options.conversationId;
-        setQueuedTurn(guard.redact({ text: prompt }, {}));
+        enqueueTurn(guard.redact({ text: prompt }, {}));
         composer.setDraft('');
         conversation.cancel();
-    }, [composer, conversation, options.conversationId, guard.redact]);
+    }, [composer, conversation, enqueueTurn, guard.redact]);
     const cancelQueued = useCallback(() => {
         queuedConversationIdRef.current = undefined;
         setQueuedTurn(null);

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

@@ -0,0 +1,25 @@
+import type { MouseEvent as ReactMouseEvent } from 'react';
+/**
+ * Decides whether a click inside the pane should open a link in a new tab.
+ *
+ * @param input.event - The click, native (React's `nativeEvent` or a DOM listener's own).
+ * @param input.root - The pane root; an anchor outside it (one wrapping the whole pane) is ignored.
+ * @returns The anchor's resolved absolute URL to open, or `null` to leave the click to the browser.
+ * @complexity O(d) for `closest` over the target's ancestor depth d.
+ */
+export declare function newTabLinkHref({ event, root }: {
+    event: MouseEvent;
+    root: Element;
+}): string | null;
+/**
+ * The pane root's `onClickCapture` handler: opens qualifying link clicks in a new tab and cancels
+ * the in-tab navigation. See this module's doc for what qualifies.
+ *
+ * @param _required - Reserved; no required inputs.
+ * @param options.openInNewTab - Opener port; defaults to `window.open(url, '_blank', 'noopener,noreferrer')`.
+ * @returns A stable click-capture handler.
+ */
+export declare function useChatPaneNewTabLinks(_required?: Record<string, never>, { openInNewTab }?: {
+    openInNewTab?: (url: string) => void;
+}): (event: ReactMouseEvent<HTMLElement>) => void;
+//# sourceMappingURL=useChatPaneNewTabLinks.hooks.d.ts.map

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

@@ -0,0 +1,70 @@
+/**
+ * @module useChatPaneNewTabLinks
+ *
+ * Every link inside the chat pane opens in a new tab, so following one never navigates the tab the
+ * conversation lives in (owner 2026-10-08: "every link"). One capture-phase click guard on the
+ * pane's root absorbs every link source at once — markdown in messages, tool cards, host-registered
+ * ext-event cards, A2UI surfaces, the header slot — instead of each renderer setting `target` on its
+ * own anchors and the next new card forgetting to.
+ *
+ * Capture phase, then `preventDefault()`: the guard runs before any anchor's own `onClick`, so a
+ * router `<Link>` (React Router, TanStack Router — both skip their in-app navigation once
+ * `defaultPrevented` is set) does not ALSO navigate the chat's tab after the new tab opens.
+ *
+ * Left to the browser: modified or non-primary clicks (the browser already opens those however the
+ * user asked), anchors that already say `target="_blank"`, `#` same-document anchors, `download`
+ * links, `role="button"` anchors (an action, not a link), and any scheme other than http(s) —
+ * `mailto:`/`tel:` hand off to another app without navigating the tab anyway.
+ *
+ * MCP-UI Views render inside a sandboxed iframe, out of this guard's reach; their proxy page
+ * forwards link clicks as `ui/open-link` (`@jini-ai/ui/mcp-ui`'s sandbox proxy) instead.
+ */
+import { useCallback } from 'react';
+const NEW_TAB_PROTOCOLS = new Set(['http:', 'https:']);
+/** Opens `url` in a new tab with no opener or referrer — `rel="noopener noreferrer"` for `window.open`. */
+function openInNewTabDefault(url) {
+    window.open(url, '_blank', 'noopener,noreferrer');
+}
+/**
+ * Decides whether a click inside the pane should open a link in a new tab.
+ *
+ * @param input.event - The click, native (React's `nativeEvent` or a DOM listener's own).
+ * @param input.root - The pane root; an anchor outside it (one wrapping the whole pane) is ignored.
+ * @returns The anchor's resolved absolute URL to open, or `null` to leave the click to the browser.
+ * @complexity O(d) for `closest` over the target's ancestor depth d.
+ */
+export function newTabLinkHref({ event, root }) {
+    if (event.defaultPrevented || event.button !== 0)
+        return null;
+    if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)
+        return null;
+    const target = event.target;
+    if (!(target instanceof Element))
+        return null;
+    const link = target.closest('a[href]');
+    if (!(link instanceof HTMLAnchorElement) || !root.contains(link))
+        return null;
+    if (link.target === '_blank' || link.hasAttribute('download') || link.getAttribute('role') === 'button')
+        return null;
+    if (link.getAttribute('href').startsWith('#'))
+        return null;
+    return NEW_TAB_PROTOCOLS.has(link.protocol) ? link.href : null;
+}
+/**
+ * The pane root's `onClickCapture` handler: opens qualifying link clicks in a new tab and cancels
+ * the in-tab navigation. See this module's doc for what qualifies.
+ *
+ * @param _required - Reserved; no required inputs.
+ * @param options.openInNewTab - Opener port; defaults to `window.open(url, '_blank', 'noopener,noreferrer')`.
+ * @returns A stable click-capture handler.
+ */
+export function useChatPaneNewTabLinks(_required = {}, { openInNewTab = openInNewTabDefault } = {}) {
+    return useCallback((event) => {
+        const href = newTabLinkHref({ event: event.nativeEvent, root: event.currentTarget });
+        if (href === null)
+            return;
+        event.preventDefault();
+        openInNewTab(href);
+    }, [openInNewTab]);
+}
+//# sourceMappingURL=useChatPaneNewTabLinks.hooks.js.map

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

@@ -57,6 +57,10 @@ export function useChatPaneRuntimeInventory({ access, initialAgents = EMPTY_AGEN
                 const nextAgents = await (rescan ? access.rescanAgents() : access.listAgents());
                 token.ensureCurrent();
                 retry.answered();
+                // Successful cached data paints immediately. Poll only while the host says its single
+                // background scan is pending; reads never imply an explicit Rescan.
+                if (nextAgents.some(agent => agent.discoveryPending))
+                    retry.schedule(() => void loadAgents(false));
                 setAgents([...nextAgents]);
                 setConnectingAgents(false);
                 setScanningAgents(false);

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

@@ -0,0 +1,9 @@
+import { type RefObject } from 'react';
+/** Fill the pane-owned draft without sending, then focus its composer for editing.
+ * @complexity O(pane controls) per selection; O(1) retained state.
+ */
+export declare function useChatPaneSuggestion({ rootRef, setDraft }: {
+    rootRef: RefObject<HTMLElement | null>;
+    setDraft: (draft: string) => void;
+}, _options?: {}): (suggestion: string) => void;
+//# sourceMappingURL=useChatPaneSuggestion.hooks.d.ts.map

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

@@ -0,0 +1,11 @@
+import { useCallback } from 'react';
+/** Fill the pane-owned draft without sending, then focus its composer for editing.
+ * @complexity O(pane controls) per selection; O(1) retained state.
+ */
+export function useChatPaneSuggestion({ rootRef, setDraft }, _options = {}) {
+    return useCallback((suggestion) => {
+        setDraft(suggestion);
+        rootRef.current?.querySelector('.jini-composer-input:not(:disabled)')?.focus();
+    }, [rootRef, setDraft]);
+}
+//# sourceMappingURL=useChatPaneSuggestion.hooks.js.map

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

@@ -0,0 +1,17 @@
+import type { ChatPaneProps } from '../types.js';
+/**
+ * Embed is a visitor surface with a fixed backend. Workspace composer extensions and filesystem
+ * controls stay outside its render tree, even if a host accidentally supplies them.
+ * @complexity O(1) time and space.
+ */
+export declare function useChatPaneSurface({ variant, composerSlots, workingDirectoryControlPlacement, uploadAttachments }: Pick<ChatPaneProps, 'variant'> & {
+    composerSlots: ChatPaneProps['composerSlots'];
+    workingDirectoryControlPlacement: ChatPaneProps['workingDirectoryControlPlacement'];
+    uploadAttachments: ChatPaneProps['uploadAttachments'];
+}, _options?: {}): {
+    embed: boolean;
+    composerSlots: Omit<import("../../../slots.js").ComposerSlots, "footerAccessories" | "leadingAccessories"> | undefined;
+    workingDirectoryControlPlacement: "none" | "below" | "composer";
+    uploadAttachments: ((files: File[], options?: import("../types.js").ChatPaneAttachmentUploadOptions) => Promise<import("../../../../core/messages.js").ChatAttachment[]>) | undefined;
+};
+//# sourceMappingURL=useChatPaneSurface.hooks.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * Embed is a visitor surface with a fixed backend. Workspace composer extensions and filesystem
+ * controls stay outside its render tree, even if a host accidentally supplies them.
+ * @complexity O(1) time and space.
+ */
+export function useChatPaneSurface({ variant, composerSlots, workingDirectoryControlPlacement, uploadAttachments }, _options = {}) {
+    const embed = variant === 'embed';
+    return {
+        embed,
+        composerSlots: embed ? undefined : composerSlots,
+        workingDirectoryControlPlacement: embed ? 'none' : workingDirectoryControlPlacement ?? 'below',
+        uploadAttachments: embed ? undefined : uploadAttachments,
+    };
+}
+//# sourceMappingURL=useChatPaneSurface.hooks.js.map

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, DeliverTypedAnswer, RuntimePickerPlacement, TypedAnswerDelivery, TypedAnswerNotice, } from './types.js';
+export type { AgentRuntimePickerProps, ByokRuntimeSummary, ChatPaneActivity, ChatPaneAgent, ChatPaneAgentBridgeAccess, ChatPaneAgentControlOptions, ChatPaneAgentOption, ChatPaneAgentSelection, ChatPaneAgentToolAction, ChatPaneAttachmentUploadOptions, ChatPaneComposerHandle, ChatPaneProps, ChatPaneRunContext, ChatPaneRunContextInput, ChatPaneRuntimeAccess, ChatPaneVariant, ChatPaneWorkingDirectoryAccess, DeliverMidRunMessage, DeliverTypedAnswer, MidRunMessageDelivery, 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 { createMidRunMessagePoster, type CreateMidRunMessagePosterOptions, } from './create-mid-run-message-poster.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';

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 { createMidRunMessagePoster, } from './create-mid-run-message-poster.js';
 export { createTypedAnswerPoster, } from './create-typed-answer-poster.js';
 export { useChatPane, } from './hooks/useChatPane.hooks.js';
 export { useChatPaneAgentControl, } from './hooks/useChatPaneAgentControl.hooks.js';

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

@@ -1,4 +1,5 @@
 import type { ChatMessage } from '@jini-ai/chat';
+import type { UserTextRedaction } from '../../../core/user-text-redaction.js';
 import type { ByokRuntimeSummary, ChatPaneAgent, ChatPaneAgentSelection, TypedAnswerNotice } from './types.js';
 export declare function defaultChatPaneSelection({ agent }: {
     agent: ChatPaneAgent;
@@ -126,6 +127,32 @@ export declare function isTypedAnswerTurn({ blocker, attachmentCount, messages,
     messages: readonly ChatMessage[];
     toolName: string;
 }): boolean;
+/**
+ * The run a composer send can go INTO instead of queueing behind, or `null`: a run is streaming
+ * ({@link isChatPaneQueueableBlocker}), the turn has no attachments (a mid-run message carries text
+ * only — the live agent's stdin takes no files), and the newest message is that run's assistant
+ * turn with a known `runId`.
+ *
+ * @complexity O(1).
+ */
+export declare function findMidRunMessageRunId({ blocker, attachmentCount, messages }: {
+    blocker: ChatPaneSendBlocker | null;
+    attachmentCount: number;
+    messages: readonly ChatMessage[];
+}): string | null;
+/**
+ * The queued next turn after one more message joins it. The pane holds ONE queued turn, so a second
+ * message sent behind the same run is appended to it (a blank line apart) rather than replacing it:
+ * replacing silently dropped the first message (owner, 2026-10-10). One turn, not two, because both
+ * were written for the run still going and the agent should read them together — two queued turns
+ * would also start two paid runs back to back.
+ *
+ * @complexity O(n) in the combined text length.
+ */
+export declare function appendQueuedTurn({ queued, next }: {
+    queued: UserTextRedaction | null;
+    next: UserTextRedaction;
+}): UserTextRedaction;
 /** The English copy (and i18n key) for why a typed answer was not sent. */
 export declare function describeTypedAnswerNotice({ notice }: {
     notice: TypedAnswerNotice;

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

@@ -179,6 +179,38 @@ export function findAwaitedTypedAnswerId({ messages, toolName }) {
 export function isTypedAnswerTurn({ blocker, attachmentCount, messages, toolName }) {
     return isChatPaneQueueableBlocker({ blocker }) && attachmentCount === 0 && isAwaitingTypedAnswer({ messages, toolName });
 }
+/**
+ * The run a composer send can go INTO instead of queueing behind, or `null`: a run is streaming
+ * ({@link isChatPaneQueueableBlocker}), the turn has no attachments (a mid-run message carries text
+ * only — the live agent's stdin takes no files), and the newest message is that run's assistant
+ * turn with a known `runId`.
+ *
+ * @complexity O(1).
+ */
+export function findMidRunMessageRunId({ blocker, attachmentCount, messages }) {
+    if (!isChatPaneQueueableBlocker({ blocker }) || attachmentCount !== 0)
+        return null;
+    const last = messages.at(-1);
+    return last?.role === 'assistant' && last.runId ? last.runId : null;
+}
+/**
+ * The queued next turn after one more message joins it. The pane holds ONE queued turn, so a second
+ * message sent behind the same run is appended to it (a blank line apart) rather than replacing it:
+ * replacing silently dropped the first message (owner, 2026-10-10). One turn, not two, because both
+ * were written for the run still going and the agent should read them together — two queued turns
+ * would also start two paid runs back to back.
+ *
+ * @complexity O(n) in the combined text length.
+ */
+export function appendQueuedTurn({ queued, next }) {
+    if (queued === null)
+        return next;
+    return {
+        text: `${queued.text}\n\n${next.text}`,
+        secretRedacted: queued.secretRedacted || next.secretRedacted,
+        count: queued.count + next.count,
+    };
+}
 const TYPED_ANSWER_NOTICES = {
     'not-pending': 'That question is no longer waiting for an answer, so your message was not sent.',
     failed: 'Your answer could not be delivered. Try sending it again.',