@jini-ai/chat 0.6.5 → 0.6.7

package/dist/react/hooks/useComposer.js

@@ -31,6 +31,14 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useComposerHistory } from './useComposerHistory.hooks.js';
 import { readCachedAttachments, readCachedDraft, rememberCachedDraft, writeCachedAttachments, writeCachedDraft, } from './composer-draft-cache.js';
 import { cacheAttachmentPreviewSource } from './attachment-preview-cache.js';
+/**
+ * The real window/document pair, or `null` when this runtime has no `window` — a non-DOM React
+ * renderer still runs effects, and subscribing there would throw.
+ * @complexity Time/space: O(1).
+ */
+export function browserPageLifecycle() {
+    return typeof window === 'undefined' ? null : { window, document };
+}
 const EMPTY_MENTION = { open: false, query: '', results: [] };
 /**
  * How long typing must pause before the draft reaches `localStorage` and the host's persistence
@@ -44,9 +52,12 @@ export const DRAFT_PERSIST_DEBOUNCE_MS = 800;
  * One pending durable draft write at a time, trailing-edge debounced. Flushes on unmount and when
  * the page is hidden (`pagehide`, or `visibilitychange` to hidden — the last event a mobile browser
  * reliably delivers before discarding the tab).
+ * @param pageLifecycle The page-exit event sources, captured at mount; `undefined` resolves the
+ *   browser's own, `null` subscribes to nothing (unmount still flushes).
  * @complexity Time/space: O(1) per call.
  */
