@jini-ai/chat 0.5.2 → 0.5.4

package/dist/react/hooks/composer-draft-cache.js

@@ -62,6 +62,10 @@ export const COMPOSER_DRAFT_STORAGE_PREFIX = 'jini.chat.composer-draft.v1.';
 export const COMPOSER_ATTACHMENTS_STORAGE_PREFIX = 'jini.chat.composer-attachments.v1.';
 const drafts = new Map();
 const stagedAttachments = new Map();
+// Kept beside `stagedAttachments` rather than inside it so `writeCachedAttachments` keeps its
+// attachments-only signature: `useComposer` persists the list and never sees a batch id, while
+// `useChatPane` (the one caller that uploads in batches) records the batch here.
+const stagedBatchIds = new Map();
 /**
  * The origin's `localStorage`, or `null` when it cannot be used.
  *
@@ -282,10 +286,11 @@ function isChatAttachment(candidate) {
     return true;
 }
 /**
- * Reads the stored attachment references for `conversationId`.
+ * Reads the stored attachment references (and their upload batch) for `conversationId`.
  *
  * Elements that do not validate are dropped individually rather than failing the whole entry — one
- * malformed row should cost the operator that row, not every attachment on the turn.
+ * malformed row should cost the operator that row, not every attachment on the turn. A missing or
+ * malformed batch id costs only the batch (`batchId: null`), never the references.
  *
  * @returns The stored references, or `null` when there are none, storage is unavailable, or nothing
  * in the entry validated.
@@ -302,6 +307,7 @@ function readStoredAttachments(conversationId) {
             return null;
         const parsed = JSON.parse(raw);
         const list = parsed?.a;
+        const batchId = parsed?.b;
         if (!Array.isArray(list)) {
             store.removeItem(key);
             return null;
@@ -311,7 +317,7 @@ function readStoredAttachments(conversationId) {
             store.removeItem(key);
             return null;
         }
-        return valid;
+        return { attachments: valid, batchId: typeof batchId === 'string' && batchId !== '' ? batchId : null };
     }
     catch {
         try {
@@ -345,8 +351,48 @@ export function readCachedAttachments({ conversationId }) {
     const stored = readStoredAttachments(conversationId);
     if (stored === null)
         return null;
-    stagedAttachments.set(conversationId, stored);
-    return stored;
+    stagedAttachments.set(conversationId, stored.attachments);
+    if (stored.batchId !== null)
+        stagedBatchIds.set(conversationId, stored.batchId);
+    return stored.attachments;
+}
+/**
+ * The upload batch `conversationId`'s cached attachments were uploaded under, so a pane that
+ * restores those attachments uploads the next file into the SAME batch.
+ *
+ * Why this exists: the daemon grants the agent exactly one batch directory per turn and refuses a
+ * turn whose attachments span two ("Attachments must belong to one batch"). A pane that restored an
+ * attachment after a remount, reload, or conversation switch used to upload the next file under a
+ * brand-new batch id, so every such turn failed before the agent started (2026-10-06).
+ *
+ * @returns The batch id, or `null` when there are no cached attachments to stay consistent with
+ * (none staged, attachment persistence off because the host supplied no validator, or an entry
+ * written before batch ids were recorded) — the caller then starts a fresh batch.
+ * @complexity Time/space: O(1) on an in-memory hit, O(n) in the stored count otherwise.
+ */
+export function readCachedAttachmentBatchId({ conversationId }) {
+    if (!conversationId)
+        return null;
+    if (readCachedAttachments({ conversationId: conversationId }) === null)
+        return null;
+    return stagedBatchIds.get(conversationId) ?? null;
+}
+/**
+ * Records the upload batch of an attachment about to be staged in `conversationId`'s composer.
+ * Memory only: the stored envelope picks it up on the {@link writeCachedAttachments} that persists
+ * that attachment, so it is never written ahead of the references it describes.
+ *
+ * @complexity Time/space: O(1) amortized.
+ */
+export function writeCachedAttachmentBatchId({ conversationId, batchId }) {
+    if (!conversationId)
+        return;
+    if (!stagedBatchIds.has(conversationId) && stagedBatchIds.size >= MAX_CACHED_CONVERSATION_DRAFTS) {
+        const oldest = stagedBatchIds.keys().next().value;
+        if (oldest !== undefined)
+            stagedBatchIds.delete(oldest);
+    }
+    stagedBatchIds.set(conversationId, batchId);
 }
 /**
  * Stores `attachments` for `conversationId` in both tiers.
@@ -362,6 +408,8 @@ export function writeCachedAttachments({ conversationId, attachments }) {
     const store = storage();
     if (attachments.length === 0) {
         stagedAttachments.delete(conversationId);
+        // A sent or cleared turn's batch is spent; the next upload starts a fresh one.
+        stagedBatchIds.delete(conversationId);
         try {
             store?.removeItem(key);
         }
@@ -381,7 +429,8 @@ export function writeCachedAttachments({ conversationId, attachments }) {
     try {
         if (store.getItem(key) === null)
             pruneStored(COMPOSER_ATTACHMENTS_STORAGE_PREFIX, MAX_CACHED_CONVERSATION_DRAFTS - 1);
-        const envelope = { v: 1, t: Date.now(), a: attachments };
+        const batchId = stagedBatchIds.get(conversationId);
+        const envelope = { v: 1, t: Date.now(), a: attachments, ...(batchId === undefined ? {} : { b: batchId }) };
         store.setItem(key, JSON.stringify(envelope));
     }
     catch {
@@ -399,6 +448,7 @@ export function writeCachedAttachments({ conversationId, attachments }) {
 export function __resetComposerDraftCacheForTests(options) {
     drafts.clear();
     stagedAttachments.clear();
+    stagedBatchIds.clear();
     if (options?.keepStorage === true)
         return;
     pruneStored(COMPOSER_DRAFT_STORAGE_PREFIX, 0);

package/dist/react/hooks/composer-history-storage.d.ts

@@ -0,0 +1,8 @@
+import { type ComposerHistoryStoragePort } from '../../core/composer-history.js';
+/** Browser default; private/embedded hosts may replace this port without changing recall. */
+export declare function createBrowserComposerHistoryStorage(_required: {}, { storage, prefix }?: {
+    storage?: Pick<Storage, 'getItem' | 'setItem'>;
+    prefix?: string;
+}): ComposerHistoryStoragePort;
+export declare const browserComposerHistoryStorage: ComposerHistoryStoragePort;
+//# sourceMappingURL=composer-history-storage.d.ts.map

