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

package/lib/mjs/utils/chatThreads.js

@@ -0,0 +1,219 @@
+/** Stored record format; records with another version are ignored on read. */
+export const PERSISTED_CHAT_VERSION = 1;
+/** Prefix of the `localStorage` key; the api key, domain and user id are appended to it. */
+export const DEFAULT_PERSISTENCE_KEY = 'cio-asa:chat';
+/** One week, matching how long the agent itself remembers a thread. */
+export const 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. */
+export const 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. */
+export 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)}`;
+}
+/** Client-side thread id for a conversation the server has not named yet. */
+export function createLocalThreadId() {
+    return `${LOCAL_THREAD_PREFIX}${randomId()}`;
+}
+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?.type === 'reload';
+    }
+    catch {
+        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.
+ */
+export 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 {
+                /* ignore */
+            }
+        });
+        window.addEventListener('pageshow', (event) => {
+            if (!event.persisted)
+                return;
+            try {
+                sessionStorage.removeItem(TAB_ID_KEY);
+            }
+            catch {
+                /* ignore */
+            }
+        });
+    }
+    catch {
+        /* sessionStorage blocked: the id lasts for this page only */
+    }
+    return tabId;
+}
+/** Whether `threadId` was made by `createLocalThreadId` rather than by the server. */
+export function isLocalThreadId(threadId) {
+    return typeof threadId === 'string' && threadId.startsWith(LOCAL_THREAD_PREFIX);
+}
+/** Title for a thread list: the first user message, truncated with an ellipsis. */
+export function getThreadTitle(messages) {
+    const first = messages.find((m) => m.role === 'user')?.text ?? '';
+    return first.length > TITLE_MAX_LENGTH ? `${first.slice(0, TITLE_MAX_LENGTH - 1)}…` : first;
+}
+/** Counter to continue message ids from after a restore, so new ids never collide with restored ones. */
+export 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);
+}
+/** Whether the latest answer in `messages` has not finished streaming. */
+export function isInFlight(messages) {
+    const last = messages[messages.length - 1];
+    return last?.status === 'loading' || last?.status === 'streaming';
+}
+/** Settles answers stored mid-stream: `done` when they have content, an interrupted `error` otherwise. */
+export function normalizeHydratedMessages(messages) {
+    return messages.map((m) => {
+        if (m.status !== 'loading' && m.status !== 'streaming')
+            return m;
+        const hasContent = Boolean(m.text) || Boolean(m.groups?.length) || Boolean(m.refinement);
+        return hasContent ? { ...m, status: 'done' } : { ...m, status: 'error', interrupted: true };
+    });
+}
+/** Messages as stored: raw items replaced by the cards `normalize` makes; a restored group keeps its cards. */
+export function compactMessages(messages, normalize) {
+    return messages.map((m) => m.groups?.length
+        ? {
+            ...m,
+            groups: m.groups.map((g) => ({
+                ...g,
+                searchResults: [],
+                products: g.products ?? g.searchResults.map(normalize),
+            })),
+        }
+        : m);
+}
+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.
+ */
+export 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)),
+    ];
+}
+/**
+ * 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.
+ */
+export async function saveThreadAndRetireStale(store, snapshot, staleIds) {
+    try {
+        await store.saveThread(snapshot);
+    }
+    catch {
+        return { saved: false, leftover: staleIds };
+    }
+    const persisted = await store.getThread(snapshot.threadId).catch(() => null);
+    if (!persisted || persisted.updatedAt < snapshot.updatedAt) {
+        return { saved: false, leftover: staleIds };
+    }
+    const retired = await Promise.all(staleIds.map(async (id) => {
+        await store.deleteThread(id).catch(() => { });
+        return (await store.getThread(id).catch(() => null)) === null;
+    }));
+    return { saved: true, leftover: staleIds.filter((_, i) => !retired[i]) };
+}
+/** Finds the server-keyed record another tab re-keyed a local thread into, by its first message. */
+export async function findRekeyedThread(store, firstMessageId) {
+    if (!firstMessageId)
+        return null;
+    const list = await store.listThreads();
+    const candidates = list.filter((t) => !isLocalThreadId(t.threadId));
+    const loaded = await Promise.all(candidates.map((t) => store.getThread(t.threadId)));
+    return loaded.find((c) => c?.messages[0]?.id === firstMessageId) ?? null;
+}
+/** Whether a stored thread still reads as streaming: this tab's own always, another tab's only within the grace. */
+export 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 < IN_FLIGHT_GRACE_MS;
+}
+/** Ms left to show a stored answer as streaming in another tab; `0` when it should be settled. */
+export 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, IN_FLIGHT_GRACE_MS - (now - chat.updatedAt));
+}
+/**
+ * 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.
+ */
+export async function moveThreads(from, to, onScreen = {}) {
+    const { threadIds = [], firstMessageId } = onScreen;
+    const summaries = await from.listThreads();
+    const chats = (await Promise.all(summaries.map((t) => from.getThread(t.threadId)))).filter((chat) => chat !== null);
+    const isShown = (chat) => threadIds.includes(chat.threadId) ||
+        (firstMessageId !== undefined && chat.messages[0]?.id === firstMessageId);
+    const toCopy = chats.filter((chat) => !isShown(chat));
+    await Promise.all(toCopy.map((chat) => to.saveThread(chat)));
+    const targetList = await to.listThreads();
+    const target = new Map((await 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;
+    });
+    await Promise.all(moved.map((chat) => from.deleteThread(chat.threadId)));
+}

package/lib/mjs/utils/clientOptions.js

@@ -0,0 +1,7 @@
+/** `options` is private in the client's typings; read it here only, so a client bump fails a test, not storage keys. */
+export function readClientOptions(client) {
+    const { options } = (client ?? {});
+    if (!options || typeof options !== 'object')
+        return undefined;
+    return options;
+}

package/lib/mjs/utils/localStoragePersistence.js

@@ -0,0 +1,373 @@
+import { DEFAULT_PERSISTENCE_KEY, DEFAULT_PERSISTENCE_TTL_MS, PERSISTED_CHAT_VERSION, getThreadTitle, isThreadStreaming, mergeMessages, } from './chatThreads';
+import isPersistedChat from './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.
+async function withStorageLock(name, fn) {
+    const locks = typeof navigator !== 'undefined' ? navigator.locks : undefined;
+    if (!locks?.request) {
+        fn();
+        return;
+    }
+    let ran = false;
+    try {
+        await locks.request(name, async () => {
+            ran = true;
+            fn();
+        });
+    }
+    catch {
+        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 {
+        return null;
+    }
+}
+/** No user id, or an empty one: the conversation belongs to a guest. */
+export const isGuest = (userId) => userId == null || userId === '';
+/** The id the client and storage use: `undefined` for a guest (no id, `null` or empty). */
+export const shopperId = (userId) => isGuest(userId) ? undefined : String(userId);
+/** Guests live in `sessionStorage`, so their history ends with the tab; shoppers keep theirs in `localStorage`. */
+export function storageAreaFor(userId) {
+    return isGuest(userId) ? 'session' : 'local';
+}
+/** Namespace the provider stores under: api key, domain and, for a signed-in shopper, the user id. */
+export function persistenceNamespace(parts) {
+    return [parts.apiKey, parts.domain ?? 'default', shopperId(parts.userId)]
+        .filter((part) => part !== undefined)
+        .map(encodeURIComponent)
+        .join(':');
+}
+function storageKeyFor(key, namespace) {
+    return [key, `v${PERSISTED_CHAT_VERSION}`, namespace].filter(Boolean).join(':');
+}
+const emptyStored = () => ({
+    version: PERSISTED_CHAT_VERSION,
+    threads: {},
+    deleted: {},
+});
+function parseStored(raw) {
+    if (!raw)
+        return emptyStored();
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed?.version !== PERSISTED_CHAT_VERSION || !parsed.threads)
+            return emptyStored();
+        const threads = Object.fromEntries(Object.entries(parsed.threads).filter(([, chat]) => isPersistedChat(chat)));
+        const deleted = Object.fromEntries(Object.entries(parsed.deleted ?? {}).filter(([, at]) => typeof at === 'number'));
+        return { version: PERSISTED_CHAT_VERSION, threads, deleted };
+    }
+    catch {
+        return emptyStored();
+    }
+}
+function readItem(storage, key) {
+    try {
+        return storage.getItem(key);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Deletes every stored conversation of one shopper, or of the guest without `userId`; open tabs
+ * follow. Resolves once the deletion is recorded.
+ */
+export async function clearPersistedConversations(options) {
+    const { apiKey, domain = 'chatbot', userId, storage: storageOption } = options;
+    const storage = resolveStorage(storageOption, storageAreaFor(userId));
+    if (!storage)
+        return;
+    const key = storageKeyFor(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.
+    await withStorageLock(key, () => {
+        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) => ({ ...all, [threadId]: now }), current.deleted ?? {});
+            if (Object.keys(deleted).length === 0)
+                storage.removeItem(key);
+            else
+                storage.setItem(key, JSON.stringify({ ...emptyStored(), deleted }));
+            cleared = true;
+        }
+        catch {
+            /* 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 non-Storage `storage` option cannot be attached to the event */
+    }
+}
+/** Conversation store on top of `localStorage`; one key per namespace, merged across tabs. */
+export function createLocalStoragePersistence(options = {}) {
+    const { key = DEFAULT_PERSISTENCE_KEY, namespace, ttlMs = 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) => {
+        if (!raw)
+            return emptyStored();
+        if (lastParsed?.raw !== raw)
+            lastParsed = { raw, data: parseStored(raw) };
+        const cutoff = Date.now() - ttlMs;
+        const { data } = lastParsed;
+        return {
+            version: PERSISTED_CHAT_VERSION,
+            threads: Object.fromEntries(Object.entries(data.threads).filter(([, chat]) => chat.updatedAt >= cutoff)),
+            deleted: Object.fromEntries(Object.entries(data.deleted ?? {}).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 {
+            return false;
+        }
+    };
+    const remove = (storage) => {
+        try {
+            storage.removeItem(storageKey);
+        }
+        catch {
+            /* ignore */
+        }
+    };
+    const isEmpty = (data) => Object.keys(data.threads).length === 0 && Object.keys(data.deleted ?? {}).length === 0;
+    // Retries without tombstones, oldest first: the last thing to shed, see `write`.
+    const tryWriteShedding = (storage, data) => {
+        if (tryWrite(storage, data))
+            return true;
+        const oldestFirst = Object.entries(data.deleted ?? {})
+            .sort((a, b) => a[1] - b[1])
+            .map(([id]) => id);
+        let next = data;
+        for (let i = 0; i < oldestFirst.length; i += 1) {
+            const { [oldestFirst[i]]: shed, ...deleted } = next.deleted ?? {};
+            next = { ...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?.threadId)
+            .reverse();
+        let next = data;
+        for (let i = 0; i < oldestFirst.length; i += 1) {
+            const { [oldestFirst[i].threadId]: evicted, ...threads } = next.threads;
+            next = { ...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 = { ...chat, messages: trimToTurns(chat.messages.slice(2), maxTurns) };
+            next = { ...next, threads: { ...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 { [priority.threadId]: dropped, ...rest } = data.threads;
+        const others = { ...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) => {
+        const now = Date.now();
+        const createdAt = chat.createdAt ?? now;
+        const deletedAt = current.deleted?.[chat.threadId];
+        if (deletedAt !== undefined && deletedAt >= createdAt)
+            return null;
+        const stored = current.threads[chat.threadId];
+        const incomingAt = chat.updatedAt ?? 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?.owner !== undefined && chat.owner !== undefined && stored.owner === chat.owner;
+        const replace = !stored || (ownsStored && !stale);
+        const messages = replace ? chat.messages : 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 = {
+            ...base,
+            owner: absorbed ? undefined : base.owner,
+            version: PERSISTED_CHAT_VERSION,
+            threadId: chat.threadId,
+            messages: trimToTurns(messages, maxTurns),
+            createdAt,
+            updatedAt: Math.max(incomingAt, stored?.updatedAt ?? 0),
+        };
+        let next = {
+            ...current,
+            threads: { ...current.threads, [chat.threadId]: merged },
+        };
+        if (Number.isFinite(maxThreads)) {
+            const kept = sortedThreads(next).slice(0, Math.max(0, maxThreads));
+            next = { ...next, threads: Object.fromEntries(kept.map((t) => [t.threadId, t])) };
+            if (!next.threads[chat.threadId])
+                return null;
+        }
+        return next;
+    };
+    const retire = (data, staleId) => {
+        const { [staleId]: retired, ...threads } = data.threads;
+        return { ...data, threads, deleted: { ...data.deleted, [staleId]: Date.now() } };
+    };
+    return {
+        async listThreads() {
+            const now = Date.now();
+            return sortedThreads(read()).map((chat) => ({
+                threadId: chat.threadId,
+                title: getThreadTitle(chat.messages),
+                createdAt: chat.createdAt,
+                updatedAt: chat.updatedAt,
+                inFlight: isThreadStreaming(chat, now),
+            }));
+        },
+        async getThread(threadId) {
+            return read().threads[threadId] ?? null;
+        },
+        async isThreadDeleted(threadId) {
+            // 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 read().deleted?.[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);
+        },
+    };
+}
+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.
+ */
+export 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;
+}
+export default createLocalStoragePersistence;

package/lib/mjs/utils/translate.js

@@ -19,6 +19,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.',
 };
 export default function translate(key, translations) {
     if (translations?.[key] !== undefined) {

package/lib/mjs/version.js

@@ -1 +1 @@
-export default '1.7.2';
+export default '1.8.0';

package/lib/types/components/Chat/Chat.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { ChatComponentOverrides, ResultGroupMeta, Translations } from '../../types';
+import { ChatComponentOverrides, ResultGroupMeta, ThreadSummary, Translations } from '../../types';
 import { Product, NormalizeOptions } from '../../utils/productNormalizer';
 import { AspectRatio } from '../ResultsBlock/ResultsBlock';
 export interface ChatHandle {
@@ -9,8 +9,12 @@ export interface ChatHandle {
      * No-op when nothing is streaming.
      */
     abort: () => void;
-    /** Cancel any active response, then reset the conversation and the thread. */
+    /** Cancel any active response, then reset the conversation and delete it from storage. */
     clearHistory: () => void;
+    /** Start an empty conversation, keeping the current one in storage. */
+    newThread: () => void;
+    /** Load a stored conversation. No-op when persistence is off. */
+    switchThread: (threadId: string) => Promise<void>;
 }
 export interface ChatProps {
     /** Called when the close button (✕) is clicked. The consumer controls visibility. */
@@ -42,6 +46,8 @@ export interface ChatProps {
     translations?: Translations;
     /** Seed the thread id (e.g. loaded from browser storage) to resume a prior conversation. Read once on mount. */
     initialThreadId?: string;
+    /** Fires with the stored conversations and the active one whenever either changes. Requires persistence. */
+    onThreadsChange?: (threads: ThreadSummary[], activeThreadId: string | null) => void;
     /**
      * Whether the input's send button becomes a stop button while a reply streams.
      * Defaults to `false`, so the packaged UI is unchanged unless you opt in. While it is

package/lib/types/components/CioAsa/CioAsa.d.ts

@@ -10,5 +10,5 @@ export type CioAsaProps = CioAsaProviderProps & ChatProps;
  * directly. This is the single-entry-point convenience wrapper, and it is what the
  * standalone browser bundle (`src/bundled.jsx`) mounts.
  */
-declare const CioAsa: React.ForwardRefExoticComponent<CioAsaProviderProps & ChatProps & React.RefAttributes<ChatHandle>>;
+declare const CioAsa: React.ForwardRefExoticComponent<CioAsaProps & React.RefAttributes<ChatHandle>>;
 export default CioAsa;