@constructor-io/constructorio-ui-asa 1.7.1 → 1.8.0

package/lib/cjs/hooks/useAsaResults.js

@@ -3,189 +3,116 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const react_1 = require("react");
 const useCioAsaContext_1 = require("./useCioAsaContext");
-const asaStreamHandlers_1 = require("./asaStreamHandlers");
 const useAsaTracking_1 = tslib_1.__importDefault(require("./useAsaTracking"));
+const useChatPersistence_1 = tslib_1.__importDefault(require("./persistence/useChatPersistence"));
+const agentStream_1 = require("./agentStream");
+const chatSession_1 = require("../utils/chatSession");
+const productNormalizer_1 = require("../utils/productNormalizer");
+const useLatest_1 = tslib_1.__importDefault(require("./useLatest"));
 function useAsaResults(options) {
-    var _a, _b;
-    const [messages, setMessages] = (0, react_1.useState)([]);
-    const [isStreaming, setIsStreaming] = (0, react_1.useState)(false);
-    const isStreamingRef = (0, react_1.useRef)(false);
-    const killSwitchRef = (0, react_1.useRef)(false);
-    const readerRef = (0, react_1.useRef)(null);
-    const threadIdRef = (0, react_1.useRef)((_a = options === null || options === void 0 ? void 0 : options.initialThreadId) !== null && _a !== void 0 ? _a : null);
-    const idCounterRef = (0, react_1.useRef)(0);
-    // The assistant message the in-flight stream is writing into, so `abort` can
-    // settle it without having to guess which message that is.
-    const activeAssistantIdRef = (0, react_1.useRef)(null);
+    var _a;
     const contextValue = (0, useCioAsaContext_1.useCioAsaContext)();
     if (!contextValue) {
         throw new Error('useAsaResults must be used within a CioAsaProvider.');
     }
-    const { cioClient, staticRequestConfigs, callbacks, section } = contextValue;
+    const { cioClient, staticRequestConfigs, callbacks, section, persistence, persistenceScope, persistenceIndex, } = contextValue;
     const { domain } = staticRequestConfigs || {};
     if (!cioClient || !domain) {
         throw new Error('useAsaResults requires a configured cioClient and domain. Check your CioAsaProvider props.');
     }
+    const [messages, setMessages] = (0, react_1.useState)([]);
+    const [isStreaming, setIsStreaming] = (0, react_1.useState)(false);
+    const normalizeItemRef = (0, useLatest_1.default)(options === null || options === void 0 ? void 0 : options.normalizeItem);
+    const sessionRef = (0, react_1.useRef)(null);
+    if (!sessionRef.current) {
+        sessionRef.current = (0, chatSession_1.createChatSession)(options === null || options === void 0 ? void 0 : options.initialThreadId, (item) => { var _a; return ((_a = normalizeItemRef.current) !== null && _a !== void 0 ? _a : productNormalizer_1.normalizeItemToProduct)(item); });
+    }
+    const session = sessionRef.current;
+    const turnRef = (0, react_1.useRef)(null);
     const tracking = (0, useAsaTracking_1.default)({
         tracker: cioClient.tracker,
         section,
-        threadId: (_b = threadIdRef.current) !== null && _b !== void 0 ? _b : undefined,
+        threadId: (_a = session.serverThreadId) !== null && _a !== void 0 ? _a : undefined,
     });
-    const trackingRef = (0, react_1.useRef)(tracking);
-    trackingRef.current = tracking;
-    const callbacksRef = (0, react_1.useRef)(callbacks);
-    callbacksRef.current = callbacks;
-    const staticRequestConfigsRef = (0, react_1.useRef)(staticRequestConfigs);
-    staticRequestConfigsRef.current = staticRequestConfigs;
-    /**
-     * Stops the in-flight stream. The kill switch is raised *before* cancelling because
-     * cancelling makes the pending `reader.read()` resolve `{ done: true }` — identical
-     * to a stream that ended on its own. Without the flag already set, the read loop
-     * would take the end-of-stream branch and report a load that never finished.
-     *
-     * Deliberately touches no state, so the unmount cleanup can share it.
-     */
-    const teardownStream = (0, react_1.useCallback)(() => {
-        killSwitchRef.current = true;
-        if (readerRef.current) {
-            readerRef.current.cancel();
-            readerRef.current = null;
-        }
-    }, []);
-    const nextMessageId = (0, react_1.useCallback)(() => {
-        idCounterRef.current += 1;
-        return `msg-${idCounterRef.current}-${Date.now()}`;
+    const trackingRef = (0, useLatest_1.default)(tracking);
+    const callbacksRef = (0, useLatest_1.default)(callbacks);
+    const staticRequestConfigsRef = (0, useLatest_1.default)(staticRequestConfigs);
+    /** Stops this tab's stream, if any. `readAgentStream` settles its `done` without touching state. */
+    const cancelStream = (0, react_1.useCallback)(() => {
+        var _a;
+        (_a = turnRef.current) === null || _a === void 0 ? void 0 : _a.cancel();
+        turnRef.current = null;
     }, []);
+    const store = (0, useChatPersistence_1.default)({
+        store: persistence,
+        scope: persistenceScope,
+        index: persistenceIndex,
+        session,
+        initialThreadId: options === null || options === void 0 ? void 0 : options.initialThreadId,
+        messages,
+        setMessages,
+        isStreaming,
+        setIsStreaming,
+        turnRef,
+        cancelStream,
+    });
+    const { beginTurn, screenOwner } = store;
+    (0, react_1.useEffect)(() => cancelStream, [cancelStream]);
     const sendMessage = (0, react_1.useCallback)((text, source = 'input') => {
         var _a, _b;
         const intent = text.trim();
-        if (!intent || isStreamingRef.current)
+        if (!intent || session.isStreaming || session.foreignInFlight)
             return;
+        beginTurn();
         trackingRef.current.trackSubmit(intent);
         (_b = (_a = callbacksRef.current) === null || _a === void 0 ? void 0 : _a.onAssistantSubmit) === null || _b === void 0 ? void 0 : _b.call(_a, { intent, source });
         const userMessage = {
-            id: nextMessageId(),
+            id: (0, chatSession_1.nextMessageId)(session),
             role: 'user',
             text: intent,
             status: 'done',
         };
         const assistantMessage = {
-            id: nextMessageId(),
+            id: (0, chatSession_1.nextMessageId)(session),
             role: 'assistant',
             text: '',
             groups: [],
             status: 'loading',
             intent,
         };
-        activeAssistantIdRef.current = assistantMessage.id;
         setMessages((prev) => [...prev, userMessage, assistantMessage]);
         setIsStreaming(true);
-        isStreamingRef.current = true;
-        killSwitchRef.current = false;
-        // `intent` is passed as the first argument and `threadId` is managed per-stream
-        // below, so both are stripped here. Everything else configured on the provider
-        // (filters, guard, numResultsPerEvent, numResultEvents, qsParam,
-        // preFilterExpression, fmtOptions, ...) is forwarded to the agent as-is.
+        session.isStreaming = true;
         const agentParams = Object.assign({}, staticRequestConfigsRef.current);
         delete agentParams.intent;
         delete agentParams.threadId;
-        const stream = cioClient.agent.getAgentResultsStream(intent, Object.assign(Object.assign(Object.assign({}, agentParams), { domain }), (threadIdRef.current && { threadId: threadIdRef.current })));
-        const reader = stream.getReader();
-        readerRef.current = reader;
-        // Mutable per-stream state kept on an object so the closures below don't capture
-        // reassigned loop-locals (which eslint's no-loop-func forbids).
-        const streamState = {
-            pendingGroup: null,
-            intentResultId: undefined,
-            loadStartFired: false,
-            groupCount: 0,
-        };
-        const patchAssistant = (patch) => {
-            setMessages((prev) => prev.map((m) => (m.id === assistantMessage.id ? Object.assign(Object.assign({}, m), patch) : m)));
-        };
-        const fireLoadStart = () => {
-            var _a, _b;
-            if (streamState.loadStartFired)
-                return;
-            streamState.loadStartFired = true;
-            const args = { intent, intentResultId: streamState.intentResultId };
-            trackingRef.current.trackResultLoadStarted(args);
-            (_b = (_a = callbacksRef.current) === null || _a === void 0 ? void 0 : _a.onResultLoadStart) === null || _b === void 0 ? void 0 : _b.call(_a, args);
-        };
-        (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _c, _d, _e, _f, _g, _h;
-            try {
-                // eslint-disable-next-line no-await-in-loop
-                while (!killSwitchRef.current) {
-                    // eslint-disable-next-line no-await-in-loop
-                    const res = yield reader.read();
-                    if (killSwitchRef.current)
-                        break;
-                    if (res.done) {
-                        (0, asaStreamHandlers_1.handleStreamEnd)(assistantMessage.id, setMessages);
-                        const finishArgs = {
-                            intent,
-                            searchResultCount: streamState.groupCount,
-                            intentResultId: streamState.intentResultId,
-                        };
-                        trackingRef.current.trackResultLoadFinished(finishArgs);
-                        (_d = (_c = callbacksRef.current) === null || _c === void 0 ? void 0 : _c.onResultLoadFinish) === null || _d === void 0 ? void 0 : _d.call(_c, finishArgs);
-                        break;
-                    }
-                    const { type, data } = res.value;
-                    // `intent_result_id` is shared across the stream; capture it from the first
-                    // event that carries it so load-start/finish can attribute correctly.
-                    if (!streamState.intentResultId && (data === null || data === void 0 ? void 0 : data.intent_result_id)) {
-                        streamState.intentResultId = data.intent_result_id;
-                        patchAssistant({ intentResultId: streamState.intentResultId });
-                    }
-                    if (type === 'start') {
-                        if (data === null || data === void 0 ? void 0 : data.thread_id) {
-                            threadIdRef.current = data.thread_id;
-                            patchAssistant({ threadId: data.thread_id });
-                        }
-                        fireLoadStart();
-                    }
-                    else if (type === 'group') {
-                        streamState.pendingGroup = {
-                            display_name: (_f = (_e = data === null || data === void 0 ? void 0 : data.display_name) !== null && _e !== void 0 ? _e : data === null || data === void 0 ? void 0 : data.group) !== null && _f !== void 0 ? _f : '',
-                            value: (_h = (_g = data === null || data === void 0 ? void 0 : data.value) !== null && _g !== void 0 ? _g : data === null || data === void 0 ? void 0 : data.group) !== null && _h !== void 0 ? _h : '',
-                        };
-                    }
-                    else if (type === 'search_result') {
-                        fireLoadStart();
-                        streamState.groupCount += 1;
-                        streamState.pendingGroup = (0, asaStreamHandlers_1.handleSearchResult)(data, streamState.pendingGroup, assistantMessage.id, setMessages);
-                    }
-                    else if (type === 'message') {
-                        fireLoadStart();
-                        (0, asaStreamHandlers_1.handleMessage)(data, assistantMessage.id, setMessages);
-                    }
-                    else if (type === 'follow_up_refinement') {
-                        fireLoadStart();
-                        (0, asaStreamHandlers_1.handleFollowUpRefinement)(data, assistantMessage.id, setMessages);
-                    }
-                    else if (type === 'server_error') {
-                        (0, asaStreamHandlers_1.handleServerError)(assistantMessage.id, setMessages);
-                        break;
-                    }
-                }
-            }
-            catch (_j) {
-                (0, asaStreamHandlers_1.handleStreamError)(assistantMessage.id, setMessages);
-            }
-            finally {
-                if (readerRef.current === reader) {
-                    reader.cancel();
-                    readerRef.current = null;
-                    activeAssistantIdRef.current = null;
-                    setIsStreaming(false);
-                    isStreamingRef.current = false;
-                }
-            }
-        }))();
-    }, [cioClient, domain, nextMessageId]);
-    (0, react_1.useEffect)(() => () => teardownStream(), [teardownStream]);
+        const stream = cioClient.agent.getAgentResultsStream(intent, Object.assign(Object.assign(Object.assign({}, agentParams), { domain }), (session.serverThreadId && { threadId: session.serverThreadId })));
+        turnRef.current = (0, agentStream_1.startTurn)(stream, assistantMessage, screenOwner, {
+            onLoadStart: (intentResultId) => {
+                var _a, _b;
+                const args = { intent, intentResultId };
+                trackingRef.current.trackResultLoadStarted(args);
+                (_b = (_a = callbacksRef.current) === null || _a === void 0 ? void 0 : _a.onResultLoadStart) === null || _b === void 0 ? void 0 : _b.call(_a, args);
+            },
+            onFinish: (_a) => {
+                var _b, _c;
+                var { threadId } = _a, result = tslib_1.__rest(_a, ["threadId"]);
+                const args = Object.assign({ intent }, result);
+                // The turn may have finished in the background, after the chat moved to another thread.
+                trackingRef.current.trackResultLoadFinished(Object.assign(Object.assign({}, args), { threadId }));
+                (_c = (_b = callbacksRef.current) === null || _b === void 0 ? void 0 : _b.onResultLoadFinish) === null || _c === void 0 ? void 0 : _c.call(_b, args);
+            },
+        });
+    }, [
+        cioClient,
+        domain,
+        session,
+        beginTurn,
+        screenOwner,
+        trackingRef,
+        callbacksRef,
+        staticRequestConfigsRef,
+    ]);
     /**
      * Cancels the in-flight request while keeping the conversation: the partial reply is
      * settled as `done` (so the typing indicator stops and streamed text survives) and the
@@ -202,13 +129,13 @@ function useAsaResults(options) {
      * `assistant_result_load_started` with no matching finished event.
      */
     const abort = (0, react_1.useCallback)(() => {
-        if (!isStreamingRef.current)
+        var _a;
+        if (!session.isStreaming)
             return;
-        teardownStream();
+        const abortedId = (_a = turnRef.current) === null || _a === void 0 ? void 0 : _a.assistantId;
+        cancelStream();
+        session.isStreaming = false;
         setIsStreaming(false);
-        isStreamingRef.current = false;
-        const abortedId = activeAssistantIdRef.current;
-        activeAssistantIdRef.current = null;
         if (abortedId) {
             setMessages((prev) => prev.flatMap((msg) => {
                 var _a;
@@ -219,15 +146,21 @@ function useAsaResults(options) {
                 return [Object.assign(Object.assign({}, msg), { status: 'done' })];
             }));
         }
-    }, [teardownStream]);
-    const clearHistory = (0, react_1.useCallback)(() => {
-        teardownStream();
-        threadIdRef.current = null;
-        activeAssistantIdRef.current = null;
-        setMessages([]);
-        setIsStreaming(false);
-        isStreamingRef.current = false;
-    }, [teardownStream]);
-    return { messages, sendMessage, isStreaming, abort, clearHistory };
+        // With persistence on, the cancelled turn is stored as it stands.
+        session.dirty = true;
+    }, [session, cancelStream]);
+    return {
+        messages,
+        sendMessage,
+        isStreaming: isStreaming || store.foreignInFlight,
+        canAbort: isStreaming,
+        abort,
+        clearHistory: store.clearHistory,
+        isHydrating: store.isHydrating,
+        threads: store.threads,
+        activeThreadId: store.activeThreadId,
+        newThread: store.newThread,
+        switchThread: store.switchThread,
+    };
 }
 exports.default = useAsaResults;