package/dist/react/hooks/composer-history-storage.js

@@ -0,0 +1,40 @@
+import { normalizeComposerHistory } from '../../core/composer-history.js';
+/** Browser default; private/embedded hosts may replace this port without changing recall. */
+export function createBrowserComposerHistoryStorage(_required, { storage, prefix = 'jini:composer-history:v1:' } = {}) {
+    const memory = new Map();
+    function resolveStorage() {
+        // Accessing localStorage itself can throw (sandboxed embeds/private browsing).
+        return storage ?? globalThis.localStorage;
+    }
+    return {
+        async read({ scope }, _optional = {}) {
+            try {
+                const raw = resolveStorage()?.getItem(prefix + encodeURIComponent(scope));
+                if (raw) {
+                    const parsed = JSON.parse(raw);
+                    if (Array.isArray(parsed)) {
+                        const entries = normalizeComposerHistory({ entries: parsed.filter((value) => typeof value === 'string') });
+                        memory.set(scope, entries);
+                        return entries;
+                    }
+                }
+            }
+            catch {
+                // Storage denial/corruption must not disable draft editing or in-memory recall.
+            }
+            return memory.get(scope) ?? [];
+        },
+        async write({ scope, entries }, _optional = {}) {
+            const normalized = normalizeComposerHistory({ entries });
+            memory.set(scope, normalized);
+            try {
+                resolveStorage()?.setItem(prefix + encodeURIComponent(scope), JSON.stringify(normalized));
+            }
+            catch {
+                // Quota/denial falls back to the same scoped in-memory list.
+            }
+        },
+    };
+}
+export const browserComposerHistoryStorage = createBrowserComposerHistoryStorage({});
+//# sourceMappingURL=composer-history-storage.js.map

