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

package/lib/cjs/utils/chatThreads.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moveThreads = exports.foreignStreamRemainingMs = exports.isThreadStreaming = exports.findRekeyedThread = exports.saveThreadAndRetireStale = exports.mergeMessages = exports.compactMessages = exports.normalizeHydratedMessages = exports.isInFlight = exports.nextMessageCounter = exports.getThreadTitle = exports.isLocalThreadId = exports.getTabId = exports.createLocalThreadId = exports.randomId = exports.IN_FLIGHT_GRACE_MS = exports.DEFAULT_PERSISTENCE_TTL_MS = exports.DEFAULT_PERSISTENCE_KEY = exports.PERSISTED_CHAT_VERSION = void 0;
+const tslib_1 = require("tslib");
+/** Stored record format; records with another version are ignored on read. */
+exports.PERSISTED_CHAT_VERSION = 1;
+/** Prefix of the `localStorage` key; the api key, domain and user id are appended to it. */
+exports.DEFAULT_PERSISTENCE_KEY = 'cio-asa:chat';
+/** One week, matching how long the agent itself remembers a thread. */
+exports.DEFAULT_PERSISTENCE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/** How long a stored answer written by another tab is still shown as "typing" before it is settled. */
+exports.IN_FLIGHT_GRACE_MS = 60 * 1000;
+/** Marks client-side thread ids, used before the server has assigned one. Never sent to the agent. */
+const LOCAL_THREAD_PREFIX = 'local-';
+/** Thread titles are the first question, cut to this many characters. */
+const TITLE_MAX_LENGTH = 80;
+let fallbackCounter = 0;
+/** Random token for the ids that must not collide between tabs: threads, tabs and messages. */
+function randomId() {
+    if (typeof crypto !== 'undefined') {
+        if (typeof crypto.randomUUID === 'function')
+            return crypto.randomUUID();
+        if (typeof crypto.getRandomValues === 'function') {
+            const bytes = crypto.getRandomValues(new Uint8Array(16));
+            return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+        }
+    }
+    fallbackCounter += 1;
+    return `${Date.now().toString(36)}-${fallbackCounter.toString(36)}`;
+}
+exports.randomId = randomId;
+/** Client-side thread id for a conversation the server has not named yet. */
+function createLocalThreadId() {
+    return `${LOCAL_THREAD_PREFIX}${randomId()}`;
+}
+exports.createLocalThreadId = createLocalThreadId;
+const TAB_ID_KEY = 'cio-asa:tab';
+let tabId;
+/** Whether this page load is a reload, as opposed to a new, duplicated or restored tab. */
+function isReload() {
+    try {
+        const [entry] = performance.getEntriesByType('navigation');
+        return (entry === null || entry === void 0 ? void 0 : entry.type) === 'reload';
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Per-tab id: survives a reload, differs between tabs, `undefined` on the server. A duplicated tab
+ * copies `sessionStorage`, so the id is read back on a reload only, and is kept there only while
+ * the page is hidden.
+ */
+function getTabId() {
+    if (tabId)
+        return tabId;
+    if (typeof window === 'undefined')
+        return undefined;
+    const id = randomId();
+    tabId = id;
+    try {
+        const { sessionStorage } = window;
+        tabId = (isReload() && sessionStorage.getItem(TAB_ID_KEY)) || id;
+        sessionStorage.removeItem(TAB_ID_KEY);
+        const claimed = tabId;
+        window.addEventListener('pagehide', () => {
+            try {
+                sessionStorage.setItem(TAB_ID_KEY, claimed);
+            }
+            catch (_a) {
+                /* ignore */
+            }
+        });
+        window.addEventListener('pageshow', (event) => {
+            if (!event.persisted)
+                return;
+            try {
+                sessionStorage.removeItem(TAB_ID_KEY);
+            }
+            catch (_a) {
+                /* ignore */
+            }
+        });
+    }
+    catch (_a) {
+        /* sessionStorage blocked: the id lasts for this page only */
+    }
+    return tabId;
+}
+exports.getTabId = getTabId;
+/** Whether `threadId` was made by `createLocalThreadId` rather than by the server. */
+function isLocalThreadId(threadId) {
+    return typeof threadId === 'string' && threadId.startsWith(LOCAL_THREAD_PREFIX);
+}
+exports.isLocalThreadId = isLocalThreadId;
+/** Title for a thread list: the first user message, truncated with an ellipsis. */
+function getThreadTitle(messages) {
+    var _a, _b;
+    const first = (_b = (_a = messages.find((m) => m.role === 'user')) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : '';
+    return first.length > TITLE_MAX_LENGTH ? `${first.slice(0, TITLE_MAX_LENGTH - 1)}…` : first;
+}
+exports.getThreadTitle = getThreadTitle;
+/** Counter to continue message ids from after a restore, so new ids never collide with restored ones. */
+function nextMessageCounter(messages) {
+    return messages.reduce((max, m) => {
+        const match = /^msg-(\d+)-/.exec(m.id);
+        return match ? Math.max(max, Number(match[1])) : max;
+    }, messages.length);
+}
+exports.nextMessageCounter = nextMessageCounter;
+/** Whether the latest answer in `messages` has not finished streaming. */
+function isInFlight(messages) {
+    const last = messages[messages.length - 1];
+    return (last === null || last === void 0 ? void 0 : last.status) === 'loading' || (last === null || last === void 0 ? void 0 : last.status) === 'streaming';
+}
+exports.isInFlight = isInFlight;
+/** Settles answers stored mid-stream: `done` when they have content, an interrupted `error` otherwise. */
+function normalizeHydratedMessages(messages) {
+    return messages.map((m) => {
+        var _a;
+        if (m.status !== 'loading' && m.status !== 'streaming')
+            return m;
+        const hasContent = Boolean(m.text) || Boolean((_a = m.groups) === null || _a === void 0 ? void 0 : _a.length) || Boolean(m.refinement);
+        return hasContent ? Object.assign(Object.assign({}, m), { status: 'done' }) : Object.assign(Object.assign({}, m), { status: 'error', interrupted: true });
+    });
+}
+exports.normalizeHydratedMessages = normalizeHydratedMessages;
+/** Messages as stored: raw items replaced by the cards `normalize` makes; a restored group keeps its cards. */
+function compactMessages(messages, normalize) {
+    return messages.map((m) => {
+        var _a;
+        return ((_a = m.groups) === null || _a === void 0 ? void 0 : _a.length)
+            ? Object.assign(Object.assign({}, m), { groups: m.groups.map((g) => {
+                    var _a;
+                    return (Object.assign(Object.assign({}, g), { searchResults: [], products: (_a = g.products) !== null && _a !== void 0 ? _a : g.searchResults.map(normalize) }));
+                }) }) : m;
+    });
+}
+exports.compactMessages = compactMessages;
+const isUnsettled = (m) => m.status === 'loading' || m.status === 'streaming';
+/**
+ * Both lists in stored order; a shared message takes the incoming version unless `preferStored`.
+ * A settled incoming version still replaces a stored one mid-stream: it is the later one by definition.
+ */
+function mergeMessages(stored, incoming, preferStored = false) {
+    const incomingById = new Map(incoming.map((m) => [m.id, m]));
+    const storedIds = new Set(stored.map((m) => m.id));
+    return [
+        ...stored.map((m) => {
+            const update = incomingById.get(m.id);
+            if (!update)
+                return m;
+            if (!preferStored)
+                return update;
+            return isUnsettled(m) && !isUnsettled(update) ? update : m;
+        }),
+        ...incoming.filter((m) => !storedIds.has(m.id)),
+    ];
+}
+exports.mergeMessages = mergeMessages;
+/**
+ * Saves `snapshot`, then deletes `staleIds` once the new record is read back. Stores may fail
+ * without throwing, so both steps are checked by reading: `saved` is whether the snapshot landed,
+ * `leftover` the stale ids still stored.
+ */
+function saveThreadAndRetireStale(store, snapshot, staleIds) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            yield store.saveThread(snapshot);
+        }
+        catch (_a) {
+            return { saved: false, leftover: staleIds };
+        }
+        const persisted = yield store.getThread(snapshot.threadId).catch(() => null);
+        if (!persisted || persisted.updatedAt < snapshot.updatedAt) {
+            return { saved: false, leftover: staleIds };
+        }
+        const retired = yield Promise.all(staleIds.map((id) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield store.deleteThread(id).catch(() => { });
+            return (yield store.getThread(id).catch(() => null)) === null;
+        })));
+        return { saved: true, leftover: staleIds.filter((_, i) => !retired[i]) };
+    });
+}
+exports.saveThreadAndRetireStale = saveThreadAndRetireStale;
+/** Finds the server-keyed record another tab re-keyed a local thread into, by its first message. */
+function findRekeyedThread(store, firstMessageId) {
+    var _a;
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (!firstMessageId)
+            return null;
+        const list = yield store.listThreads();
+        const candidates = list.filter((t) => !isLocalThreadId(t.threadId));
+        const loaded = yield Promise.all(candidates.map((t) => store.getThread(t.threadId)));
+        return (_a = loaded.find((c) => { var _a; return ((_a = c === null || c === void 0 ? void 0 : c.messages[0]) === null || _a === void 0 ? void 0 : _a.id) === firstMessageId; })) !== null && _a !== void 0 ? _a : null;
+    });
+}
+exports.findRekeyedThread = findRekeyedThread;
+/** Whether a stored thread still reads as streaming: this tab's own always, another tab's only within the grace. */
+function isThreadStreaming(chat, now = Date.now()) {
+    if (!isInFlight(chat.messages))
+        return false;
+    if (chat.owner !== undefined && chat.owner === getTabId())
+        return true;
+    return now - chat.updatedAt < exports.IN_FLIGHT_GRACE_MS;
+}
+exports.isThreadStreaming = isThreadStreaming;
+/** Ms left to show a stored answer as streaming in another tab; `0` when it should be settled. */
+function foreignStreamRemainingMs(chat, now = Date.now()) {
+    if (!isInFlight(chat.messages))
+        return 0;
+    if (chat.owner !== undefined && chat.owner === getTabId())
+        return 0;
+    return Math.max(0, exports.IN_FLIGHT_GRACE_MS - (now - chat.updatedAt));
+}
+exports.foreignStreamRemainingMs = foreignStreamRemainingMs;
+/**
+ * Moves every thread of `from` into `to`; copies of the chat on screen are not copied, its owner
+ * saves it. A source record is deleted only once `to` holds it after every copy was made, so one
+ * copy evicting another, or a save that did not land, leaves the source in place.
+ */
+function moveThreads(from, to, onScreen = {}) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const { threadIds = [], firstMessageId } = onScreen;
+        const summaries = yield from.listThreads();
+        const chats = (yield Promise.all(summaries.map((t) => from.getThread(t.threadId)))).filter((chat) => chat !== null);
+        const isShown = (chat) => {
+            var _a;
+            return threadIds.includes(chat.threadId) ||
+                (firstMessageId !== undefined && ((_a = chat.messages[0]) === null || _a === void 0 ? void 0 : _a.id) === firstMessageId);
+        };
+        const toCopy = chats.filter((chat) => !isShown(chat));
+        yield Promise.all(toCopy.map((chat) => to.saveThread(chat)));
+        const targetList = yield to.listThreads();
+        const target = new Map((yield Promise.all(targetList.map((t) => to.getThread(t.threadId))))
+            .filter((chat) => chat !== null)
+            .map((chat) => [chat.threadId, chat]));
+        const shownSaved = Array.from(target.values()).some(isShown);
+        const moved = chats.filter((chat) => {
+            if (isShown(chat))
+                return shownSaved;
+            const copy = target.get(chat.threadId);
+            return copy !== undefined && copy.updatedAt >= chat.updatedAt;
+        });
+        yield Promise.all(moved.map((chat) => from.deleteThread(chat.threadId)));
+    });
+}
+exports.moveThreads = moveThreads;