-function useDeferredDraftWrite() {
+function useDeferredDraftWrite(pageLifecycle) {
+    const [lifecycle] = useState(() => (pageLifecycle === undefined ? browserPageLifecycle() : pageLifecycle));
     const pendingRef = useRef(null);
     const cancel = useCallback(() => {
         const pending = pendingRef.current;
@@ -73,20 +84,21 @@ function useDeferredDraftWrite() {
         pendingRef.current = { timer, write };
     }, []);
     useEffect(() => {
-        if (typeof window === 'undefined')
+        if (lifecycle === null)
             return flush;
+        const { window: page, document: doc } = lifecycle;
         const onVisibilityChange = () => {
-            if (document.visibilityState === 'hidden')
+            if (doc.visibilityState === 'hidden')
                 flush();
         };
-        window.addEventListener('pagehide', flush);
-        document.addEventListener('visibilitychange', onVisibilityChange);
+        page.addEventListener('pagehide', flush);
+        doc.addEventListener('visibilitychange', onVisibilityChange);
         return () => {
-            window.removeEventListener('pagehide', flush);
-            document.removeEventListener('visibilitychange', onVisibilityChange);
+            page.removeEventListener('pagehide', flush);
+            doc.removeEventListener('visibilitychange', onVisibilityChange);
             flush();
         };
-    }, [flush]);
+    }, [flush, lifecycle]);
     return useMemo(() => ({ schedule, flush, cancel }), [schedule, flush, cancel]);
 }
 export function useComposer(options = {}) {
@@ -95,7 +107,7 @@ export function useComposer(options = {}) {
     const [attachments, setAttachments] = useState([]);
     const [agent, setAgent] = useState(options.initialAgent);
     const [mention, setMention] = useState(EMPTY_MENTION);
-    const deferredWrite = useDeferredDraftWrite();
+    const deferredWrite = useDeferredDraftWrite(options.pageLifecycle);
     const commitDraft = useCallback((next) => {
         setDraftState(next);
         rememberCachedDraft({ conversationId: conversationId, draft: next });
@@ -115,6 +127,7 @@ export function useComposer(options = {}) {
     const history = useComposerHistory({ setRecalledDraft: setDraftState }, {
         ...(options.historyMessages === undefined ? {} : { messages: options.historyMessages }),
         ...(options.historyScope === undefined ? {} : { scope: options.historyScope }),
+        ...(options.historyCap === undefined ? {} : { cap: options.historyCap }),
         ...(options.historyStorage === undefined ? {} : { storage: options.historyStorage }),
         ...(conversationId === undefined ? {} : { conversationId }),
     });

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

@@ -1,12 +1,17 @@
+import { type AcceptedChatInput } from '../../core/accepted-input.js';
 import type { ChatMessage } from '../../core/messages.js';
 import { type ComposerHistoryKeyInput, type ComposerHistoryStoragePort } from '../../core/composer-history.js';
 export interface ComposerHistoryController {
+    record: (required: {
+        inputs: readonly AcceptedChatInput[];
+    }, optional?: {}) => void;
     navigate: (input: ComposerHistoryKeyInput, optional?: {}) => boolean;
     edit: (required: {}, optional?: {}) => void;
 }
 export declare function useComposerHistory({ setRecalledDraft }: {
     setRecalledDraft: (text: string) => void;
-}, { messages, scope, storage, conversationId }?: {
+}, { messages, scope, storage, conversationId, cap }?: {
+    cap?: number;
     messages?: readonly ChatMessage[];
     scope?: string;
     storage?: ComposerHistoryStoragePort;

package/dist/react/hooks/useComposerHistory.hooks.js

@@ -1,36 +1,42 @@
+import { acceptedInputsFromMessages } from '../../core/accepted-input.js';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { composerHistoryKeyAction, createComposerHistoryState, mergeComposerHistory, normalizeComposerHistory, transitionComposerHistory, } from '../../core/composer-history.js';
 import { browserComposerHistoryStorage } from './composer-history-storage.js';
 const EMPTY_MESSAGES = [];
-export function useComposerHistory({ setRecalledDraft }, { messages = EMPTY_MESSAGES, scope = 'default', storage = browserComposerHistoryStorage, conversationId } = {}) {
+export function useComposerHistory({ setRecalledDraft }, { messages = EMPTY_MESSAGES, scope = 'default', storage = browserComposerHistoryStorage, conversationId, cap = 100 } = {}) {
     const browseRef = useRef(createComposerHistoryState({}));
     const [recent, setRecent] = useState([]);
     const hydratedPortRef = useRef(null);
     const [hydratedScope, setHydratedScope] = useState(null);
     const pendingRef = useRef([]);
+    const pendingBaselineRef = useRef([]);
     const conversationRef = useRef(conversationId);
     const scopeRef = useRef(scope);
-    const seenRef = useRef(new Set(messages.map((message) => message.id)));
+    const inputs = useMemo(() => acceptedInputsFromMessages({ messages }), [messages]);
+    const seenRef = useRef(new Set(inputs.flatMap(input => [input.id, ...(input.aliases ?? [])])));
     const writeQueueRef = useRef(Promise.resolve());
-    const current = useMemo(() => messages.filter((message) => message.role === 'user').map((message) => message.content), [messages]);
-    const entries = mergeComposerHistory({ recent, current });
+    const current = inputs.map(input => input.text);
+    const entries = pendingRef.current.length > 0 ? normalizeComposerHistory({ entries: recent }, { cap }) : mergeComposerHistory({ recent, current }, { cap });
     useEffect(() => {
         let cancelled = false;
         pendingRef.current = [];
+        pendingBaselineRef.current = [];
         hydratedPortRef.current = null;
         setRecent([]);
         setHydratedScope(null);
         browseRef.current = createComposerHistoryState({});
         // Read after this hook's outstanding writes so an injected async store cannot return stale
         // entries when a scope is revisited. A remounted hook's default storage writes synchronously.
-        void writeQueueRef.current.then(() => storage.read({ scope }, {})).catch(() => []).then((loaded) => {
+        void writeQueueRef.current.then(() => storage.read({ scope }, cap === 100 ? {} : { cap })).catch(() => []).then((loaded) => {
             if (cancelled)
                 return;
             // Bootstrap an empty recent store from the already-sent current transcript. This
             // makes opening a new chat useful immediately after installing recall; opening an
             // older transcript later does not reorder an established recent list.
             const seed = loaded.length > 0 ? loaded : current;
-            setRecent(normalizeComposerHistory({ entries: [...seed, ...pendingRef.current] }));
+            const baseline = pendingRef.current.length > 0
+                ? mergeComposerHistory({ recent: seed, current: pendingBaselineRef.current }, { cap }) : seed;
+            setRecent(normalizeComposerHistory({ entries: [...baseline, ...pendingRef.current] }, { cap }));
             hydratedPortRef.current = storage;
             setHydratedScope(scope);
         });
@@ -42,31 +48,45 @@ export function useComposerHistory({ setRecalledDraft }, { messages = EMPTY_MESS
         scopeRef.current = scope;
         if (adopted)
             return;
+        pendingRef.current = [];
+        pendingBaselineRef.current = [];
         browseRef.current = createComposerHistoryState({});
         // A conversation's existing turns are available for navigation, but merely opening old
         // conversations must not reorder the cross-conversation recent list.
-        seenRef.current = new Set(messages.map((message) => message.id));
+        seenRef.current = new Set(inputs.flatMap(input => [input.id, ...(input.aliases ?? [])]));
         // messages is deliberately absent: newly appended turns are handled below, not reseeded.
     }, [conversationId, scope]);
-    useEffect(() => {
+    /** All acceptance paths, including replay observations, claim identities before writing recall. */
+    const record = useCallback(({ inputs: accepted }, _options = {}) => {
         const added = [];
-        for (const message of messages) {
-            if (!seenRef.current.has(message.id) && message.role === 'user')
-                added.push(message.content);
-            seenRef.current.add(message.id);
+        const newIds = new Set();
+        for (const input of accepted) {
+            const ids = [input.id, ...(input.aliases ?? [])];
+            const seen = ids.some(id => seenRef.current.has(id));
+            for (const id of ids)
+                seenRef.current.add(id);
+            if (!seen) {
+                added.push(input.text);
+                for (const id of ids)
+                    newIds.add(id);
+            }
         }
         if (added.length === 0)
             return;
-        pendingRef.current.push(...added);
-        pendingRef.current = normalizeComposerHistory({ entries: pendingRef.current });
-        setRecent((previous) => normalizeComposerHistory({ entries: [...previous, ...added] }));
-    }, [messages]);
+        const firstAcceptance = pendingRef.current.length === 0;
+        pendingRef.current = normalizeComposerHistory({ entries: [...pendingRef.current, ...added] }, { cap });
+        const before = inputs.filter(input => !newIds.has(input.id)).map(input => input.text);
+        if (firstAcceptance)
+            pendingBaselineRef.current = before;
+        setRecent(previous => normalizeComposerHistory({ entries: [...(firstAcceptance ? mergeComposerHistory({ recent: previous, current: before }, { cap }) : previous), ...added] }, { cap }));
+    }, [cap, inputs]);
+    useEffect(() => { record({ inputs }); }, [inputs, record]);
     useEffect(() => {
         if (hydratedScope !== scope || hydratedPortRef.current !== storage)
             return;
         // Serialize writes; a slow earlier write must not overwrite a later prompt.
-        writeQueueRef.current = writeQueueRef.current.then(() => storage.write({ scope, entries: recent }, {})).catch(() => { });
-    }, [hydratedScope, recent, scope, storage]);
+        writeQueueRef.current = writeQueueRef.current.then(() => storage.write({ scope, entries: normalizeComposerHistory({ entries: recent }, { cap }) }, cap === 100 ? {} : { cap })).catch(() => { });
+    }, [hydratedScope, recent, scope, storage, cap]);
     const navigate = useCallback((input, _optional = {}) => {
         const action = composerHistoryKeyAction(input);
         if (action === null)
@@ -85,6 +105,6 @@ export function useComposerHistory({ setRecalledDraft }, { messages = EMPTY_MESS
         // the original browsing snapshot are never edited in place.
         browseRef.current = createComposerHistoryState({});
     }, []);
-    return useMemo(() => ({ navigate, edit }), [navigate, edit]);
+    return useMemo(() => ({ navigate, edit, record }), [navigate, edit, record]);
 }
 //# sourceMappingURL=useComposerHistory.hooks.js.map

package/dist/react/hooks/useComposerHistoryKeys.hooks.js

@@ -37,28 +37,38 @@ function visualLineBounds({ textarea }) {
         mirror.remove();
     }
 }
+function placeCaret(textarea, { placement }) {
+    const offset = placement === 'start' ? 0 : textarea.value.length;
+    textarea.setSelectionRange(offset, offset);
+}
+function hasModifier(event) {
+    return event.shiftKey || event.ctrlKey || event.altKey || event.metaKey;
+}
+/** Keys another handler or an IME already owns, or that an open popup should get instead. */
+function isClaimedElsewhere(event, { popupOpen }) {
+    return event.defaultPrevented || popupOpen || event.nativeEvent.isComposing || event.nativeEvent.keyCode === 229;
+}
+function isHistoryKey(event, { popupOpen }) {
+    if (hasModifier(event) || isClaimedElsewhere(event, { popupOpen }))
+        return false;
+    return ['ArrowUp', 'ArrowDown', 'Escape'].includes(event.key);
+}
 export function useComposerHistoryKeys({ composer, textareaRef }, { popupOpen = false } = {}) {
     const pendingCaretRef = useRef(null);
     // A duplicate history entry can equal the current value, so setDraft may bail out.
     // Still commit the caret request now rather than carrying it into the next real edit.
     const [, requestCaretCommit] = useReducer((revision) => revision + 1, 0);
     useLayoutEffect(() => {
-        if (!pendingCaretRef.current)
-            return;
         const placement = pendingCaretRef.current;
+        if (!placement)
+            return;
         pendingCaretRef.current = null;
         const textarea = textareaRef.current;
-        if (textarea) {
-            const offset = placement === 'start' ? 0 : textarea.value.length;
-            textarea.setSelectionRange(offset, offset);
-        }
+        if (textarea)
+            placeCaret(textarea, { placement });
     });
     return (event) => {
-        if (event.shiftKey || event.ctrlKey || event.altKey || event.metaKey)
-            return false;
-        if (event.defaultPrevented || popupOpen || event.nativeEvent.isComposing || event.nativeEvent.keyCode === 229)
-            return false;
-        if (!['ArrowUp', 'ArrowDown', 'Escape'].includes(event.key))
+        if (!isHistoryKey(event, { popupOpen }))
             return false;
         const textarea = event.currentTarget;
         const handled = composer.history?.navigate({
@@ -78,11 +88,11 @@ export function useComposerHistoryKeys({ composer, textareaRef }, { popupOpen =
             // that commit clamps it to the OLD draft's length and breaks multiline Down gating.
             // Up stays on the first line of even a multiline recall so repeated Up can browse
             // older entries. Down/Escape go to the end, including when restoring the draft.
-            pendingCaretRef.current = event.key === 'ArrowUp' ? 'start' : 'end';
+            const placement = event.key === 'ArrowUp' ? 'start' : 'end';
+            pendingCaretRef.current = placement;
             requestCaretCommit();
             // Recalling an identical string may not cause a render; the existing value is safe.
-            const offset = pendingCaretRef.current === 'start' ? 0 : textarea.value.length;
-            textarea.setSelectionRange(offset, offset);
+            placeCaret(textarea, { placement });
         }
         return handled;
     };

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

@@ -1,3 +1,4 @@
+import { type AcceptedChatInput } from '../../core/accepted-input.js';
 import { type UserTextRedactionOptions } from '../../core/user-text-redaction.js';
 import type { ChatAttachment, ChatMessage } from '../../core/index.js';
 import type { ChatTransport, RunContext } from '../../core/index.js';
@@ -18,6 +19,12 @@ export interface UseConversationOptions extends UserTextRedactionOptions {
     createMessageId?: () => string;
 }
 export interface SendMessageOptions {
+    /** Queue flushes reuse the input receipts recorded when they were queued. */
+    acceptedInputs?: AcceptedChatInput[];
+    /** Called after transport acceptance; rejection never consumes the draft or recall slot. */
+    onAccepted?: (input: {
+        inputs: AcceptedChatInput[];
+    }) => void;
     /** Non-secret signal from a composer that already sanitized the content before this boundary. */
     secretRedaction?: ChatMessage['secretRedaction'];
     attachments?: ChatAttachment[];

package/dist/react/hooks/useConversation.js

@@ -1,3 +1,4 @@
+import { acceptedInputUserEvent, projectAcceptedInputEvents } from '../../core/accepted-input.js';
 import { redactUserHistory, redactUserMessage } from '../../core/user-text-redaction.js';
 import { preserveAssistantContent, mergeRunEvents } from '../../core/durable-projection.js';
 /**
@@ -22,6 +23,18 @@ function defaultCreateMessageId() {
     fallbackIdCounter += 1;
     return `msg-${Date.now()}-${fallbackIdCounter}`;
 }
+function pendingUserMessage({ content, sendOptions, createMessageId }, options = {}) {
+    return redactUserMessage({ message: {
+            id: createMessageId(),
+            role: 'user',
+            inputPending: true,
+            ...(sendOptions.acceptedInputs ? { events: sendOptions.acceptedInputs.map(input => acceptedInputUserEvent({ input }, { receipt: 'accepted' })) } : {}),
+            content,
+            createdAt: Date.now(),
+            ...(sendOptions.secretRedaction ? { secretRedaction: sendOptions.secretRedaction } : {}),
+            ...(sendOptions.attachments ? { attachments: sendOptions.attachments } : {}),
+        } }, options).message;
+}
 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 } : {}) }));
@@ -149,7 +162,7 @@ export function useConversation(options) {
             return {
                 ...m,
                 ...(nextRunId !== undefined ? { runId: nextRunId } : {}),
-                events: mergeRunEvents({ saved: m.events, incoming: run.events }, {}),
+                events: projectAcceptedInputEvents({ events: mergeRunEvents({ saved: m.events, incoming: run.events }, {}) }),
                 // Replayed completion prefixes cannot erase a saved interrupted segment.
                 content: preserveAssistantContent({ saved: m.content, incoming: assistantContentFromEvents({ events: run.events }) }, {}),
                 runStatus,
@@ -169,14 +182,7 @@ export function useConversation(options) {
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [run.events, run.status, run.runId]);
     const sendMessage = useCallback(async (content, sendOptions = {}) => {
-        const userMessage = redactUserMessage({ message: {
-                id: createMessageId(),
-                role: 'user',
-                content,
-                createdAt: Date.now(),
-                ...(sendOptions.secretRedaction ? { secretRedaction: sendOptions.secretRedaction } : {}),
-                ...(sendOptions.attachments ? { attachments: sendOptions.attachments } : {}),
-            } }, options).message;
+        const userMessage = pendingUserMessage({ content, sendOptions, createMessageId }, options);
         const resolvedAgentId = sendOptions.agentId ?? agentId;
         const assistantMessage = {
             id: createMessageId(),
@@ -197,7 +203,7 @@ export function useConversation(options) {
         // (host stuck-chat investigation, 2026-09-27).
         setMessagesState((prev) => [...prev, userMessage, assistantMessage]);
         setScrollIntent(true);
-        await run.start({
+        const accepted = await run.start({
             assistantMessageId: assistantMessage.id,
             history,
             ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
@@ -205,6 +211,13 @@ export function useConversation(options) {
             ...(sendOptions.attachments !== undefined ? { attachments: sendOptions.attachments } : {}),
             ...(sendOptions.context !== undefined ? { context: sendOptions.context } : {}),
         });
+        if (!accepted) {
+            setMessagesState(prev => prev.filter(message => message.id !== userMessage.id && message.id !== assistantMessage.id));
+            return;
+        }
+        const inputs = sendOptions.acceptedInputs ?? [{ id: userMessage.id, text: userMessage.content }];
+        setMessagesState(prev => prev.map(message => message.id === userMessage.id ? { ...message, inputPending: false } : message));
+        sendOptions.onAccepted?.({ inputs });
     }, [agentId, conversationId, createMessageId, run, options.redactUserText, options.onSecretRedacted]);
     const retry = useCallback(async (assistantMessageId) => {
         const idx = messagesRef.current.findIndex((m) => m.id === assistantMessageId);

package/dist/react/hooks/useExtEventGroups.js

@@ -11,51 +11,51 @@
  * chrome for them).
  */
 import { useMemo } from 'react';
+function addExtEvent(state, { name, data }) {
+    const slot = state.slotOf(name, data);
+    let group = state.bySlot.get(slot);
+    if (!group) {
+        group = { name, slot, events: [] };
+        state.bySlot.set(slot, group);
+        const owner = [...state.openCalls].at(-1);
+        if (owner !== undefined)
+            state.ownerOf.set(group, { id: owner[0], ...owner[1] });
+    }
+    group.events.push(data);
+}
+function visitEvent(state, ev) {
+    if (ev.kind === 'tool_use') {
+        state.openCalls.set(ev.id, { name: ev.name, input: ev.input });
+    }
+    else if (ev.kind === 'tool_result') {
+        state.openCalls.delete(ev.toolUseId);
+        state.results.set(ev.toolUseId, { content: ev.content, isError: ev.isError });
+    }
+    else if (ev.kind === 'ext') {
+        addExtEvent(state, ev);
+    }
+}
+function attachCalls({ bySlot, ownerOf, results }) {
+    const order = [...bySlot.values()];
+    for (const group of order) {
+        const owner = ownerOf.get(group);
+        if (owner === undefined)
+            continue;
+        const result = results.get(owner.id);
+        group.call = { id: owner.id, name: owner.name, input: owner.input, ...(result === undefined ? {} : { result }) };
+    }
+    return order;
+}
 /**
  * @param slotOf - Which render slot an event belongs to. Defaults to its `name`, the one-slot-per-name
  *   grouping this hook always had; `MessageRow` passes the registry's `extEventSlot`.
  */
 export function useExtEventGroups({ events }, { slotOf = (name) => name } = {}) {
     return useMemo(() => {
-        const order = [];
-        const bySlot = new Map();
-        // Calls still open at this point in the stream, in the order they opened; the newest open one
-        // is the call an ext event arrived inside.
-        const openCalls = new Map();
-        const ownerOf = new Map();
-        const results = new Map();
-        for (const ev of events ?? []) {
-            if (ev.kind === 'tool_use') {
-                openCalls.set(ev.id, { name: ev.name, input: ev.input });
-                continue;
-            }
-            if (ev.kind === 'tool_result') {
-                openCalls.delete(ev.toolUseId);
-                results.set(ev.toolUseId, { content: ev.content, isError: ev.isError });
-                continue;
-            }
-            if (ev.kind !== 'ext')
-                continue;
-            const slot = slotOf(ev.name, ev.data);
-            let group = bySlot.get(slot);
-            if (!group) {
-                group = { name: ev.name, slot, events: [] };
-                bySlot.set(slot, group);
-                order.push(group);
-                const owner = [...openCalls].at(-1);
-                if (owner !== undefined)
-                    ownerOf.set(group, { id: owner[0], ...owner[1] });
-            }
-            group.events.push(ev.data);
-        }
-        for (const group of order) {
-            const owner = ownerOf.get(group);
-            if (owner === undefined)
-                continue;
-            const result = results.get(owner.id);
-            group.call = { name: owner.name, input: owner.input, ...(result === undefined ? {} : { result }) };
-        }
-        return order;
+        const state = { slotOf, bySlot: new Map(), openCalls: new Map(), ownerOf: new Map(), results: new Map() };
+        for (const ev of events ?? [])
+            visitEvent(state, ev);
+        return attachCalls(state);
     }, [events, slotOf]);
 }
 //# sourceMappingURL=useExtEventGroups.js.map

package/dist/react/hooks/useQuestionForms.js

@@ -17,33 +17,28 @@
  */
 import { useCallback, useMemo } from 'react';
 import { findFirstQuestionForm, formOptionValueForLabel, formatFormAnswers } from '../../core/index.js';
-export function useQuestionForms({ messages }) {
-    const forms = useMemo(() => {
-        if (!messages || messages.length === 0)
-            return [];
-        const out = [];
-        for (let i = 0; i < messages.length; i += 1) {
-            const message = messages[i];
-            if (!message || message.role !== 'assistant')
-                continue;
-            const found = findFirstQuestionForm({ input: message.content });
-            if (!found)
-                continue;
-            const nextMessage = messages[i + 1];
-            const submittedAnswers = nextMessage && nextMessage.role === 'user' ? parseSubmittedAnswers({ form: found.form, userMessageContent: nextMessage.content }) ?? undefined : undefined;
-            const interactive = submittedAnswers === undefined && i === messages.length - 1;
-            out.push({ form: found.form, raw: found.raw, messageId: message.id, interactive, submittedAnswers });
-        }
-        return out;
-    }, [messages]);
-    const activeForm = useMemo(() => {
-        for (let i = forms.length - 1; i >= 0; i -= 1) {
-            const form = forms[i];
-            if (form?.interactive)
-                return form;
-        }
+/**
+ * The question-form on `messages[index]`, or `null` when that message is not
+ * an assistant message or carries no form. Answers come from the message right
+ * after it, and only when that one is a user reply.
+ */
+function parseFormAt(messages, { index }) {
+    // Only called with an index `flatMap` is visiting (it skips holes), so the
+    // element is always defined.
+    const message = messages[index];
+    if (message.role !== 'assistant')
         return null;
-    }, [forms]);
+    const found = findFirstQuestionForm({ input: message.content });
+    if (!found)
+        return null;
+    const nextMessage = messages[index + 1];
+    const submittedAnswers = nextMessage?.role === 'user' ? parseSubmittedAnswers({ form: found.form, userMessageContent: nextMessage.content }) ?? undefined : undefined;
+    const interactive = submittedAnswers === undefined && index === messages.length - 1;
+    return { form: found.form, raw: found.raw, messageId: message.id, interactive, submittedAnswers };
+}
+export function useQuestionForms({ messages }) {
+    const forms = useMemo(() => (messages ?? []).flatMap((_, index, all) => parseFormAt(all, { index }) ?? []), [messages]);
+    const activeForm = useMemo(() => forms.findLast((form) => form.interactive) ?? null, [forms]);
     const buildSubmission = useCallback((form, answers) => formatFormAnswers({ form: form, answers: answers }), []);
     return { forms, activeForm, buildSubmission };
 }

package/dist/react/hooks/useRunStream.js

@@ -51,6 +51,9 @@ const INITIAL_STATE = {
 };
 export function useRunStream({ transport }) {
     const [state, setState] = useState(INITIAL_STATE);
+    // Acceptance/checkpoints can precede React's next commit. Cancellation needs the live id,
+    // even when the Stop handler still belongs to the render that showed a pending start.
+    const runIdRef = useRef(null);
     const subscriptionAbortRef = useRef(null);
     const cancelAbortRef = useRef(null);
     // Bumped on every start/reattach/reset. A handler closes over the
@@ -81,6 +84,7 @@ export function useRunStream({ transport }) {
             onCheckpoint: (message) => {
                 if (isStale())
                     return;
+                runIdRef.current = message.runId ?? runIdRef.current;
                 const statuses = { queued: 'streaming', running: 'streaming', succeeded: 'done', failed: 'error', canceled: 'canceled' };
                 setState((prev) => ({ ...prev, runId: message.runId ?? prev.runId,
                     status: message.runStatus ? statuses[message.runStatus] : prev.status,
@@ -115,6 +119,7 @@ export function useRunStream({ transport }) {
     const start = useCallback(async (input) => {
         teardownSubscription();
         const generation = ++generationRef.current;
+        runIdRef.current = null;
         const subscriptionAbort = new AbortController();
         const cancelAbort = new AbortController();
         subscriptionAbortRef.current = subscriptionAbort;
@@ -129,6 +134,7 @@ export function useRunStream({ transport }) {
                 }
                 return { runId };
             }
+            runIdRef.current = runId;
             setState((prev) => ({ ...prev, runId }));
             return { runId };
         }
@@ -145,6 +151,7 @@ export function useRunStream({ transport }) {
     const reattach = useCallback(async (runId, initialEvents = []) => {
         teardownSubscription();
         const generation = ++generationRef.current;
+        runIdRef.current = runId;
         const subscriptionAbort = new AbortController();
         const cancelAbort = new AbortController();
         subscriptionAbortRef.current = subscriptionAbort;
@@ -165,7 +172,7 @@ export function useRunStream({ transport }) {
     }, [makeHandlers, teardownSubscription]);
     const cancel = useCallback(() => {
         cancelAbortRef.current?.abort();
-        const runId = state.runId;
+        const runId = runIdRef.current;
         // Recorded BEFORE the bump, so it names the generation currently in flight. When `runId` is
         // already known the `stopRun` below does the work and this entry is simply never consumed;
         // when it is not, this is the only thing that will ever stop that run.
@@ -176,9 +183,10 @@ export function useRunStream({ transport }) {
         setState((prev) => ({ ...prev, status: 'canceled' }));
         if (runId)
             runStopRunHostEffect('transport.stopRun (cancel)', () => transport.stopRun(runId));
-    }, [state.runId, teardownSubscription, transport]);
+    }, [teardownSubscription, transport]);
     const reset = useCallback(() => {
         generationRef.current += 1;
+        runIdRef.current = null;
         teardownSubscription();
         setState(INITIAL_STATE);
     }, [teardownSubscription]);

package/dist/react/index.d.ts

@@ -3,6 +3,10 @@
  * chat/core vocabulary. Every export is explicit: adding or renaming a name here is a public API
  * review, so internal module exports cannot silently become public. Do not use export *.
  */
+export { ChatSettingsDialog } from './components/ChatSettingsDialog.js';
+export { ChatSettingsSegmented } from './components/ChatSettingsSegmented.js';
+export { useChatSettingsDialog } from './components/ChatSettingsDialog.hooks.js';
+export type { ChatPermissionsPort, ChatSettingsSection } from './components/ChatSettingsDialog.hooks.js';
 export type { ChatTransport, FeedbackChange, OnFeedback, ReattachRunOptions, RunContext, RunHandlers, StartRunInput, UserTextRedaction, } from '../core/index.js';
 export { RendererRegistry, } from './artifact-types.js';
 export type { ArtifactFile, ArtifactRenderContext, ArtifactRenderMatch, ArtifactRenderer, } from './artifact-types.js';
@@ -25,7 +29,7 @@ export type { RunStreamState, RunStreamStatus, StartRunOptions, UseRunStreamResu
 export { useConversation, } from './hooks/useConversation.js';
 export type { SendMessageOptions, UseConversationOptions, UseConversationResult, } from './hooks/useConversation.js';
 export { useComposer, } from './hooks/useComposer.js';
-export type { ComposerDraftPersistence, MentionPopoverState, UseComposerOptions, UseComposerResult, } from './hooks/useComposer.js';
+export type { ComposerDraftPersistence, ComposerPageLifecycle, MentionPopoverState, UseComposerOptions, UseComposerResult, } from './hooks/useComposer.js';
 export { useToolTimeline, } from './hooks/useToolTimeline.js';
 export type { ToolTimelineRow, UseToolTimelineOptions, UseToolTimelineResult, } from './hooks/useToolTimeline.js';
 export { useExtEventGroups, } from './hooks/useExtEventGroups.js';
@@ -97,6 +101,8 @@ export type { TodoCardProps } from './components/TodoCard.js';
  * `leadingAccessory` slot; it needs no changes to `ChatPane` itself.
  */
 export { ConversationList } from './components/ConversationList.js';
+export { ConversationTitle, ConversationTitleEditor } from './components/ConversationTitleEditor.js';
+export type { ConversationTitleProps, ConversationTitleEditorProps } from './components/ConversationTitleEditor.js';
 export type { ConversationListProps, ConversationListItem } from './components/ConversationList.js';
 /**
  * The conversation an operator last had open, per caller identity — so a host's switcher lands

package/dist/react/index.js

@@ -1,3 +1,11 @@
+/**
+ * @jini-ai/chat/react — headless hooks, presentational components and slots over framework-free
+ * chat/core vocabulary. Every export is explicit: adding or renaming a name here is a public API
+ * review, so internal module exports cannot silently become public. Do not use export *.
+ */
+export { ChatSettingsDialog } from './components/ChatSettingsDialog.js';
+export { ChatSettingsSegmented } from './components/ChatSettingsSegmented.js';
+export { useChatSettingsDialog } from './components/ChatSettingsDialog.hooks.js';
 export { RendererRegistry, } from './artifact-types.js';
 export { createToolRendererRegistry, clearToolRenderers, getToolRenderer, registerToolRenderer, } from './tool-renderer-registry.js';
 export { createExtEventRendererRegistry, clearExtEventRenderers, extEventSlot, getExtEventRenderer, registerExtEventRenderer, } from './ext-event-renderer-registry.js';
@@ -89,6 +97,7 @@ export { TodoCard } from './components/TodoCard.js';
  * `leadingAccessory` slot; it needs no changes to `ChatPane` itself.
  */
 export { ConversationList } from './components/ConversationList.js';
+export { ConversationTitle, ConversationTitleEditor } from './components/ConversationTitleEditor.js';
 /**
  * The conversation an operator last had open, per caller identity — so a host's switcher lands
  * back on it after a reload instead of an empty new chat. See the module doc for the contract.

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

@@ -85,6 +85,10 @@ export type MessageBlock<Row> = {
     readonly text: string;
     readonly key: string;
 };
+type SlotOf = (ev: {
+    readonly name: string;
+    readonly data: unknown;
+}) => string;
 /**
  * Rebuilds an assistant message as ordered blocks, or returns `null` if that cannot be done
  * losslessly.
@@ -107,10 +111,8 @@ export declare function interleaveMessageBlocks<Row extends {
     content: string;
     rows: readonly Row[];
 }, { slotOf, includeThinking }?: {
-    slotOf?: (ev: {
-        readonly name: string;
-        readonly data: unknown;
-    }) => string;
+    slotOf?: SlotOf;
     includeThinking?: boolean;
 }): MessageBlock<Row>[] | null;
+export {};
 //# sourceMappingURL=message-blocks.d.ts.map