@talk2view/sdk 0.16.2 → 0.17.1

package/dist/chat/lib/conversation-store.js

@@ -0,0 +1,278 @@
+/** What the thread list shows for a conversation with no first message yet. */
+export const UNTITLED = 'New chat';
+/**
+ * Per identity. Fifty is far more than anyone accumulates in a side panel, and
+ * small enough to render in one list and to keep the stored blob modest. The
+ * size ceiling below usually binds first.
+ */
+export const MAX_CONVERSATIONS = 50;
+/**
+ * Identity buckets kept per partner. Signing out and back in as a guest mints a
+ * new anonymous id each time, so without this the entry would grow one dead
+ * bucket per visit. Eight keeps a shared machine's recent users and drops the
+ * rest, least recently used first.
+ */
+export const MAX_IDENTITIES = 8;
+/**
+ * Characters in the stored entry, across every identity. `localStorage` gives
+ * an origin about 5 MB in every current browser, and the chat is a guest in the
+ * partner's page — taking a tenth of their budget is the most it can justify.
+ * A conversation of twenty substantial turns is about 20 KB, so this is roughly
+ * twenty-five of them; the count cap above catches the short ones.
+ */
+export const MAX_CHARS = 512 * 1024;
+/** Longest title kept; longer first messages are cut at a word boundary. */
+const MAX_TITLE = 60;
+const KEY_PREFIX = 't2v_chat_conversations_v1:';
+/** The `localStorage` entry for one partner key. */
+export function storageKey(partnerKey) {
+    return KEY_PREFIX + partnerKey;
+}
+/**
+ * The bucket for an end-user. `null` — nobody signed in and no guest session
+ * yet — gets its own, which only ever holds the conversation a visitor started
+ * before anything authenticated; {@link useConversations} moves that one across
+ * when an id appears.
+ */
+export function identityKey(userId) {
+    return userId ? `u:${userId}` : 'none';
+}
+/**
+ * A short title from the first user message: one line, cut at a word boundary.
+ * Null when there is nothing to make one from — an attachment with no text, or
+ * whitespace — and the caller shows {@link UNTITLED} instead.
+ */
+export function titleFrom(message) {
+    const text = (message?.content ?? '').replace(/\s+/g, ' ').trim();
+    if (text)
+        return text.length <= MAX_TITLE ? text : cut(text);
+    const file = message?.attachments?.[0]?.filename?.trim();
+    return file ? (file.length <= MAX_TITLE ? file : cut(file)) : null;
+}
+function cut(text) {
+    const head = text.slice(0, MAX_TITLE);
+    const space = head.lastIndexOf(' ');
+    // Only break on a space if one is far enough in to leave a real title behind;
+    // a first word longer than that is cut mid-word rather than thrown away.
+    return (space > MAX_TITLE / 2 ? head.slice(0, space) : head).trimEnd() + '…';
+}
+// ── Reading ────────────────────────────────────────────────────────────────
+/**
+ * This identity's conversations, newest first.
+ *
+ * Never throws and never trusts what it finds: a private window refuses
+ * `localStorage` entirely, and the value itself is whatever anything else with
+ * access to this origin last wrote there. Anything that does not validate is
+ * dropped — one bad conversation, or the whole entry — and the chat carries on
+ * with no history rather than not at all.
+ */
+export function readConversations(partnerKey, identity) {
+    const file = readFile(partnerKey);
+    const bucket = file?.identities?.[identity];
+    if (!bucket)
+        return [];
+    return sortNewestFirst(asArray(bucket.conversations)
+        .map(parseConversation)
+        .filter((c) => c !== null));
+}
+// ── Writing ────────────────────────────────────────────────────────────────
+/**
+ * Replace this identity's conversations, keeping every other identity's as they
+ * are on disk. Returns false when nothing could be stored (no `localStorage`,
+ * or a quota that even the caps below could not get under), which the caller
+ * treats as "this device does not keep history" rather than as a failure.
+ *
+ * `current` is the conversation on screen: it is the one the caps must never
+ * drop, because dropping it would lose what the end-user is looking at.
+ */
+export function writeConversations(partnerKey, identity, conversations, current) {
+    const file = readFile(partnerKey) ?? { v: 1, identities: {} };
+    const identities = { ...file.identities };
+    const mine = sortNewestFirst([...conversations]).slice(0, MAX_CONVERSATIONS);
+    if (mine.length === 0) {
+        delete identities[identity];
+    }
+    else {
+        identities[identity] = { updatedAt: Date.now(), conversations: mine.map(serialise) };
+    }
+    // Least recently used identities go first: they are somebody else's old
+    // visit, where this one is on screen.
+    const ordered = Object.keys(identities)
+        .filter((key) => key !== identity)
+        .sort((a, b) => (identities[b]?.updatedAt ?? 0) - (identities[a]?.updatedAt ?? 0));
+    for (const key of ordered.slice(MAX_IDENTITIES - 1))
+        delete identities[key];
+    let json = JSON.stringify({ v: 1, identities });
+    while (json.length > MAX_CHARS) {
+        if (!dropOldest(identities, identity, current))
+            return remove(partnerKey);
+        json = JSON.stringify({ v: 1, identities });
+    }
+    return write(partnerKey, json);
+}
+/**
+ * Drop the single oldest conversation we are allowed to drop: another
+ * identity's first, then this one's, and never the one on screen. False when
+ * there is nothing left to give up.
+ */
+function dropOldest(identities, identity, current) {
+    const candidates = [];
+    for (const [key, bucket] of Object.entries(identities)) {
+        bucket.conversations.forEach((conversation, index) => {
+            if (key === identity && conversation.id === current)
+                return;
+            candidates.push({
+                key,
+                index,
+                mine: key === identity,
+                updatedAt: typeof conversation.updatedAt === 'number' ? conversation.updatedAt : 0,
+            });
+        });
+    }
+    // Another identity's conversations go before any of this one's, however old:
+    // what this end-user can still open is worth more than what they cannot.
+    candidates.sort((a, b) => Number(a.mine) - Number(b.mine) || a.updatedAt - b.updatedAt);
+    const victim = candidates[0];
+    if (!victim)
+        return false;
+    const bucket = identities[victim.key];
+    bucket.conversations = bucket.conversations.filter((_, i) => i !== victim.index);
+    if (bucket.conversations.length === 0)
+        delete identities[victim.key];
+    return true;
+}
+/** Forget everything stored for this partner key. Always returns false: nothing is stored now. */
+function remove(partnerKey) {
+    try {
+        localStorage.removeItem(storageKey(partnerKey));
+    }
+    catch {
+        // A private window, or storage the page is not allowed to touch at all.
+    }
+    return false;
+}
+function write(partnerKey, json) {
+    try {
+        localStorage.setItem(storageKey(partnerKey), json);
+        return true;
+    }
+    catch {
+        // Out of quota even under the caps, or storage refused outright. The list
+        // still works for the rest of this page's life; it just does not survive.
+        return false;
+    }
+}
+function serialise(conversation) {
+    return {
+        id: conversation.id,
+        title: conversation.title,
+        createdAt: conversation.createdAt,
+        updatedAt: conversation.updatedAt,
+        threadId: conversation.snapshot.threadId,
+        messages: conversation.snapshot.messages.map((message) => {
+            // `isStreaming` is deliberately dropped. A conversation left mid-reply is
+            // stored with the text that had arrived; restoring it with the flag still
+            // set would put a cursor on a message nothing is writing to.
+            const { isStreaming: _isStreaming, timestamp, ...rest } = message;
+            return { ...rest, timestamp: asDate(timestamp).toISOString() };
+        }),
+        history: conversation.snapshot.history,
+    };
+}
+function readFile(partnerKey) {
+    let raw;
+    try {
+        raw = localStorage.getItem(storageKey(partnerKey));
+    }
+    catch {
+        return null;
+    }
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed) || !isRecord(parsed.identities))
+            return null;
+        const identities = {};
+        for (const [key, value] of Object.entries(parsed.identities)) {
+            if (!isRecord(value))
+                continue;
+            identities[key] = {
+                updatedAt: typeof value.updatedAt === 'number' ? value.updatedAt : 0,
+                conversations: asArray(value.conversations),
+            };
+        }
+        return { v: 1, identities };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * One stored conversation, checked field by field. Anything missing or of the
+ * wrong type means the record is not ours — a half-written value, an older
+ * shape, or something hostile — and it is dropped rather than rendered.
+ */
+function parseConversation(value) {
+    if (!isRecord(value) || typeof value.id !== 'string' || !value.id)
+        return null;
+    const messages = asArray(value.messages)
+        .map(parseMessage)
+        .filter((m) => m !== null);
+    const history = asArray(value.history).filter(isChatMessage);
+    const createdAt = typeof value.createdAt === 'number' ? value.createdAt : Date.now();
+    return {
+        id: value.id,
+        title: typeof value.title === 'string' && value.title ? value.title : null,
+        createdAt,
+        updatedAt: typeof value.updatedAt === 'number' ? value.updatedAt : createdAt,
+        snapshot: {
+            messages,
+            history,
+            threadId: typeof value.threadId === 'string' ? value.threadId : null,
+        },
+    };
+}
+function parseMessage(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.id !== 'string' || typeof value.content !== 'string')
+        return null;
+    if (value.role !== 'user' && value.role !== 'assistant')
+        return null;
+    const message = {
+        id: value.id,
+        role: value.role,
+        content: value.content,
+        timestamp: asDate(value.timestamp),
+    };
+    if (Array.isArray(value.attachments))
+        message.attachments = value.attachments;
+    if (typeof value.plan === 'string')
+        message.plan = value.plan;
+    if (Array.isArray(value.steps))
+        message.steps = value.steps;
+    return message;
+}
+/** `role` and `content` are all the engine is sent; content may be parts, not a string. */
+function isChatMessage(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.role !== 'user' && value.role !== 'assistant' && value.role !== 'system')
+        return false;
+    return typeof value.content === 'string' || Array.isArray(value.content);
+}
+function asDate(value) {
+    const date = value instanceof Date ? value : new Date(typeof value === 'string' ? value : NaN);
+    return Number.isNaN(date.getTime()) ? new Date(0) : date;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function sortNewestFirst(conversations) {
+    return conversations.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+//# sourceMappingURL=conversation-store.js.map

package/dist/chat/lib/conversation-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-store.js","sourceRoot":"","sources":["../../../src/chat/lib/conversation-store.ts"],"names":[],"mappings":"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"}

package/dist/chat/lib/use-conversations.d.ts

@@ -0,0 +1,13 @@
+import type { ExternalStoreThreadListAdapter } from '@assistant-ui/react';
+import type { Talk2View } from '../../index.js';
+/**
+ * The thread-list adapter for `adapters.threadList`.
+ *
+ * With `enabled` false there is no list and nothing is stored, but New chat
+ * still works: it clears the conversation the way it always did, deleting the
+ * engine session too, because with no list there is no way back to it.
+ */
+export declare function useConversations(client: Talk2View, { enabled }: {
+    enabled: boolean;
+}): ExternalStoreThreadListAdapter;
+//# sourceMappingURL=use-conversations.d.ts.map

package/dist/chat/lib/use-conversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversations.d.ts","sourceRoot":"","sources":["../../../src/chat/lib/use-conversations.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAA2B,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AACnG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAyDhD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,EACjB,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GAChC,8BAA8B,CAwPhC"}

package/dist/chat/lib/use-conversations.js

@@ -0,0 +1,365 @@
+'use client';
+/**
+ * The chat's list of conversations: what "New chat" starts, what the Chats view
+ * shows, and what survives a reload.
+ *
+ * It owns the list and hands assistant-ui a thread-list adapter for it. The
+ * runtime stays dumb: it passes the adapter through and knows nothing about
+ * storage. {@link conversation-store} is the storage half.
+ *
+ * ## What happens when
+ *
+ * - **New chat** — the conversation on screen is kept where it is and an empty
+ *   one takes its place. Clicking it again on an empty chat does nothing, so
+ *   the list does not fill up with blanks.
+ * - **Switching** — the client is handed the stored transcript and the engine
+ *   session is detached, not deleted: the visitor may switch back, and the turn
+ *   it is running may not be finished. The next message opens a new session and
+ *   replays the transcript into it.
+ * - **Signing in or out** — the list follows the end-user. Whoever is there now
+ *   sees their own conversations and an empty chat, never the last person's.
+ *   The one exception is a visitor who started typing before anything
+ *   authenticated: their conversation moves across with them when the guest
+ *   session appears, because it was theirs all along.
+ * - **A guest becoming an account** — nothing moves. Converting keeps the same
+ *   user id, so the conversations are already in the right bucket.
+ */
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { UNTITLED, identityKey, readConversations, titleFrom, writeConversations, } from './conversation-store.js';
+/**
+ * Written this long after the last change, so a reply is stored once when it
+ * lands and not once per token.
+ */
+const WRITE_DELAY_MS = 500;
+/**
+ * …but never delayed longer than this. A reply that streams for a minute is
+ * checkpointed as it goes, so a reload in the middle of one keeps what arrived.
+ */
+const WRITE_MAX_DELAY_MS = 5_000;
+const EMPTY = { messages: [], history: [], threadId: null };
+/**
+ * The thread-list adapter for `adapters.threadList`.
+ *
+ * With `enabled` false there is no list and nothing is stored, but New chat
+ * still works: it clears the conversation the way it always did, deleting the
+ * engine session too, because with no list there is no way back to it.
+ */
+export function useConversations(client, { enabled }) {
+    const partnerKey = client.config.partnerKey;
+    // A mutable store plus a counter to re-render on: the snapshot of the
+    // conversation on screen changes on every streamed token, and the list only
+    // changes when a conversation is added, renamed, deleted or gains a message.
+    // Keeping them apart is what stops a reply repainting the list 60 times.
+    const store = useRef(null);
+    const [, setListVersion] = useState(0);
+    const publish = useCallback(() => setListVersion((n) => n + 1), []);
+    // Once, on the first render. Deliberately not in an effect: `start` may put a
+    // stored conversation back into the client, and the runtime reads the client's
+    // messages as its own initial state on this same render. Restoring later would
+    // paint the welcome screen first and replace it a frame afterwards. Nothing is
+    // subscribed to the client yet at this point — this hook is called before the
+    // runtime's — so the change this publishes reaches no other component.
+    if (store.current === null) {
+        store.current = start(client, partnerKey, enabled);
+    }
+    // ── Persistence ──────────────────────────────────────────────────────────
+    const timer = useRef(null);
+    const oldestPending = useRef(0);
+    const flush = useCallback(() => {
+        if (timer.current !== null) {
+            clearTimeout(timer.current);
+            timer.current = null;
+        }
+        oldestPending.current = 0;
+        const s = store.current;
+        if (!enabled)
+            return;
+        writeConversations(partnerKey, s.identity, s.conversations, s.currentId);
+    }, [enabled, partnerKey]);
+    const schedule = useCallback(() => {
+        if (!enabled)
+            return;
+        const now = Date.now();
+        if (oldestPending.current === 0)
+            oldestPending.current = now;
+        if (timer.current !== null)
+            clearTimeout(timer.current);
+        const wait = Math.min(WRITE_DELAY_MS, Math.max(0, oldestPending.current + WRITE_MAX_DELAY_MS - now));
+        timer.current = setTimeout(flush, wait);
+    }, [enabled, flush]);
+    // Closing the tab, or a phone putting the page to sleep, does not wait for a
+    // debounce. `pagehide` is the one that fires on the bfcache path too.
+    useEffect(() => {
+        const onHide = () => {
+            if (timer.current !== null)
+                flush();
+        };
+        const onVisibility = () => {
+            if (document.visibilityState === 'hidden')
+                onHide();
+        };
+        window.addEventListener('pagehide', onHide);
+        document.addEventListener('visibilitychange', onVisibility);
+        return () => {
+            window.removeEventListener('pagehide', onHide);
+            document.removeEventListener('visibilitychange', onVisibility);
+            // An unmount mid-debounce would otherwise drop the last change.
+            if (timer.current !== null)
+                flush();
+        };
+    }, [flush]);
+    // ── Keeping the conversation on screen up to date ────────────────────────
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const sync = () => {
+            const s = store.current;
+            const current = s.conversations.find((c) => c.id === s.currentId);
+            if (!current)
+                return;
+            const snapshot = client.exportConversation();
+            current.snapshot = snapshot;
+            // Title and date move when the transcript gains a message, not when the
+            // reply in it grows by a token.
+            if (snapshot.messages.length !== s.seen) {
+                s.seen = snapshot.messages.length;
+                current.updatedAt = Date.now();
+                if (current.title === null)
+                    current.title = titleFrom(firstUser(snapshot.messages));
+                reorder(s);
+                publish();
+            }
+            schedule();
+        };
+        const offs = [
+            client.on('messagesChange', sync),
+            // The last thing a turn does is record itself in the history the next
+            // message replays, and it does that after its final message change — so a
+            // snapshot taken on messages alone is one assistant turn short of being
+            // able to carry the conversation on. The loading flag drops after it.
+            client.on('loadingChange', (loading) => {
+                if (!loading)
+                    sync();
+            }),
+        ];
+        return () => offs.forEach((off) => off());
+    }, [client, enabled, publish, schedule]);
+    // ── Identity ─────────────────────────────────────────────────────────────
+    useEffect(() => {
+        if (!enabled)
+            return;
+        return client.auth.onAuthStateChange((user) => {
+            const s = store.current;
+            const next = identityKey(user?.id);
+            if (next === s.identity)
+                return;
+            // The conversation on screen follows the end-user across exactly one
+            // step: out of a guest session, or out of no session at all, into the
+            // account they have just signed in to. That is the same person carrying
+            // on — the visitor who typed before anything authenticated, and the guest
+            // who signed up because the demo ran out.
+            //
+            // It has to be a conversation they started here, in this page's life: one
+            // read back out of a guest bucket may be the last visitor's, and it must
+            // not walk into somebody else's account. And it never crosses from one
+            // account to another, where the two are simply different people.
+            const carried = s.guest && s.fresh.has(s.currentId)
+                ? s.conversations.find((c) => c.id === s.currentId)
+                : undefined;
+            // What the previous identity keeps, written before we let go of it. A
+            // conversation that moves is taken out of it rather than left in both.
+            const left = carried ? s.conversations.filter((c) => c.id !== carried.id) : s.conversations;
+            if (timer.current !== null)
+                clearTimeout(timer.current);
+            timer.current = null;
+            oldestPending.current = 0;
+            writeConversations(partnerKey, s.identity, left, null);
+            s.identity = next;
+            s.guest = isGuest(client, next);
+            s.conversations = readConversations(partnerKey, next);
+            if (carried) {
+                s.conversations.unshift(carried);
+                reorder(s);
+                s.seen = client.messages.length;
+            }
+            else {
+                // Somebody else is in front of the chat now. They get their own list and
+                // an empty conversation; the last person's goes off the screen.
+                blank(s);
+                client.restoreConversation(EMPTY);
+            }
+            publish();
+            flush();
+        });
+    }, [client, enabled, flush, partnerKey, publish]);
+    // ── The adapter ──────────────────────────────────────────────────────────
+    const s = store.current;
+    const threads = useMemo(() => s.conversations
+        // An empty conversation is not one yet. Leaving it out is what keeps
+        // the Chats button off until there is something behind it, and stops
+        // the list opening on a single row saying "New chat".
+        .filter((c) => c.snapshot.messages.length > 0)
+        .map((c) => ({
+        id: c.id,
+        status: 'regular',
+        // Never left to assistant-ui's own fallback, so one word decides
+        // what an untitled conversation is called.
+        title: c.title ?? UNTITLED,
+        lastMessageAt: new Date(c.updatedAt),
+    })), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [s.conversations]);
+    const onSwitchToNewThread = useCallback(() => {
+        if (!enabled) {
+            // No list, so no way back: end the session rather than leave it behind.
+            client.clearMessages();
+            return;
+        }
+        const s = store.current;
+        const current = s.conversations.find((c) => c.id === s.currentId);
+        // Already on an empty chat. Pressing New again should not stack up blanks.
+        if (current && current.snapshot.messages.length === 0)
+            return;
+        blank(s);
+        client.restoreConversation(EMPTY);
+        s.seen = 0;
+        publish();
+        flush();
+    }, [client, enabled, flush, publish]);
+    const onSwitchToThread = useCallback((id) => {
+        const s = store.current;
+        const target = s.conversations.find((c) => c.id === id);
+        if (!target || id === s.currentId)
+            return;
+        s.currentId = id;
+        s.seen = target.snapshot.messages.length;
+        client.restoreConversation(target.snapshot);
+        publish();
+        flush();
+    }, [client, flush, publish]);
+    const onRename = useCallback((id, title) => {
+        const s = store.current;
+        const target = s.conversations.find((c) => c.id === id);
+        if (!target)
+            return;
+        // Renaming does not count as activity: the conversation keeps its place
+        // in the list instead of jumping to the top of it.
+        target.title = title.trim() || null;
+        // A new array, or the adapter would hand assistant-ui the one it already
+        // has and the new name would never reach the screen.
+        reorder(s);
+        publish();
+        flush();
+    }, [flush, publish]);
+    const onDelete = useCallback((id) => {
+        const s = store.current;
+        s.conversations = s.conversations.filter((c) => c.id !== id);
+        if (id === s.currentId) {
+            blank(s);
+            client.restoreConversation(EMPTY);
+            s.seen = 0;
+        }
+        publish();
+        flush();
+    }, [client, flush, publish]);
+    return useMemo(() => enabled
+        ? {
+            threadId: s.currentId,
+            threads,
+            onSwitchToNewThread,
+            onSwitchToThread,
+            onRename,
+            onDelete,
+        }
+        : { onSwitchToNewThread }, [enabled, s.currentId, threads, onSwitchToNewThread, onSwitchToThread, onRename, onDelete]);
+}
+// ── The store ──────────────────────────────────────────────────────────────
+/**
+ * The list as it stands when the chat mounts.
+ *
+ * A client handed to the chat may already be holding a conversation — a partner
+ * sharing one client with the rest of their app, or a chat that unmounted and
+ * came back. That transcript is adopted rather than thrown away: into the
+ * stored conversation it came from where the last message identifies one, and
+ * into a new conversation where it does not.
+ */
+function start(client, partnerKey, enabled) {
+    const identity = identityKey(client.auth.getUser?.()?.id);
+    const conversations = enabled ? readConversations(partnerKey, identity) : [];
+    const messages = client.messages;
+    const store = {
+        identity,
+        conversations,
+        currentId: '',
+        seen: 0,
+        fresh: new Set(),
+        guest: isGuest(client, identity),
+    };
+    if (messages.length > 0) {
+        // A transcript already in the client is one somebody is in the middle of,
+        // so it counts as started here however it got there.
+        const lastId = messages[messages.length - 1].id;
+        const known = conversations.find((c) => c.snapshot.messages[c.snapshot.messages.length - 1]?.id === lastId);
+        const conversation = known ??
+            {
+                id: newId(),
+                title: titleFrom(firstUser(messages)),
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+                snapshot: client.exportConversation(),
+            };
+        if (known)
+            known.snapshot = client.exportConversation();
+        else
+            conversations.unshift(conversation);
+        store.currentId = conversation.id;
+        store.seen = messages.length;
+        store.fresh.add(conversation.id);
+        return store;
+    }
+    // Nothing on screen: pick up where this device left off. The transcript is
+    // put back locally — the engine is not asked for anything and does not need
+    // to remember it. Not marked as started here: it may be an earlier visitor's.
+    const newest = conversations[0];
+    if (newest) {
+        client.restoreConversation(newest.snapshot);
+        store.currentId = newest.id;
+        store.seen = newest.snapshot.messages.length;
+        return store;
+    }
+    blank(store);
+    return store;
+}
+/** Put a fresh, empty conversation at the top of the list and make it the current one. */
+function blank(store) {
+    const conversation = {
+        id: newId(),
+        title: null,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        snapshot: { messages: [], history: [], threadId: null },
+    };
+    store.conversations = [conversation, ...store.conversations];
+    store.currentId = conversation.id;
+    store.seen = 0;
+    store.fresh.add(conversation.id);
+}
+/** Newest first, and a new array so the adapter's `threads` is seen to have changed. */
+function reorder(store) {
+    store.conversations = [...store.conversations].sort((a, b) => b.updatedAt - a.updatedAt);
+}
+function firstUser(messages) {
+    return messages.find((m) => m.role === 'user');
+}
+/** Whether there is no account behind this identity: a guest, or nobody yet. */
+function isGuest(client, identity) {
+    return identity === identityKey(null) || client.auth.isAnonymous?.() === true;
+}
+/**
+ * `crypto.randomUUID` needs a secure context, which a partner's staging page on
+ * plain http is not. The id only has to be unique inside one browser's storage.
+ */
+function newId() {
+    return `c_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+//# sourceMappingURL=use-conversations.js.map