package/dist/react/hooks/last-conversation-store.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @module last-conversation-store
+ *
+ * Remembers which conversation an operator last had open, so a host's chat surface can land back
+ * on it after a page reload, a closed tab, or a navigation away — instead of an empty new chat.
+ *
+ * Conversation SELECTION is host-owned (`ChatPane` is uncontrolled and takes a `conversationId`;
+ * `ConversationList` takes `activeConversationId` as a prop), so this module does not decide when
+ * to restore. It is only the durable slot: the host reads it once at mount, checks the id still
+ * exists for this caller, and writes it whenever its active conversation changes.
+ *
+ * Same storage discipline as `composer-draft-cache.ts`: a versioned key, every access wrapped, and a
+ * foreign or corrupt entry treated as "nothing remembered" and deleted. A private window, blocked
+ * site data or a quota rejection degrades this to remembering nothing — never a throw at the host.
+ *
+ * Unlike the draft cache this is NOT a module singleton. The partition here is the caller's
+ * identity (`scope`), which only the host knows — two users on one browser must never land in each
+ * other's chat — so a host constructs one store per scope and passes it down.
+ */
+/**
+ * Key prefix for the stored entry. Versioned (`.v1.`) so a future change to the stored shape can be
+ * introduced without interpreting, or mis-interpreting, entries written by this one.
+ */
+export declare const LAST_CONVERSATION_STORAGE_PREFIX = "jini.chat.last-conversation.v1.";
+/** The subset of Web Storage this module uses — `localStorage` satisfies it; tests pass a fake. */
+export interface LastConversationStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/** The host-facing port. Every method is total: none throws, whatever storage does. */
+export interface LastConversationStore {
+    /** The remembered conversation id, or `null` when there is none or storage is unusable. */
+    read(): string | null;
+    /** Remembers `conversationId` as the one to land on next time, replacing any earlier one. */
+    write(conversationId: string): void;
+    /** Forgets the remembered id — for a conversation that was deleted or is no longer reachable. */
+    clear(): void;
+}
+/**
+ * Creates the last-conversation slot for one caller identity.
+ *
+ * @param required.scope Who this memory belongs to — e.g. `${workspaceId}:${userId}`. Part of the
+ *   key, so a different scope on the same browser reads nothing.
+ * @param optional.storage Defaults to the origin's `localStorage`, resolved on every call (not once)
+ *   so a store created during SSR still works after hydration. `null` disables persistence.
+ * @returns A {@link LastConversationStore}; see its methods for the never-throws contract.
+ * @example
+ * const store = createLastConversationStore({ scope: `${workspaceId}:${user.id}` });
+ * const id = store.read(); // land here if it still exists, else store.clear()
+ * @complexity Time/space: O(1) per call, plus O(n) in the entry's length for the JSON parse.
+ */
+export declare function createLastConversationStore({ scope }: {
+    scope: string;
+}, { storage }?: {
+    storage?: LastConversationStorage | null;
+}): LastConversationStore;
+//# sourceMappingURL=last-conversation-store.d.ts.map

package/dist/react/hooks/last-conversation-store.js

