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

package/lib/mjs/hooks/useAsaResults.js

@@ -5,6 +5,7 @@ import useChatPersistence from './persistence/useChatPersistence';
 import { startTurn } from './agentStream';
 import { createChatSession, nextMessageId } from '../utils/chatSession';
 import { normalizeItemToProduct } from '../utils/productNormalizer';
+import { isLocalThreadId, settleCancelledReply } from '../utils/chatThreads';
 import useLatest from './useLatest';
 export default function useAsaResults(options) {
     const contextValue = useCioAsaContext();
@@ -38,6 +39,18 @@ export default function useAsaResults(options) {
         turnRef.current?.cancel();
         turnRef.current = null;
     }, []);
+    const abortOwnTurn = useCallback(() => {
+        if (!session.isStreaming)
+            return;
+        const abortedId = turnRef.current?.assistantId;
+        cancelStream();
+        session.isStreaming = false;
+        setIsStreaming(false);
+        if (abortedId)
+            setMessages((prev) => settleCancelledReply(prev, abortedId));
+        // With persistence on, the cancelled turn is stored as it stands.
+        session.dirty = true;
+    }, [session, cancelStream]);
     const store = useChatPersistence({
         store: persistence,
         scope: persistenceScope,
@@ -50,15 +63,16 @@ export default function useAsaResults(options) {
         setIsStreaming,
         turnRef,
         cancelStream,
+        abortTurn: abortOwnTurn,
     });
-    const { beginTurn, screenOwner } = store;
+    const { beginTurn, screenOwner, abortForeign } = store;
     useEffect(() => cancelStream, [cancelStream]);
-    const sendMessage = useCallback((text, source = 'input') => {
+    const sendToCurrentThread = useCallback((text, source) => {
         const intent = text.trim();
         if (!intent || session.isStreaming || session.foreignInFlight)
             return;
         beginTurn();
-        trackingRef.current.trackSubmit(intent);
+        trackingRef.current.trackSubmit(intent, source);
         callbacksRef.current?.onAssistantSubmit?.({ intent, source });
         const userMessage = {
             id: nextMessageId(session),
@@ -108,6 +122,32 @@ export default function useAsaResults(options) {
         callbacksRef,
         staticRequestConfigsRef,
     ]);
+    const { newThread, switchThread } = store;
+    /**
+     * Sends `text`. With `threadId`, first moves to that conversation, loading it from storage
+     * when persistence has it and otherwise continuing it on the server with an empty screen.
+     */
+    const sendMessage = useCallback((text, source = 'input', { threadId } = {}) => {
+        if (!threadId ||
+            threadId === session.serverThreadId ||
+            threadId === session.storageThreadId) {
+            sendToCurrentThread(text, source);
+            return;
+        }
+        (async () => {
+            if (persistence)
+                await switchThread(threadId);
+            else
+                newThread();
+            // A turn that started meanwhile (or one still streaming in the background) owns the screen.
+            if (session.isStreaming || session.foreignInFlight)
+                return;
+            if (!session.serverThreadId && !isLocalThreadId(threadId)) {
+                session.serverThreadId = threadId;
+            }
+            sendToCurrentThread(text, source);
+        })();
+    }, [session, persistence, newThread, switchThread, sendToCurrentThread]);
     /**
      * Cancels the in-flight request while keeping the conversation: the partial reply is
      * settled as `done` (so the typing indicator stops and streamed text survives) and the
@@ -122,37 +162,26 @@ export default function useAsaResults(options) {
      * No beacon is sent: there is no "aborted" ASA event, and reporting the load as
      * finished would be false. An aborted turn therefore leaves an
      * `assistant_result_load_started` with no matching finished event.
+     *
+     * An answer streaming in another tab is stopped by that tab, which stores the result.
      */
     const abort = useCallback(() => {
-        if (!session.isStreaming)
-            return;
-        const abortedId = turnRef.current?.assistantId;
-        cancelStream();
-        session.isStreaming = false;
-        setIsStreaming(false);
-        if (abortedId) {
-            setMessages((prev) => prev.flatMap((msg) => {
-                if (msg.id !== abortedId)
-                    return [msg];
-                if (!msg.text && !msg.groups?.length && !msg.refinement)
-                    return [];
-                return [{ ...msg, status: 'done' }];
-            }));
-        }
-        // With persistence on, the cancelled turn is stored as it stands.
-        session.dirty = true;
-    }, [session, cancelStream]);
+        if (session.isStreaming)
+            abortOwnTurn();
+        else
+            abortForeign();
+    }, [session, abortOwnTurn, abortForeign]);
     return {
         messages,
         sendMessage,
         isStreaming: isStreaming || store.foreignInFlight,
-        canAbort: isStreaming,
+        canAbort: isStreaming || store.canAbortForeign,
         abort,
         clearHistory: store.clearHistory,
         isHydrating: store.isHydrating,
         threads: store.threads,
         activeThreadId: store.activeThreadId,
-        newThread: store.newThread,
-        switchThread: store.switchThread,
+        newThread,
+        switchThread,
     };
 }

package/lib/mjs/hooks/useAsaTracking.js

@@ -1,5 +1,14 @@
 import { useCallback, useMemo } from 'react';
+/** Beacon `source` values, aligned with the ones the behavioral-actions API documents. */
+const BEACON_SUBMIT_SOURCES = {
+    input: 'input',
+    suggestion: 'suggestion',
+    refinement: 'follow_up',
+    // A prompt the host page sent, typically a suggested question clicked outside the chat.
+    external: 'suggestion',
+};
 const NOOP_TRACKING = {
+    trackAgentButtonClick: () => { },
     trackSubmit: () => { },
     trackResultLoadStarted: () => { },
     trackResultLoadFinished: () => { },
@@ -13,32 +22,45 @@ const NOOP_TRACKING = {
  * Mirrors the tracking-hook pattern used by constructorio-ui-pia.
  */
 export default function useAsaTracking({ tracker, section, threadId, }) {
-    const assistant = tracker;
     const base = useMemo(() => ({
         ...(section && { section }),
         ...(threadId && { threadId }),
     }), [section, threadId]);
-    const trackSubmit = useCallback((intent) => {
-        assistant?.trackAssistantSubmit({ intent, ...base });
-    }, [assistant, base]);
+    const trackAgentButtonClick = useCallback(({ mode, agentDomain, positionOnPage, pageType, instanceId }) => {
+        tracker?.trackAgentButtonClick?.({
+            mode,
+            agentDomain,
+            ...(positionOnPage && { positionOnPage }),
+            ...(pageType && { pageType }),
+            ...(instanceId && { instanceId }),
+            ...(section && { section }),
+        });
+    }, [tracker, section]);
+    const trackSubmit = useCallback((intent, source) => {
+        tracker?.trackAssistantSubmit({
+            intent,
+            ...(source && { source: BEACON_SUBMIT_SOURCES[source] }),
+            ...base,
+        });
+    }, [tracker, base]);
     const trackResultLoadStarted = useCallback(({ intent, intentResultId }) => {
-        assistant?.trackAssistantResultLoadStarted({
+        tracker?.trackAssistantResultLoadStarted({
             intent,
             ...(intentResultId && { intentResultId }),
             ...base,
         });
-    }, [assistant, base]);
+    }, [tracker, base]);
     const trackResultLoadFinished = useCallback(({ intent, searchResultCount, intentResultId, threadId: turnThreadId, }) => {
-        assistant?.trackAssistantResultLoadFinished({
+        tracker?.trackAssistantResultLoadFinished({
             intent,
             searchResultCount,
             ...(intentResultId && { intentResultId }),
             ...base,
             ...(turnThreadId && { threadId: turnThreadId }),
         });
-    }, [assistant, base]);
+    }, [tracker, base]);
     const trackResultClick = useCallback(({ intent, searchResultId, intentResultId, itemId, itemName, variationId, }) => {
-        assistant?.trackAssistantResultClick({
+        tracker?.trackAssistantResultClick({
             intent,
             searchResultId,
             ...(intentResultId && { intentResultId }),
@@ -47,9 +69,9 @@ export default function useAsaTracking({ tracker, section, threadId, }) {
             ...(variationId && { variationId }),
             ...base,
         });
-    }, [assistant, base]);
+    }, [tracker, base]);
     const trackResultView = useCallback(({ intent, searchResultId, numResultsViewed, intentResultId, items }) => {
-        assistant?.trackAssistantResultView({
+        tracker?.trackAssistantResultView({
             intent,
             searchResultId,
             numResultsViewed,
@@ -57,9 +79,9 @@ export default function useAsaTracking({ tracker, section, threadId, }) {
             ...(items && items.length > 0 && { items }),
             ...base,
         });
-    }, [assistant, base]);
+    }, [tracker, base]);
     const trackSearchSubmit = useCallback(({ intent, searchTerm, userInput, searchResultId, intentResultId, groupId, }) => {
-        assistant?.trackAssistantSearchSubmit({
+        tracker?.trackAssistantSearchSubmit({
             intent,
             searchTerm,
             userInput,
@@ -68,11 +90,12 @@ export default function useAsaTracking({ tracker, section, threadId, }) {
             ...(groupId && { groupId }),
             ...base,
         });
-    }, [assistant, base]);
+    }, [tracker, base]);
     return useMemo(() => {
-        if (!assistant)
+        if (!tracker)
             return NOOP_TRACKING;
         return {
+            trackAgentButtonClick,
             trackSubmit,
             trackResultLoadStarted,
             trackResultLoadFinished,
@@ -81,7 +104,8 @@ export default function useAsaTracking({ tracker, section, threadId, }) {
             trackSearchSubmit,
         };
     }, [
-        assistant,
+        tracker,
+        trackAgentButtonClick,
         trackSubmit,
         trackResultLoadStarted,
         trackResultLoadFinished,

package/lib/mjs/index.js

@@ -11,5 +11,6 @@ export { default as useCioAsaContext } from './hooks/useCioAsaContext';
 // Utils
 export { normalizeItemToProduct } from './utils/productNormalizer';
 export { clearPersistedConversations } from './utils/localStoragePersistence';
+export { renderMarkdown } from './utils/markdown';
 // Re-exported client value from the JS client (used to construct/type a cioClient)
 export { ConstructorIOClient } from './types';

package/lib/mjs/utils/chatThreads.js

@@ -6,6 +6,8 @@ export const DEFAULT_PERSISTENCE_KEY = 'cio-asa:chat';
 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;
+/** How long to wait for the tab streaming an answer to store it stopped, before settling it here. */
+export const FOREIGN_ABORT_TIMEOUT_MS = 3 * 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. */
@@ -111,6 +113,16 @@ export function normalizeHydratedMessages(messages) {
         return hasContent ? { ...m, status: 'done' } : { ...m, status: 'error', interrupted: true };
     });
 }
+/** `messages` with the cancelled reply settled: `done` when it has content, dropped otherwise. */
+export function settleCancelledReply(messages, assistantId) {
+    return messages.flatMap((m) => {
+        if (m.id !== assistantId)
+            return [m];
+        if (!m.text && !m.groups?.length && !m.refinement)
+            return [];
+        return [{ ...m, status: 'done' }];
+    });
+}
 /** 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

package/lib/mjs/utils/localStoragePersistence.js

@@ -64,21 +64,31 @@ const emptyStored = () => ({
     threads: {},
     deleted: {},
 });
-function parseStored(raw) {
-    if (!raw)
-        return emptyStored();
+/** The record `raw` holds, or `null` when it is not one of this version. */
+function readStored(raw) {
     try {
         const parsed = JSON.parse(raw);
         if (parsed?.version !== PERSISTED_CHAT_VERSION || !parsed.threads)
-            return emptyStored();
+            return null;
         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();
+        return null;
     }
 }
+function parseStored(raw) {
+    return (raw && readStored(raw)) || emptyStored();
+}
+function dropExpired(data, cutoff) {
+    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 entryCount = (data) => Object.keys(data.threads).length + Object.keys(data.deleted ?? {}).length;
 function readItem(storage, key) {
     try {
         return storage.getItem(key);
@@ -87,6 +97,42 @@ function readItem(storage, key) {
         return null;
     }
 }
+/** How often a write is redone when another tab changed the key between its read and its write. */
+const MAX_COMMIT_ATTEMPTS = 3;
+/** Drops expired threads and tombstones under every namespace of `key`, other shoppers' included. */
+async function sweepExpired(storage, key, ttlMs) {
+    const prefix = storageKeyFor(key);
+    let keys;
+    try {
+        keys = Array.from({ length: storage.length }, (_, i) => storage.key(i)).filter((k) => k === prefix || Boolean(k?.startsWith(`${prefix}:`)));
+    }
+    catch {
+        return;
+    }
+    await Promise.all(keys.map((k) => withStorageLock(k, () => {
+        for (let attempt = 0; attempt < MAX_COMMIT_ATTEMPTS; attempt += 1) {
+            const raw = readItem(storage, k);
+            const stored = raw === null ? null : readStored(raw);
+            if (!stored)
+                return;
+            const kept = dropExpired(stored, Date.now() - ttlMs);
+            if (entryCount(kept) === entryCount(stored))
+                return;
+            if (readItem(storage, k) === raw) {
+                try {
+                    if (entryCount(kept) === 0)
+                        storage.removeItem(k);
+                    else
+                        storage.setItem(k, JSON.stringify(kept));
+                }
+                catch {
+                    /* storage unavailable */
+                }
+                return;
+            }
+        }
+    })));
+}
 /**
  * Deletes every stored conversation of one shopper, or of the guest without `userId`; open tabs
  * follow. Resolves once the deletion is recorded.
@@ -132,6 +178,23 @@ export async function clearPersistedConversations(options) {
         /* a non-Storage `storage` option cannot be attached to the event */
     }
 }
+/** The channel abort requests travel on between tabs, or `null` where none can be opened. */
+function openAbortChannel(name, onRequest) {
+    if (typeof window === 'undefined' || typeof BroadcastChannel === 'undefined')
+        return null;
+    try {
+        const channel = new BroadcastChannel(name);
+        channel.onmessage = ({ data }) => {
+            if (typeof data?.threadId !== 'string' || typeof data?.messageId !== 'string')
+                return;
+            onRequest({ threadId: data.threadId, messageId: data.messageId });
+        };
+        return channel;
+    }
+    catch {
+        return null;
+    }
+}
 /** 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;
@@ -144,15 +207,20 @@ export function createLocalStoragePersistence(options = {}) {
             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)),
-        };
+        return dropExpired(lastParsed.data, Date.now() - ttlMs);
+    };
+    // Other shoppers' records expire only here: their own store may never run again on this device.
+    let swept = false;
+    const sweepOnce = () => {
+        if (swept)
+            return;
+        swept = true;
+        const local = resolveStorage(storageOption, 'local');
+        if (local)
+            sweepExpired(local, key, ttlMs).catch(() => { });
     };
     const read = () => {
+        sweepOnce();
         const storage = resolveStorage(storageOption, storageArea);
         return parse(storage ? readRaw(storage) : null);
     };
@@ -174,7 +242,7 @@ export function createLocalStoragePersistence(options = {}) {
             /* ignore */
         }
     };
-    const isEmpty = (data) => Object.keys(data.threads).length === 0 && Object.keys(data.deleted ?? {}).length === 0;
+    const isEmpty = (data) => entryCount(data) === 0;
     // Retries without tombstones, oldest first: the last thing to shed, see `write`.
     const tryWriteShedding = (storage, data) => {
         if (tryWrite(storage, data))
@@ -238,8 +306,8 @@ export function createLocalStoragePersistence(options = {}) {
             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) => {
+        sweepOnce();
         const storage = resolveStorage(storageOption, storageArea);
         if (!storage)
             return;
@@ -297,6 +365,29 @@ export function createLocalStoragePersistence(options = {}) {
         }
         return next;
     };
+    const abortListeners = new Set();
+    // Only `localStorage` is shared between tabs; a guest's `sessionStorage` thread streams in this tab alone.
+    const channel = storageArea === 'local'
+        ? openAbortChannel(`${storageKey}:abort`, (request) => abortListeners.forEach((listener) => listener(request)))
+        : null;
+    const abortMethods = channel
+        ? {
+            requestAbort(threadId, messageId) {
+                try {
+                    channel.postMessage({ threadId, messageId });
+                }
+                catch {
+                    /* channel closed */
+                }
+            },
+            subscribeAbort(listener) {
+                abortListeners.add(listener);
+                return () => {
+                    abortListeners.delete(listener);
+                };
+            },
+        }
+        : {};
     const retire = (data, staleId) => {
         const { [staleId]: retired, ...threads } = data.threads;
         return { ...data, threads, deleted: { ...data.deleted, [staleId]: Date.now() } };
@@ -352,6 +443,7 @@ export function createLocalStoragePersistence(options = {}) {
             window.addEventListener('storage', onStorage);
             return () => window.removeEventListener('storage', onStorage);
         },
+        ...abortMethods,
     };
 }
 const sharedStores = new Map();

package/lib/mjs/utils/markdown.js

@@ -0,0 +1,53 @@
+import DOMPurify from 'dompurify';
+import { marked } from 'marked';
+// The text comes from an LLM a shopper can steer, so only the tags `marked` outputs are kept.
+// Images, media and SVG would load a URL with no click and could leak data; form controls and
+// `style` could fake a form.
+const purifyConfig = {
+    ALLOWED_TAGS: 'p br strong em del a ul ol li blockquote hr code pre table thead tbody tr th td h1 h2 h3 h4 h5 h6'.split(' '),
+    ALLOWED_ATTR: ['href', 'tabindex', 'align', 'start'],
+};
+// Text the agent reads (catalog, knowledge base, reviews) could plant a phishing link, so only
+// links to this site, its subdomains, email and phone stay clickable.
+function isOnThisSite(href) {
+    try {
+        const url = new URL(href, window.location.href);
+        if (url.protocol === 'mailto:' || url.protocol === 'tel:')
+            return true;
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return false;
+        const site = window.location.hostname.replace(/^www\./, '');
+        return url.hostname === site || url.hostname.endsWith(`.${site}`);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Turns the agent's markdown into sanitized HTML: paragraphs, bold, links, lists and tables.
+ * Links to other sites become plain text. Browser only: without a DOM to sanitize with (server
+ * rendering) it returns `''`, so render the plain text instead.
+ */
+export function renderMarkdown(markdown) {
+    if (!markdown || !DOMPurify.isSupported)
+        return '';
+    const html = marked.parse(markdown, { async: false, breaks: true })
+        // A wide table scrolls (AiMessage.css), so keyboard users need to be able to focus it.
+        .replace(/<table>/g, '<table tabindex="0">');
+    const doc = new DOMParser().parseFromString(DOMPurify.sanitize(html, purifyConfig), 'text/html');
+    doc.querySelectorAll('a[href]').forEach((link) => {
+        if (!isOnThisSite(link.getAttribute('href')))
+            link.replaceWith(...Array.from(link.childNodes));
+    });
+    return doc.body.innerHTML;
+}
+/** The agent's markdown as plain text, one space between blocks and table cells, for screen readers. */
+export function markdownToText(markdown) {
+    const html = renderMarkdown(markdown);
+    if (!html)
+        return markdown;
+    // An inert document: nothing in it loads or runs.
+    const { body } = new DOMParser().parseFromString(html, 'text/html');
+    body.querySelectorAll('p, li, th, td, br').forEach((node) => node.append(' '));
+    return (body.textContent ?? '').replace(/\s+/g, ' ').trim();
+}

package/lib/mjs/version.js

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

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

@@ -1,5 +1,6 @@
 import React from 'react';
-export interface ButtonProps {
+import { AgentButtonClickPlacement } from '../../types';
+export interface ButtonProps extends AgentButtonClickPlacement {
     /** Color scheme: dark (for light backgrounds) or light (for dark backgrounds) */
     theme?: 'dark' | 'light';
     /** Button size: sm (small) or lg (large) */
@@ -9,4 +10,4 @@ export interface ButtonProps {
     /** Button label text */
     label?: string;
 }
-export default function Button({ theme, size, onClick, label, }: ButtonProps): React.JSX.Element;
+export default function Button({ theme, size, onClick, label, positionOnPage, pageType, instanceId, }: ButtonProps): React.JSX.Element;

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { ChatComponentOverrides, ResultGroupMeta, ThreadSummary, Translations } from '../../types';
+import { ChatComponentOverrides, ResultGroupMeta, SendMessageOptions, ThreadSummary, Translations } from '../../types';
 import { Product, NormalizeOptions } from '../../utils/productNormalizer';
 import { AspectRatio } from '../ResultsBlock/ResultsBlock';
 export interface ChatHandle {
@@ -15,6 +15,12 @@ export interface ChatHandle {
     newThread: () => void;
     /** Load a stored conversation. No-op when persistence is off. */
     switchThread: (threadId: string) => Promise<void>;
+    /**
+     * Send a prompt from outside the chat, e.g. one the shopper clicked elsewhere on the page.
+     * Pass `threadId` to send it into that conversation instead of the one on screen. Skipped
+     * while an answer is streaming. Opening the chat stays with you, as with `onClose`.
+     */
+    sendMessage: (text: string, options?: SendMessageOptions) => void;
 }
 export interface ChatProps {
     /** Called when the close button (✕) is clicked. The consumer controls visibility. */
@@ -46,6 +52,12 @@ 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;
+    /**
+     * A prompt sent once on mount, after any stored conversation loads, e.g. one the shopper
+     * clicked elsewhere before you opened the chat. Goes into `initialThreadId` when set.
+     * Read once on mount; use `sendMessage` on the ref once the chat is already open.
+     */
+    initialPrompt?: string;
     /** Fires with the stored conversations and the active one whenever either changes. Requires persistence. */
     onThreadsChange?: (threads: ThreadSummary[], activeThreadId: string | null) => void;
     /**

package/lib/types/hooks/persistence/backgroundTurns.d.ts

@@ -15,6 +15,7 @@ export declare class BackgroundTurn {
     readonly ids: Set<string>;
     /** Its writes, in order; a chat that takes the turn back writes after them. */
     writes: Promise<void>;
+    private stopListening?;
     constructor(turn: LiveTurn, params: {
         store: ChatPersistence;
         session: ChatSession;
@@ -24,6 +25,11 @@ export declare class BackgroundTurn {
     save(): Promise<void>;
     /** Later writes go into `store`. */
     moveTo(store: ChatPersistence): void;
+    /** Stops the answer when another tab asks to, through the store it is saved into. */
+    listen(): void;
+    release(): void;
+    /** Stops the answer and stores it settled, as the stop button does on screen. */
+    abort(): void;
     /** Stores the conversation settled, without awaiting: the page is going away. */
     flush(): void;
 }

package/lib/types/hooks/persistence/useChatPersistence.d.ts

@@ -18,6 +18,8 @@ interface Params {
     turnRef: MutableRefObject<LiveTurn | null>;
     /** Stop the answer currently streaming in this tab, if any. */
     cancelStream: () => void;
+    /** Stop this tab's answer as the stop button does: settled and stored. */
+    abortTurn: () => void;
 }
 /** Restores, saves and syncs the conversation with `store`; inert when `store` is undefined. */
 export default function useChatPersistence(params: Params): {
@@ -25,6 +27,8 @@ export default function useChatPersistence(params: Params): {
     threads: import("../../types").ThreadSummary[];
     activeThreadId: string | null;
     foreignInFlight: boolean;
+    canAbortForeign: boolean;
+    abortForeign: () => void;
     beginTurn: () => void;
     screenOwner: (turn: LiveTurn) => TurnOwner;
     clearHistory: () => void;

package/lib/types/hooks/useAsaTracking.d.ts

@@ -1,5 +1,5 @@
 import { Tracker } from '@constructor-io/constructorio-client-javascript/lib/types/constructorio';
-import { AssistantTrackedItem } from '../types';
+import { AgentButtonClickPayload, AssistantSubmitSource, AssistantTrackedItem } from '../types';
 export interface UseAsaTrackingProps {
     tracker?: Tracker;
     section?: string;
@@ -40,8 +40,10 @@ export interface TrackSearchSubmitArgs {
     intentResultId?: string;
     groupId?: string;
 }
+export type TrackAgentButtonClickArgs = AgentButtonClickPayload;
 export interface UseAsaTrackingReturn {
-    trackSubmit: (intent: string) => void;
+    trackAgentButtonClick: (args: TrackAgentButtonClickArgs) => void;
+    trackSubmit: (intent: string, source?: AssistantSubmitSource) => void;
     trackResultLoadStarted: (args: TrackResultLoadStartedArgs) => void;
     trackResultLoadFinished: (args: TrackResultLoadFinishedArgs) => void;
     trackResultClick: (args: TrackResultClickArgs) => void;

package/lib/types/index.d.ts

@@ -10,9 +10,10 @@ export type { ButtonProps } from './components/Button/Button';
 export { default as useAsaResults } from './hooks/useAsaResults';
 export { default as useAsaTracking } from './hooks/useAsaTracking';
 export { default as useCioAsaContext } from './hooks/useCioAsaContext';
-export type { UseAsaTrackingProps, UseAsaTrackingReturn } from './hooks/useAsaTracking';
+export type { UseAsaTrackingProps, UseAsaTrackingReturn, TrackAgentButtonClickArgs, } from './hooks/useAsaTracking';
 export { normalizeItemToProduct } from './utils/productNormalizer';
 export { clearPersistedConversations } from './utils/localStoragePersistence';
+export { renderMarkdown } from './utils/markdown';
 export type { Product, NormalizeOptions } from './utils/productNormalizer';
 export { ConstructorIOClient } from './types';
-export type { Nullable, CioAsaProviderProps, PersistConversationOptions, AsaContextValue, CioClientOptions, RequestConfigs, Formatters, UrlHelpers, QueryParamEncodingOptions, DefaultQueryStringMap, Translations, ChatMessage, ChatMessageStatus, FollowUpRefinement, ResultGroup, ResultGroupMeta, SearchResultEventRequest, UseAsaResultsOptions, UseChatReturn, ClearPersistedConversationsOptions, ThreadSummary, AsaCallbacks, AssistantSubmitSource, AssistantTrackedItem, ChatComponentOverrides, WelcomeScreenOverrides, ChatInputOverrides, AiMessageOverrides, ResultsBlockOverrides, ComponentOverrideProps, IncludeComponentOverrides, ChatHeaderRenderProps, ChatInputRenderProps, WelcomeScreenTitleRenderProps, WelcomeScreenInputRenderProps, SuggestedQuestionsRenderProps, UserMessageRenderProps, AiMessageLoaderRenderProps, AiMessageTextRenderProps, FollowUpRefinementRenderProps, ResultsGroupTitleRenderProps, ResultsViewMoreRenderProps, } from './types';
+export type { Nullable, CioAsaProviderProps, PersistConversationOptions, AsaContextValue, CioClientOptions, RequestConfigs, Formatters, UrlHelpers, QueryParamEncodingOptions, DefaultQueryStringMap, Translations, ChatMessage, ChatMessageStatus, FollowUpRefinement, ResultGroup, ResultGroupMeta, SearchResultEventRequest, UseAsaResultsOptions, UseChatReturn, SendMessageOptions, ClearPersistedConversationsOptions, ThreadSummary, AsaCallbacks, AssistantSubmitSource, AssistantTrackedItem, AgentButtonClickMode, AgentButtonClickPayload, AgentButtonClickPageType, AgentButtonClickPlacement, ChatComponentOverrides, WelcomeScreenOverrides, ChatInputOverrides, AiMessageOverrides, ResultsBlockOverrides, ComponentOverrideProps, IncludeComponentOverrides, ChatHeaderRenderProps, ChatInputRenderProps, WelcomeScreenTitleRenderProps, WelcomeScreenInputRenderProps, SuggestedQuestionsRenderProps, UserMessageRenderProps, AiMessageLoaderRenderProps, AiMessageTextRenderProps, FollowUpRefinementRenderProps, ResultsGroupTitleRenderProps, ResultsViewMoreRenderProps, } from './types';