package/lib/cjs/hooks/useAsaTracking.js

@@ -23,9 +23,9 @@ function useAsaTracking({ tracker, section, threadId, }) {
     const trackResultLoadStarted = (0, react_1.useCallback)(({ intent, intentResultId }) => {
         assistant === null || assistant === void 0 ? void 0 : assistant.trackAssistantResultLoadStarted(Object.assign(Object.assign({ intent }, (intentResultId && { intentResultId })), base));
     }, [assistant, base]);
-    const trackResultLoadFinished = (0, react_1.useCallback)(({ intent, searchResultCount, intentResultId }) => {
-        assistant === null || assistant === void 0 ? void 0 : assistant.trackAssistantResultLoadFinished(Object.assign(Object.assign({ intent,
-            searchResultCount }, (intentResultId && { intentResultId })), base));
+    const trackResultLoadFinished = (0, react_1.useCallback)(({ intent, searchResultCount, intentResultId, threadId: turnThreadId, }) => {
+        assistant === null || assistant === void 0 ? void 0 : assistant.trackAssistantResultLoadFinished(Object.assign(Object.assign(Object.assign({ intent,
+            searchResultCount }, (intentResultId && { intentResultId })), base), (turnThreadId && { threadId: turnThreadId })));
     }, [assistant, base]);
     const trackResultClick = (0, react_1.useCallback)(({ intent, searchResultId, intentResultId, itemId, itemName, variationId, }) => {
         assistant === null || assistant === void 0 ? void 0 : assistant.trackAssistantResultClick(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ intent,

package/lib/cjs/hooks/useIsMounted.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/** A ref that is `true` while mounted, for async work that must not land after unmount. */
+function useIsMounted() {
+    const ref = (0, react_1.useRef)(true);
+    (0, react_1.useEffect)(() => {
+        ref.current = true;
+        return () => {
+            ref.current = false;
+        };
+    }, []);
+    return ref;
+}
+exports.default = useIsMounted;

package/lib/cjs/hooks/useLatest.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/** A ref that always holds the latest `value`, for async code that must not read stale props. */
+function useLatest(value) {
+    const ref = (0, react_1.useRef)(value);
+    ref.current = value;
+    return ref;
+}
+exports.default = useLatest;

package/lib/cjs/hooks/useViewportTracking.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const react_1 = require("react");
+const useLatest_1 = tslib_1.__importDefault(require("./useLatest"));
 /**
  * Fires `onView` once when the observed element scrolls into the viewport, modeling a
  * per-pod `assistant_search_result_view` impression. Unlike the PIA widget-level view
  * tracker, this fires a single impression per pod (not repeated enter/exit cycles).
  */
 function useViewportTracking({ onView, enabled = true, }) {
-    const onViewRef = (0, react_1.useRef)(onView);
-    onViewRef.current = onView;
+    const onViewRef = (0, useLatest_1.default)(onView);
     const firedRef = (0, react_1.useRef)(false);
     const cleanupRef = (0, react_1.useRef)(null);
     const ref = (0, react_1.useCallback)((node) => {
@@ -29,7 +30,7 @@ function useViewportTracking({ onView, enabled = true, }) {
         }, { threshold: 0.5 });
         observer.observe(node);
         cleanupRef.current = () => observer.disconnect();
-    }, [enabled]);
+    }, [enabled, onViewRef]);
     (0, react_1.useEffect)(() => () => {
         if (cleanupRef.current)
             cleanupRef.current();

package/lib/cjs/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstructorIOClient = exports.normalizeItemToProduct = exports.useCioAsaContext = exports.useAsaTracking = exports.useAsaResults = exports.Button = exports.ResultsBlock = exports.Chat = exports.CioAsaProvider = exports.CioAsa = void 0;
+exports.ConstructorIOClient = exports.clearPersistedConversations = exports.normalizeItemToProduct = exports.useCioAsaContext = exports.useAsaTracking = exports.useAsaResults = exports.Button = exports.ResultsBlock = exports.Chat = exports.CioAsaProvider = exports.CioAsa = void 0;
 // Components
 var CioAsa_1 = require("./components/CioAsa/CioAsa");
 Object.defineProperty(exports, "CioAsa", { enumerable: true, get: function () { return __importDefault(CioAsa_1).default; } });
@@ -25,6 +25,8 @@ Object.defineProperty(exports, "useCioAsaContext", { enumerable: true, get: func
 // Utils
 var productNormalizer_1 = require("./utils/productNormalizer");
 Object.defineProperty(exports, "normalizeItemToProduct", { enumerable: true, get: function () { return productNormalizer_1.normalizeItemToProduct; } });
+var localStoragePersistence_1 = require("./utils/localStoragePersistence");
+Object.defineProperty(exports, "clearPersistedConversations", { enumerable: true, get: function () { return localStoragePersistence_1.clearPersistedConversations; } });
 // Re-exported client value from the JS client (used to construct/type a cioClient)
 var types_1 = require("./types");
 Object.defineProperty(exports, "ConstructorIOClient", { enumerable: true, get: function () { return types_1.ConstructorIOClient; } });

package/lib/cjs/utils/chatRecordValidation.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chatThreads_1 = require("./chatThreads");
+const MESSAGE_ROLES = new Set(['user', 'assistant']);
+const MESSAGE_STATUSES = new Set(['idle', 'loading', 'streaming', 'done', 'error']);
+function isProduct(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const p = value;
+    return typeof p.id === 'string' && typeof p.name === 'string';
+}
+function isResultGroup(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const g = value;
+    return (Boolean(g.group) &&
+        typeof g.group === 'object' &&
+        typeof g.group.display_name === 'string' &&
+        Array.isArray(g.searchResults) &&
+        g.searchResults.every((r) => Boolean(r) && typeof r === 'object') &&
+        (g.products === undefined || (Array.isArray(g.products) && g.products.every(isProduct))));
+}
+function isRefinement(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const r = value;
+    return (typeof r.question === 'string' &&
+        Array.isArray(r.options) &&
+        r.options.every((o) => typeof o === 'string'));
+}
+function isChatMessage(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const m = value;
+    return (typeof m.id === 'string' &&
+        MESSAGE_ROLES.has(m.role) &&
+        typeof m.text === 'string' &&
+        MESSAGE_STATUSES.has(m.status) &&
+        (m.groups === undefined || (Array.isArray(m.groups) && m.groups.every(isResultGroup))) &&
+        (m.refinement === undefined || isRefinement(m.refinement)));
+}
+function isPersistedChat(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const chat = value;
+    return (chat.version === chatThreads_1.PERSISTED_CHAT_VERSION &&
+        typeof chat.threadId === 'string' &&
+        Array.isArray(chat.messages) &&
+        chat.messages.every(isChatMessage) &&
+        typeof chat.createdAt === 'number' &&
+        typeof chat.updatedAt === 'number' &&
+        (chat.owner === undefined || typeof chat.owner === 'string'));
+}
+exports.default = isPersistedChat;

package/lib/cjs/utils/chatSession.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareSnapshot = exports.adoptSession = exports.forkSession = exports.adoptStoredChat = exports.isOwnMessage = exports.nextMessageId = exports.resetConversation = exports.createChatSession = void 0;
+const chatThreads_1 = require("./chatThreads");
+const productNormalizer_1 = require("./productNormalizer");
+function createChatSession(initialThreadId, normalizeItem = productNormalizer_1.normalizeItemToProduct) {
+    return {
+        normalizeItem,
+        serverThreadId: initialThreadId && !(0, chatThreads_1.isLocalThreadId)(initialThreadId) ? initialThreadId : null,
+        storageThreadId: null,
+        orphanIds: [],
+        createdAt: null,
+        lastSyncedAt: 0,
+        dirty: false,
+        interacted: false,
+        loadRequest: 0,
+        isStreaming: false,
+        foreignInFlight: false,
+        idCounter: 0,
+        idSuffix: (0, chatThreads_1.randomId)().slice(0, 6),
+    };
+}
+exports.createChatSession = createChatSession;
+/** Forget the current conversation. Returns the id it was stored under, if any. */
+function resetConversation(session) {
+    const storedId = session.storageThreadId;
+    session.serverThreadId = null;
+    session.storageThreadId = null;
+    session.orphanIds = [];
+    session.createdAt = null;
+    session.lastSyncedAt = 0;
+    session.dirty = false;
+    session.loadRequest += 1;
+    session.isStreaming = false;
+    session.foreignInFlight = false;
+    return storedId;
+}
+exports.resetConversation = resetConversation;
+function nextMessageId(session) {
+    session.idCounter += 1;
+    return `msg-${session.idCounter}-${Date.now()}-${session.idSuffix}`;
+}
+exports.nextMessageId = nextMessageId;
+/** Whether `messageId` was minted by this session rather than by another tab. */
+function isOwnMessage(session, messageId) {
+    return messageId.endsWith(`-${session.idSuffix}`);
+}
+exports.isOwnMessage = isOwnMessage;
+/** Makes a stored conversation the one this session continues. */
+function adoptStoredChat(session, chat) {
+    session.storageThreadId = chat.threadId;
+    session.createdAt = chat.createdAt;
+    session.serverThreadId = (0, chatThreads_1.isLocalThreadId)(chat.threadId) ? null : chat.threadId;
+    session.idCounter = (0, chatThreads_1.nextMessageCounter)(chat.messages);
+    session.lastSyncedAt = chat.updatedAt;
+}
+exports.adoptStoredChat = adoptStoredChat;
+/** A copy that keeps the conversation `session` holds while `session` itself moves on. */
+function forkSession(session) {
+    return Object.assign(Object.assign({}, session), { orphanIds: [...session.orphanIds] });
+}
+exports.forkSession = forkSession;
+/** Makes `session` continue the conversation `from` kept, showing `messages`. */
+function adoptSession(session, from, messages) {
+    session.serverThreadId = from.serverThreadId;
+    session.storageThreadId = from.storageThreadId;
+    session.orphanIds = [...from.orphanIds];
+    session.createdAt = from.createdAt;
+    session.lastSyncedAt = from.lastSyncedAt;
+    session.idCounter = (0, chatThreads_1.nextMessageCounter)(messages);
+}
+exports.adoptSession = adoptSession;
+/** Builds the record to write and moves the session onto its key; `staleIds` are the records to retire once stored. */
+function prepareSnapshot(session, messages, now = Date.now()) {
+    var _a, _b, _c;
+    const previousId = session.storageThreadId;
+    const threadId = (_b = (_a = session.serverThreadId) !== null && _a !== void 0 ? _a : previousId) !== null && _b !== void 0 ? _b : (0, chatThreads_1.createLocalThreadId)();
+    const staleIds = [previousId !== threadId ? previousId : null, ...session.orphanIds].filter((id) => id !== null && id !== threadId);
+    // Strictly increasing so other tabs read a same-millisecond save as newer.
+    const updatedAt = Math.max(now, session.lastSyncedAt + 1);
+    const createdAt = (_c = session.createdAt) !== null && _c !== void 0 ? _c : updatedAt;
+    session.storageThreadId = threadId;
+    session.orphanIds = [];
+    session.createdAt = createdAt;
+    session.lastSyncedAt = updatedAt;
+    return {
+        staleIds: Array.from(new Set(staleIds)),
+        snapshot: {
+            version: chatThreads_1.PERSISTED_CHAT_VERSION,
+            threadId,
+            messages: (0, chatThreads_1.compactMessages)(messages, session.normalizeItem),
+            createdAt,
+            updatedAt,
+            owner: (0, chatThreads_1.getTabId)(),
+        },
+    };
+}
+exports.prepareSnapshot = prepareSnapshot;