@@ -0,0 +1,112 @@
+/**
+ * @module last-conversation-store
+ *
+ * Remembers which conversation an operator last had open, so a host's chat surface can land back
+ * on it after a page reload, a closed tab, or a navigation away — instead of an empty new chat.
+ *
+ * Conversation SELECTION is host-owned (`ChatPane` is uncontrolled and takes a `conversationId`;
+ * `ConversationList` takes `activeConversationId` as a prop), so this module does not decide when
+ * to restore. It is only the durable slot: the host reads it once at mount, checks the id still
+ * exists for this caller, and writes it whenever its active conversation changes.
+ *
+ * Same storage discipline as `composer-draft-cache.ts`: a versioned key, every access wrapped, and a
+ * foreign or corrupt entry treated as "nothing remembered" and deleted. A private window, blocked
+ * site data or a quota rejection degrades this to remembering nothing — never a throw at the host.
+ *
+ * Unlike the draft cache this is NOT a module singleton. The partition here is the caller's
+ * identity (`scope`), which only the host knows — two users on one browser must never land in each
+ * other's chat — so a host constructs one store per scope and passes it down.
+ */
+/**
+ * Key prefix for the stored entry. Versioned (`.v1.`) so a future change to the stored shape can be
+ * introduced without interpreting, or mis-interpreting, entries written by this one.
+ */
+export const LAST_CONVERSATION_STORAGE_PREFIX = 'jini.chat.last-conversation.v1.';
+/**
+ * The origin's `localStorage`, or `null` when it cannot be used — a non-browser runtime, or a
+ * browser that throws on the property access itself (Safari and Chrome both do with site data
+ * blocked), which is why this is a try/catch rather than a `typeof` check alone.
+ * @complexity Time/space: O(1).
+ */
+function browserStorage() {
+    try {
+        return typeof localStorage === 'undefined' ? null : localStorage;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Validates one parsed entry as this module's own envelope.
+ * @complexity Time/space: O(1).
+ */
+function storedId(parsed) {
+    const entry = parsed;
+    if (entry?.v !== 1 || typeof entry.id !== 'string' || entry.id === '')
+        return null;
+    return entry.id;
+}
+/**
+ * Creates the last-conversation slot for one caller identity.
+ *
+ * @param required.scope Who this memory belongs to — e.g. `${workspaceId}:${userId}`. Part of the
+ *   key, so a different scope on the same browser reads nothing.
+ * @param optional.storage Defaults to the origin's `localStorage`, resolved on every call (not once)
+ *   so a store created during SSR still works after hydration. `null` disables persistence.
+ * @returns A {@link LastConversationStore}; see its methods for the never-throws contract.
+ * @example
+ * const store = createLastConversationStore({ scope: `${workspaceId}:${user.id}` });
+ * const id = store.read(); // land here if it still exists, else store.clear()
+ * @complexity Time/space: O(1) per call, plus O(n) in the entry's length for the JSON parse.
+ */
+export function createLastConversationStore({ scope }, { storage } = {}) {
+    const key = `${LAST_CONVERSATION_STORAGE_PREFIX}${encodeURIComponent(scope)}`;
+    const resolve = () => (storage === undefined ? browserStorage() : storage);
+    const remove = (store) => {
+        try {
+            store.removeItem(key);
+        }
+        catch {
+            /* storage is unusable; nothing further this module can do */
+        }
+    };
+    return {
+        read() {
+            const store = resolve();
+            if (!store)
+                return null;
+            try {
+                const raw = store.getItem(key);
+                if (raw === null)
+                    return null;
+                const id = storedId(JSON.parse(raw));
+                if (id === null)
+                    remove(store);
+                return id;
+            }
+            catch {
+                // A parse failure or a throwing read: a corrupt entry must not survive to be read again.
+                remove(store);
+                return null;
+            }
+        },
+        write(conversationId) {
+            const store = resolve();
+            if (!store)
+                return;
+            try {
+                const envelope = { v: 1, id: conversationId };
+                store.setItem(key, JSON.stringify(envelope));
+            }
+            catch {
+                /* blocked, full, or unusable storage — remembering nothing is the documented degraded mode */
+            }
+        },
+        clear() {
+            const store = resolve();
+            if (store)
+                remove(store);
+        },
+    };
+}
+//# sourceMappingURL=last-conversation-store.js.map

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

@@ -1,4 +1,6 @@
-import type { ChatAttachment } from '../../core/index.js';
+import type { ChatAttachment, ChatMessage } from '../../core/index.js';
+import type { ComposerHistoryStoragePort } from '../../core/composer-history.js';
+import { type ComposerHistoryController } from './useComposerHistory.hooks.js';
 import type { AgentSelection, ComposerSlots, MentionResult, ProjectContextValue } from '../slots.js';
 export interface ComposerDraftPersistence {
     read: () => string | null;
@@ -6,6 +8,11 @@ export interface ComposerDraftPersistence {
 }
 export interface UseComposerOptions {
     initialDraft?: string;
+    /** This principal's current transcript; only user-role text participates in recall. */
+    historyMessages?: readonly ChatMessage[];
+    /** Scopes recent prompts across conversations. Hosts with multiple users must supply an id. */
+    historyScope?: string;
+    historyStorage?: ComposerHistoryStoragePort;
     initialAgent?: AgentSelection;
     project?: ProjectContextValue;
     composerSlots?: ComposerSlots;
@@ -42,6 +49,8 @@ export interface MentionPopoverState {
 }
 export interface UseComposerResult {
     draft: string;
+    /** Optional for compatibility with host-created composer controllers. */
+    history?: ComposerHistoryController;
     setDraft: (next: string) => void;
     attachments: ChatAttachment[];
     /** Uploads via `project.uploadFiles` (when supplied) and stages the results; no-ops (with a rejected promise) when no upload port is wired. */

package/dist/react/hooks/useComposer.js

@@ -28,6 +28,7 @@
  * the wrong thread, so they are cleared instead.
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useComposerHistory } from './useComposerHistory.hooks.js';
 import { readCachedAttachments, readCachedDraft, writeCachedAttachments, writeCachedDraft, } from './composer-draft-cache.js';
 import { cacheAttachmentPreviewSource } from './attachment-preview-cache.js';
 const EMPTY_MENTION = { open: false, query: '', results: [] };
@@ -37,11 +38,21 @@ export function useComposer(options = {}) {
     const [attachments, setAttachments] = useState([]);
     const [agent, setAgent] = useState(options.initialAgent);
     const [mention, setMention] = useState(EMPTY_MENTION);
-    const setDraft = useCallback((next) => {
+    const commitDraft = useCallback((next) => {
         setDraftState(next);
         persistence?.write(next);
         writeCachedDraft({ conversationId: conversationId, draft: next });
     }, [persistence, conversationId]);
+    const history = useComposerHistory({ setRecalledDraft: setDraftState }, {
+        ...(options.historyMessages === undefined ? {} : { messages: options.historyMessages }),
+        ...(options.historyScope === undefined ? {} : { scope: options.historyScope }),
+        ...(options.historyStorage === undefined ? {} : { storage: options.historyStorage }),
+        ...(conversationId === undefined ? {} : { conversationId }),
+    });
+    const setDraft = useCallback((next) => {
+        history.edit({});
+        commitDraft(next);
+    }, [commitDraft, history.edit]);
     // Lets the conversation-change effect below read the live draft without taking `draft` as a
     // dependency, which would re-run it on every keystroke.
     const draftRef = useRef(draft);
@@ -195,6 +206,7 @@ export function useComposer(options = {}) {
     const canSubmit = draft.trim().length > 0 || attachments.length > 0;
     return useMemo(() => ({
         draft,
+        history,
         setDraft,
         attachments,
         addAttachments,
@@ -209,6 +221,6 @@ export function useComposer(options = {}) {
         selectMention,
         canSubmit,
         reset,
-    }), [draft, setDraft, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset]);
+    }), [draft, history, setDraft, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset]);
 }
 //# sourceMappingURL=useComposer.js.map

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

@@ -0,0 +1,15 @@
+import type { ChatMessage } from '../../core/messages.js';
+import { type ComposerHistoryKeyInput, type ComposerHistoryStoragePort } from '../../core/composer-history.js';
+export interface ComposerHistoryController {
+    navigate: (input: ComposerHistoryKeyInput, optional?: {}) => boolean;
+    edit: (required: {}, optional?: {}) => void;
+}
+export declare function useComposerHistory({ setRecalledDraft }: {
+    setRecalledDraft: (text: string) => void;
+}, { messages, scope, storage, conversationId }?: {
+    messages?: readonly ChatMessage[];
+    scope?: string;
+    storage?: ComposerHistoryStoragePort;
+    conversationId?: string | null;
+}): ComposerHistoryController;
+//# sourceMappingURL=useComposerHistory.hooks.d.ts.map

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

@@ -0,0 +1,90 @@
+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 } = {}) {
+    const browseRef = useRef(createComposerHistoryState({}));
+    const [recent, setRecent] = useState([]);
+    const hydratedPortRef = useRef(null);
+    const [hydratedScope, setHydratedScope] = useState(null);
+    const pendingRef = useRef([]);
+    const conversationRef = useRef(conversationId);
+    const scopeRef = useRef(scope);
+    const seenRef = useRef(new Set(messages.map((message) => message.id)));
+    const writeQueueRef = useRef(Promise.resolve());
+    const current = useMemo(() => messages.filter((message) => message.role === 'user').map((message) => message.content), [messages]);
+    const entries = mergeComposerHistory({ recent, current });
+    useEffect(() => {
+        let cancelled = false;
+        pendingRef.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) => {
+            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] }));
+            hydratedPortRef.current = storage;
+            setHydratedScope(scope);
+        });
+        return () => { cancelled = true; };
+    }, [scope, storage]);
+    useEffect(() => {
+        const adopted = conversationRef.current == null && conversationId != null && scopeRef.current === scope;
+        conversationRef.current = conversationId;
+        scopeRef.current = scope;
+        if (adopted)
+            return;
+        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));
+        // messages is deliberately absent: newly appended turns are handled below, not reseeded.
+    }, [conversationId, scope]);
+    useEffect(() => {
+        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);
+        }
+        if (added.length === 0)
+            return;
+        pendingRef.current.push(...added);
+        pendingRef.current = normalizeComposerHistory({ entries: pendingRef.current });
+        setRecent((previous) => normalizeComposerHistory({ entries: [...previous, ...added] }));
+    }, [messages]);
+    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]);
+    const navigate = useCallback((input, _optional = {}) => {
+        const action = composerHistoryKeyAction(input);
+        if (action === null)
+            return false;
+        const transition = transitionComposerHistory({ state: browseRef.current, action, text: input.text, entries });
+        if (!transition.handled)
+            return false;
+        browseRef.current = transition.state;
+        // Recall is a view, not an edit to the cached working draft. Reload while copying a
+        // recalled entry still restores what the operator was writing before they browsed.
+        setRecalledDraft(transition.text);
+        return true;
+    }, [entries, setRecalledDraft]);
+    const edit = useCallback((_required, _optional = {}) => {
+        // The first edit leaves history. Its text is now the working draft; stored entries and
+        // the original browsing snapshot are never edited in place.
+        browseRef.current = createComposerHistoryState({});
+    }, []);
+    return useMemo(() => ({ navigate, edit }), [navigate, edit]);
+}
+//# sourceMappingURL=useComposerHistory.hooks.js.map

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