package/lib/cjs/utils/clientOptions.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readClientOptions = void 0;
+/** `options` is private in the client's typings; read it here only, so a client bump fails a test, not storage keys. */
+function readClientOptions(client) {
+    const { options } = (client !== null && client !== void 0 ? client : {});
+    if (!options || typeof options !== 'object')
+        return undefined;
+    return options;
+}
+exports.readClientOptions = readClientOptions;

package/lib/cjs/utils/localStoragePersistence.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sharedLocalStoragePersistence = exports.createLocalStoragePersistence = exports.clearPersistedConversations = exports.persistenceNamespace = exports.storageAreaFor = exports.shopperId = exports.isGuest = void 0;
+const tslib_1 = require("tslib");
+const chatThreads_1 = require("./chatThreads");
+const chatRecordValidation_1 = tslib_1.__importDefault(require("./chatRecordValidation"));
+/** Keeps the last `maxTurns` user/assistant pairs, always starting on a user message. */
+function trimToTurns(messages, maxTurns) {
+    if (maxTurns <= 0)
+        return [];
+    let trimmed = Number.isFinite(maxTurns) ? messages.slice(-maxTurns * 2) : messages;
+    while (trimmed.length && trimmed[0].role !== 'user')
+        trimmed = trimmed.slice(1);
+    return trimmed;
+}
+// Web Locks where available; elsewhere the cycle runs synchronously.
+function withStorageLock(name, fn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const locks = typeof navigator !== 'undefined' ? navigator.locks : undefined;
+        if (!(locks === null || locks === void 0 ? void 0 : locks.request)) {
+            fn();
+            return;
+        }
+        let ran = false;
+        try {
+            yield locks.request(name, () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                ran = true;
+                fn();
+            }));
+        }
+        catch (_a) {
+            if (!ran)
+                fn();
+        }
+    });
+}
+/** The storage to use, or `null` when none is available (server, or access blocked). */
+function resolveStorage(storage, area) {
+    if (storage)
+        return storage;
+    try {
+        if (typeof window === 'undefined')
+            return null;
+        return area === 'session' ? window.sessionStorage : window.localStorage;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/** No user id, or an empty one: the conversation belongs to a guest. */
+const isGuest = (userId) => userId == null || userId === '';
+exports.isGuest = isGuest;
+/** The id the client and storage use: `undefined` for a guest (no id, `null` or empty). */
+const shopperId = (userId) => (0, exports.isGuest)(userId) ? undefined : String(userId);
+exports.shopperId = shopperId;
+/** Guests live in `sessionStorage`, so their history ends with the tab; shoppers keep theirs in `localStorage`. */
+function storageAreaFor(userId) {
+    return (0, exports.isGuest)(userId) ? 'session' : 'local';
+}
+exports.storageAreaFor = storageAreaFor;
+/** Namespace the provider stores under: api key, domain and, for a signed-in shopper, the user id. */
+function persistenceNamespace(parts) {
+    var _a;
+    return [parts.apiKey, (_a = parts.domain) !== null && _a !== void 0 ? _a : 'default', (0, exports.shopperId)(parts.userId)]
+        .filter((part) => part !== undefined)
+        .map(encodeURIComponent)
+        .join(':');
+}
+exports.persistenceNamespace = persistenceNamespace;
+function storageKeyFor(key, namespace) {
+    return [key, `v${chatThreads_1.PERSISTED_CHAT_VERSION}`, namespace].filter(Boolean).join(':');
+}
+const emptyStored = () => ({
+    version: chatThreads_1.PERSISTED_CHAT_VERSION,
+    threads: {},
+    deleted: {},
+});
+function parseStored(raw) {
+    var _a;
+    if (!raw)
+        return emptyStored();
+    try {
+        const parsed = JSON.parse(raw);
+        if ((parsed === null || parsed === void 0 ? void 0 : parsed.version) !== chatThreads_1.PERSISTED_CHAT_VERSION || !parsed.threads)
+            return emptyStored();
+        const threads = Object.fromEntries(Object.entries(parsed.threads).filter(([, chat]) => (0, chatRecordValidation_1.default)(chat)));
+        const deleted = Object.fromEntries(Object.entries((_a = parsed.deleted) !== null && _a !== void 0 ? _a : {}).filter(([, at]) => typeof at === 'number'));
+        return { version: chatThreads_1.PERSISTED_CHAT_VERSION, threads, deleted };
+    }
+    catch (_b) {
+        return emptyStored();
+    }
+}
+function readItem(storage, key) {
+    try {
+        return storage.getItem(key);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/**
+ * Deletes every stored conversation of one shopper, or of the guest without `userId`; open tabs
+ * follow. Resolves once the deletion is recorded.
+ */
+function clearPersistedConversations(options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const { apiKey, domain = 'chatbot', userId, storage: storageOption } = options;
+        const storage = resolveStorage(storageOption, storageAreaFor(userId));
+        if (!storage)
+            return;
+        const key = storageKeyFor(chatThreads_1.DEFAULT_PERSISTENCE_KEY, persistenceNamespace({ apiKey, domain, userId }));
+        let cleared = false;
+        // Under the store's lock, and as tombstones rather than a bare removal: a save still queued in
+        // some tab, holding a copy of a thread, must find it deleted instead of writing it back.
+        yield withStorageLock(key, () => {
+            var _a;
+            try {
+                const raw = readItem(storage, key);
+                if (raw === null) {
+                    cleared = true;
+                    return;
+                }
+                const current = parseStored(raw);
+                const now = Date.now();
+                const deleted = Object.keys(current.threads).reduce((all, threadId) => (Object.assign(Object.assign({}, all), { [threadId]: now })), (_a = current.deleted) !== null && _a !== void 0 ? _a : {});
+                if (Object.keys(deleted).length === 0)
+                    storage.removeItem(key);
+                else
+                    storage.setItem(key, JSON.stringify(Object.assign(Object.assign({}, emptyStored()), { deleted })));
+                cleared = true;
+            }
+            catch (_b) {
+                /* storage unavailable */
+            }
+        });
+        if (!cleared)
+            return;
+        // Other tabs get a native storage event; this tab does not, so dispatch one for a mounted chat.
+        if (typeof window === 'undefined' || typeof StorageEvent === 'undefined')
+            return;
+        try {
+            window.dispatchEvent(new StorageEvent('storage', { key, storageArea: storage }));
+        }
+        catch (_a) {
+            /* a non-Storage `storage` option cannot be attached to the event */
+        }
+    });
+}
+exports.clearPersistedConversations = clearPersistedConversations;
+/** Conversation store on top of `localStorage`; one key per namespace, merged across tabs. */
+function createLocalStoragePersistence(options = {}) {
+    const { key = chatThreads_1.DEFAULT_PERSISTENCE_KEY, namespace, ttlMs = chatThreads_1.DEFAULT_PERSISTENCE_TTL_MS, maxTurns = Infinity, maxThreads = Infinity, storageArea = 'local', storage: storageOption, } = options;
+    const storageKey = storageKeyFor(key, namespace);
+    const readRaw = (storage) => readItem(storage, storageKey);
+    // One sync reads the same key several times; parse and validate the blob once per distinct value.
+    let lastParsed = null;
+    const parse = (raw) => {
+        var _a;
+        if (!raw)
+            return emptyStored();
+        if ((lastParsed === null || lastParsed === void 0 ? void 0 : lastParsed.raw) !== raw)
+            lastParsed = { raw, data: parseStored(raw) };
+        const cutoff = Date.now() - ttlMs;
+        const { data } = lastParsed;
+        return {
+            version: chatThreads_1.PERSISTED_CHAT_VERSION,
+            threads: Object.fromEntries(Object.entries(data.threads).filter(([, chat]) => chat.updatedAt >= cutoff)),
+            deleted: Object.fromEntries(Object.entries((_a = data.deleted) !== null && _a !== void 0 ? _a : {}).filter(([, at]) => at >= cutoff)),
+        };
+    };
+    const read = () => {
+        const storage = resolveStorage(storageOption, storageArea);
+        return parse(storage ? readRaw(storage) : null);
+    };
+    const sortedThreads = (data) => Object.values(data.threads).sort((a, b) => b.updatedAt - a.updatedAt);
+    const tryWrite = (storage, data) => {
+        try {
+            storage.setItem(storageKey, JSON.stringify(data));
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    };
+    const remove = (storage) => {
+        try {
+            storage.removeItem(storageKey);
+        }
+        catch (_a) {
+            /* ignore */
+        }
+    };
+    const isEmpty = (data) => { var _a; return Object.keys(data.threads).length === 0 && Object.keys((_a = data.deleted) !== null && _a !== void 0 ? _a : {}).length === 0; };
+    // Retries without tombstones, oldest first: the last thing to shed, see `write`.
+    const tryWriteShedding = (storage, data) => {
+        var _a, _b;
+        if (tryWrite(storage, data))
+            return true;
+        const oldestFirst = Object.entries((_a = data.deleted) !== null && _a !== void 0 ? _a : {})
+            .sort((a, b) => a[1] - b[1])
+            .map(([id]) => id);
+        let next = data;
+        for (let i = 0; i < oldestFirst.length; i += 1) {
+            const _c = (_b = next.deleted) !== null && _b !== void 0 ? _b : {}, _d = oldestFirst[i], shed = _c[_d], deleted = tslib_1.__rest(_c, [typeof _d === "symbol" ? _d : _d + ""]);
+            next = Object.assign(Object.assign({}, next), { deleted });
+            if (tryWrite(storage, next))
+                return true;
+        }
+        return false;
+    };
+    // A tombstone is the only thing stopping another tab from writing a deleted thread back, while an
+    // evicted thread is written back by the tab holding it. So when storage is full, shed other
+    // threads oldest first, then the saved thread's oldest turns, and only then tombstones.
+    const write = (storage, data, priorityThreadId) => {
+        if (isEmpty(data)) {
+            remove(storage);
+            return;
+        }
+        if (tryWrite(storage, data))
+            return;
+        const priority = priorityThreadId ? data.threads[priorityThreadId] : undefined;
+        const oldestFirst = sortedThreads(data)
+            .filter((chat) => chat.threadId !== (priority === null || priority === void 0 ? void 0 : priority.threadId))
+            .reverse();
+        let next = data;
+        for (let i = 0; i < oldestFirst.length; i += 1) {
+            const _a = next.threads, _b = oldestFirst[i].threadId, evicted = _a[_b], threads = tslib_1.__rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+            next = Object.assign(Object.assign({}, next), { threads });
+            if (tryWrite(storage, next))
+                return;
+        }
+        if (!priority) {
+            // Not even the tombstones fit without the threads; keep the threads rather than wipe them.
+            if (Object.keys(data.threads).length === 0)
+                remove(storage);
+            else
+                tryWriteShedding(storage, data);
+            return;
+        }
+        let chat = priority;
+        while (chat.messages.length > 2) {
+            chat = Object.assign(Object.assign({}, chat), { messages: trimToTurns(chat.messages.slice(2), maxTurns) });
+            next = Object.assign(Object.assign({}, next), { threads: Object.assign(Object.assign({}, next.threads), { [chat.threadId]: chat }) });
+            if (tryWrite(storage, next))
+                return;
+        }
+        if (tryWriteShedding(storage, next))
+            return;
+        // Nothing fits: drop the stored copy too, so no in-flight record is left behind.
+        const _c = data.threads, _d = priority.threadId, dropped = _c[_d], rest = tslib_1.__rest(_c, [typeof _d === "symbol" ? _d : _d + ""]);
+        const others = Object.assign(Object.assign({}, data), { threads: rest });
+        if (isEmpty(others))
+            remove(storage);
+        else
+            tryWriteShedding(storage, others);
+    };
+    // Redo the merge if another tab wrote between our read and this write.
+    const MAX_COMMIT_ATTEMPTS = 3;
+    const transact = (mutate, priorityThreadId) => {
+        const storage = resolveStorage(storageOption, storageArea);
+        if (!storage)
+            return;
+        for (let attempt = 0; attempt < MAX_COMMIT_ATTEMPTS; attempt += 1) {
+            const raw = readRaw(storage);
+            const next = mutate(parse(raw));
+            if (!next)
+                return;
+            if (readRaw(storage) === raw) {
+                write(storage, next, priorityThreadId);
+                return;
+            }
+        }
+        // The key kept changing under us: skip rather than overwrite another tab's turns. Without
+        // Web Locks this check is best effort; a write between the compare and the set can still win.
+    };
+    /** The record to store once `chat` is merged in, or `null` to leave storage alone. */
+    const mergeThread = (current, chat) => {
+        var _a, _b, _c, _d;
+        const now = Date.now();
+        const createdAt = (_a = chat.createdAt) !== null && _a !== void 0 ? _a : now;
+        const deletedAt = (_b = current.deleted) === null || _b === void 0 ? void 0 : _b[chat.threadId];
+        if (deletedAt !== undefined && deletedAt >= createdAt)
+            return null;
+        const stored = current.threads[chat.threadId];
+        const incomingAt = (_c = chat.updatedAt) !== null && _c !== void 0 ? _c : now;
+        // An older snapshot may add turns but must not regress ones already settled.
+        const stale = Boolean(stored) && incomingAt < stored.updatedAt;
+        // Merging keeps turns other tabs added. The tab that wrote the stored record is instead
+        // writing a newer full view of it, and may have dropped a message (an aborted reply), so
+        // merging its own older copy back would resurrect what it just removed.
+        const ownsStored = (stored === null || stored === void 0 ? void 0 : stored.owner) !== undefined && chat.owner !== undefined && stored.owner === chat.owner;
+        const replace = !stored || (ownsStored && !stale);
+        const messages = replace ? chat.messages : (0, chatThreads_1.mergeMessages)(stored.messages, chat.messages, stale);
+        const base = stale ? stored : chat;
+        // A record holding turns its owner has not seen is nobody's full view, so the next save merges too.
+        const absorbed = !replace && messages.length > base.messages.length;
+        const merged = Object.assign(Object.assign({}, base), { owner: absorbed ? undefined : base.owner, version: chatThreads_1.PERSISTED_CHAT_VERSION, threadId: chat.threadId, messages: trimToTurns(messages, maxTurns), createdAt, updatedAt: Math.max(incomingAt, (_d = stored === null || stored === void 0 ? void 0 : stored.updatedAt) !== null && _d !== void 0 ? _d : 0) });
+        let next = Object.assign(Object.assign({}, current), { threads: Object.assign(Object.assign({}, current.threads), { [chat.threadId]: merged }) });
+        if (Number.isFinite(maxThreads)) {
+            const kept = sortedThreads(next).slice(0, Math.max(0, maxThreads));
+            next = Object.assign(Object.assign({}, next), { threads: Object.fromEntries(kept.map((t) => [t.threadId, t])) });
+            if (!next.threads[chat.threadId])
+                return null;
+        }
+        return next;
+    };
+    const retire = (data, staleId) => {
+        const _a = data.threads, _b = staleId, retired = _a[_b], threads = tslib_1.__rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+        return Object.assign(Object.assign({}, data), { threads, deleted: Object.assign(Object.assign({}, data.deleted), { [staleId]: Date.now() }) });
+    };
+    return {
+        listThreads() {
+            return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const now = Date.now();
+                return sortedThreads(read()).map((chat) => ({
+                    threadId: chat.threadId,
+                    title: (0, chatThreads_1.getThreadTitle)(chat.messages),
+                    createdAt: chat.createdAt,
+                    updatedAt: chat.updatedAt,
+                    inFlight: (0, chatThreads_1.isThreadStreaming)(chat, now),
+                }));
+            });
+        },
+        getThread(threadId) {
+            var _a;
+            return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return (_a = read().threads[threadId]) !== null && _a !== void 0 ? _a : null;
+            });
+        },
+        isThreadDeleted(threadId) {
+            var _a;
+            return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                // Deletes leave tombstones, so a missing key means the store was cleared from outside.
+                const storage = resolveStorage(storageOption, storageArea);
+                if (!storage || readRaw(storage) === null)
+                    return true;
+                return ((_a = read().deleted) === null || _a === void 0 ? void 0 : _a[threadId]) !== undefined;
+            });
+        },
+        saveThread(chat) {
+            return withStorageLock(storageKey, () => transact((current) => mergeThread(current, chat), chat.threadId));
+        },
+        saveThreadSync(chat, staleIds = []) {
+            // No Web Lock: its callback is a task, and tasks do not run while the document unloads.
+            transact((current) => {
+                const merged = mergeThread(current, chat);
+                if (!merged)
+                    return null;
+                return staleIds
+                    .filter((id) => id !== chat.threadId)
+                    .reduce((next, id) => retire(next, id), merged);
+            }, chat.threadId);
+        },
+        deleteThread(threadId) {
+            return withStorageLock(storageKey, () => transact((current) => retire(current, threadId)));
+        },
+        subscribe(listener) {
+            if (typeof window === 'undefined')
+                return () => { };
+            const onStorage = (event) => {
+                const area = resolveStorage(storageOption, storageArea);
+                if (area && event.storageArea && event.storageArea !== area)
+                    return;
+                if (event.key === null || event.key === storageKey)
+                    listener();
+            };
+            window.addEventListener('storage', onStorage);
+            return () => window.removeEventListener('storage', onStorage);
+        },
+    };
+}
+exports.createLocalStoragePersistence = createLocalStoragePersistence;
+const sharedStores = new Map();
+/**
+ * One store per namespace and area for the page, so a chat mounted again finds the answers still
+ * streaming into it. Not shared on the server, where the map would outlive the request.
+ */
+function sharedLocalStoragePersistence(namespace, storageArea) {
+    if (typeof window === 'undefined')
+        return createLocalStoragePersistence({ namespace, storageArea });
+    const id = `${storageArea}:${namespace}`;
+    const existing = sharedStores.get(id);
+    if (existing)
+        return existing;
+    const store = createLocalStoragePersistence({ namespace, storageArea });
+    sharedStores.set(id, store);
+    return store;
+}
+exports.sharedLocalStoragePersistence = sharedLocalStoragePersistence;
+exports.default = createLocalStoragePersistence;

package/lib/cjs/utils/translate.js

@@ -21,6 +21,7 @@ const defaultTranslations = {
     'CioAsa.results.saleBadge': 'Sale',
     'CioAsa.refinement.ariaLabel': 'Refine your results',
     'CioAsa.error.message': "I can't assist you with that request.",
+    'CioAsa.error.interrupted': 'The answer was interrupted. Please send your question again.',
 };
 function translate(key, translations) {
     var _a;

package/lib/cjs/version.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = '1.7.2';
+exports.default = '1.8.0';

package/lib/mjs/components/Chat/AiMessage.js

@@ -8,9 +8,8 @@ export default function AiMessage({ message, componentOverrides, translations })
     const hasGroups = !!message.groups?.length;
     // On error, fall back to the (translatable) error message when the agent
     // returned no partial text of its own.
-    const text = isError
-        ? message.text || translate('CioAsa.error.message', translations)
-        : message.text || '';
+    const errorKey = message.interrupted ? 'CioAsa.error.interrupted' : 'CioAsa.error.message';
+    const text = isError ? message.text || translate(errorKey, translations) : message.text || '';
     const hasText = text.length > 0;
     const loaderRenderProps = { translations };
     const textRenderProps = { text };