@@ -0,0 +1,9 @@
+import { type KeyboardEvent, type RefObject } from 'react';
+import type { UseComposerResult } from './useComposer.js';
+export declare function useComposerHistoryKeys({ composer, textareaRef }: {
+    composer: UseComposerResult;
+    textareaRef: RefObject<HTMLTextAreaElement | null>;
+}, { popupOpen }?: {
+    popupOpen?: boolean;
+}): (event: KeyboardEvent<HTMLTextAreaElement>) => boolean;
+//# sourceMappingURL=useComposerHistoryKeys.hooks.d.ts.map

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

@@ -0,0 +1,90 @@
+import { useLayoutEffect, useReducer, useRef } from 'react';
+/** Measures visual lines as well as newlines, so a wrapped paragraph keeps native arrow motion. */
+function visualLineBounds({ textarea }) {
+    if (textarea.clientWidth === 0)
+        return {};
+    const computed = getComputedStyle(textarea);
+    const mirror = document.createElement('div');
+    for (const property of ['font', 'letter-spacing', 'word-spacing', 'line-height', 'text-indent', 'padding', 'tab-size', 'word-break', 'overflow-wrap', 'direction']) {
+        mirror.style.setProperty(property, computed.getPropertyValue(property));
+    }
+    mirror.style.position = 'fixed';
+    mirror.style.visibility = 'hidden';
+    mirror.style.pointerEvents = 'none';
+    mirror.style.whiteSpace = 'pre-wrap';
+    mirror.style.overflowWrap = 'break-word';
+    mirror.style.boxSizing = 'border-box';
+    mirror.style.width = `${textarea.clientWidth}px`;
+    const text = document.createTextNode(textarea.value);
+    mirror.append(text, document.createTextNode('\u200b'));
+    document.body.append(mirror);
+    try {
+        function lineAt(offset) {
+            const range = document.createRange();
+            range.setStart(text, offset);
+            range.setEnd(text, offset);
+            return range.getBoundingClientRect().top;
+        }
+        const first = lineAt(0);
+        const last = lineAt(text.length);
+        // Both selection endpoints must be on the boundary visual line. Selecting across soft
+        // wraps should stay native just like selecting across explicit newline characters.
+        const start = lineAt(textarea.selectionStart);
+        const end = lineAt(textarea.selectionEnd);
+        return { firstLine: Math.abs(start - first) < 1 && Math.abs(end - first) < 1, lastLine: Math.abs(start - last) < 1 && Math.abs(end - last) < 1 };
+    }
+    finally {
+        mirror.remove();
+    }
+}
+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;
+        pendingCaretRef.current = null;
+        const textarea = textareaRef.current;
+        if (textarea) {
+            const offset = placement === 'start' ? 0 : textarea.value.length;
+            textarea.setSelectionRange(offset, offset);
+        }
+    });
+    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))
+            return false;
+        const textarea = event.currentTarget;
+        const handled = composer.history?.navigate({
+            key: event.key,
+            text: textarea.value,
+            selectionStart: textarea.selectionStart,
+            selectionEnd: textarea.selectionEnd,
+            shiftKey: event.shiftKey,
+            ctrlKey: event.ctrlKey,
+            altKey: event.altKey,
+            metaKey: event.metaKey,
+            ...visualLineBounds({ textarea }),
+        }) ?? false;
+        if (handled) {
+            event.preventDefault();
+            // React's controlled value lands on the following commit. Placing the caret before
+            // 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';
+            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);
+        }
+        return handled;
+    };
+}
+//# sourceMappingURL=useComposerHistoryKeys.hooks.js.map

package/dist/react/hooks/useConversation.js

@@ -1,3 +1,4 @@
+import { preserveAssistantContent, mergeRunEvents } from '../../core/durable-projection.js';
 /**
  * @module useConversation
  *
@@ -113,8 +114,9 @@ export function useConversation(options) {
             return {
                 ...m,
                 ...(nextRunId !== undefined ? { runId: nextRunId } : {}),
-                events: run.events,
-                content: assistantContentFromEvents({ events: run.events }),
+                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,
                 ...(isTerminalRunStatus({ status: runStatus }) ? { endedAt: Date.now() } : {}),
             };
@@ -160,6 +162,7 @@ export function useConversation(options) {
         setMessagesState((prev) => [...prev, userMessage, assistantMessage]);
         setScrollIntent(true);
         await run.start({
+            assistantMessageId: assistantMessage.id,
             history,
             ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
             conversationId,
@@ -191,6 +194,7 @@ export function useConversation(options) {
         // attachment beside the user turn, the failure reads as the model ignoring it rather than as
         // the client never having sent it.
         await run.start({
+            assistantMessageId: resetAssistant.id,
             history,
             ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
             conversationId,