@xapp/chat-widget 1.86.0 → 1.87.1

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import require$$1, { useCallback, useState, useRef, useEffect, createContext, useContext, useMemo, memo, useLayoutEffect } from 'react';
+import require$$1, { useCallback, useState, useEffect, useRef, createContext, useMemo, useContext, memo, useLayoutEffect } from 'react';
 export { default as React } from 'react';
 import require$$0, { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { useSelector, useDispatch, Provider } from 'react-redux';
@@ -13,7 +13,6 @@ var lib = {};
 
 var ActionBar$1 = {};
 
-/*! Copyright (c) 2021, XAPPmedia */
 Object.defineProperty(ActionBar$1, "__esModule", { value: true });
 ActionBar$1.isActionBarChatButton = isActionBarChatButton;
 ActionBar$1.isActionBarFormButton = isActionBarFormButton;
@@ -304,12 +303,103 @@ var ActionBarButton = function (_a) {
     return (jsxs("button", { className: buttonClassName, onClick: handleClick, "aria-label": ariaLabel, "aria-pressed": isActive, tabIndex: tabIndex, children: [jsx(ActionBarIcon, { type: button.type, icon: button.icon, iconUrl: button.iconUrl, className: "xapp-action-bar__icon" }), button.label && (jsx("span", { className: "xapp-action-bar__label", children: button.label }))] }));
 };
 
+/**
+ * CTA banner for ActionBar - a full-width rectangular banner that appears
+ * above the action bar to prompt users to engage with chat.
+ */
+var ActionBarCta = function (_a) {
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    var config = _a.config, isMobile = _a.isMobile, onClick = _a.onClick, onDismiss = _a.onDismiss, hasUserInteracted = _a.hasUserInteracted;
+    var _m = useState(false), isVisible = _m[0], setIsVisible = _m[1];
+    var _o = useState(false), isAnimating = _o[0], setIsAnimating = _o[1];
+    var _p = useState(false), isDismissed = _p[0], setIsDismissed = _p[1];
+    // For mobile overrides: null means "explicitly disabled", undefined means "use desktop default"
+    var mobileMessage = isMobile ? (_b = config.mobile) === null || _b === void 0 ? void 0 : _b.message : undefined;
+    var message = mobileMessage !== undefined ? mobileMessage : config.message;
+    var delay = isMobile && ((_c = config.mobile) === null || _c === void 0 ? void 0 : _c.delay) !== undefined ? config.mobile.delay : ((_d = config.delay) !== null && _d !== void 0 ? _d : 0);
+    var mobileTimeout = isMobile ? (_e = config.mobile) === null || _e === void 0 ? void 0 : _e.timeout : undefined;
+    var timeout = mobileTimeout !== undefined ? mobileTimeout : config.timeout;
+    var mobileAnimation = isMobile ? (_f = config.mobile) === null || _f === void 0 ? void 0 : _f.animation : undefined;
+    var animation = mobileAnimation !== undefined ? mobileAnimation : config.animation;
+    var animationDelay = isMobile && ((_g = config.mobile) === null || _g === void 0 ? void 0 : _g.animationDelay) !== undefined
+        ? config.mobile.animationDelay
+        : ((_h = config.animationDelay) !== null && _h !== void 0 ? _h : delay);
+    var animationTimeout = isMobile && ((_j = config.mobile) === null || _j === void 0 ? void 0 : _j.animationTimeout) !== undefined
+        ? config.mobile.animationTimeout
+        : config.animationTimeout;
+    var dismissible = isMobile && ((_k = config.mobile) === null || _k === void 0 ? void 0 : _k.dismissible) !== undefined
+        ? config.mobile.dismissible
+        : ((_l = config.dismissible) !== null && _l !== void 0 ? _l : true);
+    // Show CTA after delay
+    useEffect(function () {
+        if (!message || hasUserInteracted || isDismissed) {
+            setIsVisible(false);
+            return undefined;
+        }
+        var showTimer = setTimeout(function () {
+            setIsVisible(true);
+        }, delay);
+        return function () { return clearTimeout(showTimer); };
+    }, [message, delay, hasUserInteracted, isDismissed]);
+    // Hide CTA after timeout
+    useEffect(function () {
+        if (!isVisible || !timeout) {
+            return undefined;
+        }
+        var hideTimer = setTimeout(function () {
+            setIsVisible(false);
+        }, timeout);
+        return function () { return clearTimeout(hideTimer); };
+    }, [isVisible, timeout]);
+    // Start animation after animationDelay
+    useEffect(function () {
+        if (!animation || hasUserInteracted || isDismissed) {
+            setIsAnimating(false);
+            return undefined;
+        }
+        var animateTimer = setTimeout(function () {
+            setIsAnimating(true);
+        }, animationDelay);
+        return function () { return clearTimeout(animateTimer); };
+    }, [animation, animationDelay, hasUserInteracted, isDismissed]);
+    // Stop animation after animationTimeout
+    useEffect(function () {
+        if (!isAnimating || !animationTimeout) {
+            return undefined;
+        }
+        var stopTimer = setTimeout(function () {
+            setIsAnimating(false);
+        }, animationTimeout);
+        return function () { return clearTimeout(stopTimer); };
+    }, [isAnimating, animationTimeout]);
+    var handleClick = function () {
+        onClick();
+        setIsVisible(false);
+    };
+    var handleDismiss = function (e) {
+        e.stopPropagation();
+        setIsDismissed(true);
+        setIsVisible(false);
+        onDismiss();
+    };
+    if (!isVisible || !message) {
+        return null;
+    }
+    var animationClass = isAnimating && animation ? "xapp-action-bar-cta--".concat(animation) : "";
+    return (jsxs("div", { className: "xapp-action-bar-cta ".concat(animationClass), onClick: handleClick, role: "button", tabIndex: 0, "aria-label": message, onKeyDown: function (e) {
+            if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                handleClick();
+            }
+        }, children: [jsx("span", { className: "xapp-action-bar-cta__message", children: message }), dismissible && (jsx("button", { className: "xapp-action-bar-cta__dismiss", onClick: handleDismiss, "aria-label": "Dismiss", type: "button", children: jsx("svg", { width: "14", height: "14", viewBox: "0 0 14 14", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: jsx("path", { d: "M13 1L1 13M1 1L13 13", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }) }) }))] }));
+};
+
 var DEFAULT_MOBILE_BREAKPOINT = 768;
 var RESIZE_DEBOUNCE_MS = 150;
 var ActionBar = function (_a) {
-    var _b, _c;
-    var config = _a.config, visible = _a.visible, chatDisabled = _a.chatDisabled, onChatClick = _a.onChatClick, onChatMinimize = _a.onChatMinimize, onFormClick = _a.onFormClick;
-    var _d = useState(false), isMobile = _d[0], setIsMobile = _d[1];
+    var _b, _c, _d;
+    var config = _a.config, visible = _a.visible, chatDisabled = _a.chatDisabled, _e = _a.hasUserInteracted, hasUserInteracted = _e === void 0 ? false : _e, onChatClick = _a.onChatClick, onChatMinimize = _a.onChatMinimize, onFormClick = _a.onFormClick, onCtaDismiss = _a.onCtaDismiss;
+    var _f = useState(false), isMobile = _f[0], setIsMobile = _f[1];
     var mobileBreakpoint = (_b = config.mobileBreakpoint) !== null && _b !== void 0 ? _b : DEFAULT_MOBILE_BREAKPOINT;
     var position = (_c = config.position) !== null && _c !== void 0 ? _c : "right";
     var resizeTimeoutRef = useRef(null);
@@ -345,7 +435,19 @@ var ActionBar = function (_a) {
     ]
         .filter(Boolean)
         .join(" ");
-    return (jsx("div", { className: classNames, role: "toolbar", "aria-label": "Chat actions", children: filteredButtons.map(function (button) { return (jsx(ActionBarButton, { button: button, chatActive: visible, onChatClick: onChatClick, onChatMinimize: onChatMinimize, onFormClick: onFormClick, isMobile: isMobile }, button.id)); }) }));
+    // Determine if CTA should be shown:
+    // - Must have CTA config with a message
+    // - Chat must not be visible (user hasn't opened it)
+    // - Chat must not be disabled
+    var hasChatButton = config.buttons.some(lib.isActionBarChatButton);
+    var showCta = ((_d = config.cta) === null || _d === void 0 ? void 0 : _d.message) && !visible && !chatDisabled && hasChatButton;
+    var handleCtaClick = function () {
+        onChatClick();
+    };
+    var handleCtaDismiss = function () {
+        onCtaDismiss === null || onCtaDismiss === void 0 ? void 0 : onCtaDismiss();
+    };
+    return (jsxs("div", { className: classNames, role: "toolbar", "aria-label": "Chat actions", children: [showCta && (jsx("div", { className: "xapp-action-bar-cta-wrapper", children: jsx(ActionBarCta, { config: config.cta, isMobile: isMobile, onClick: handleCtaClick, onDismiss: handleCtaDismiss, hasUserInteracted: hasUserInteracted }) })), jsx("div", { className: "xapp-action-bar__buttons", children: filteredButtons.map(function (button) { return (jsx(ActionBarButton, { button: button, chatActive: visible, onChatClick: onChatClick, onChatMinimize: onChatMinimize, onFormClick: onFormClick, isMobile: isMobile }, button.id)); }) })] }));
 };
 
 /**
@@ -978,14 +1080,16 @@ function getServerConfig(env) {
 }
 function useServerConfig(env, nonce) {
     var connection = getServerConfig(env);
-    var accountKey = connection.accountKey, serverUrl = connection.serverUrl, type = connection.type, timeout = connection.timeout;
+    var accountKey = connection.accountKey, serverUrl = connection.serverUrl, type = connection.type, timeout = connection.timeout, backgroundSleepDelay = connection.backgroundSleepDelay, mcp = connection.mcp;
     return useMemo(function () { return ({
         accountKey: accountKey,
         serverUrl: serverUrl,
         timeout: timeout,
         type: type,
         nonce: nonce,
-    }); }, [accountKey, serverUrl, timeout, type, nonce]);
+        backgroundSleepDelay: backgroundSleepDelay,
+        mcp: mcp,
+    }); }, [accountKey, serverUrl, timeout, type, nonce, backgroundSleepDelay, mcp]);
 }
 function useConnectionInfo(env) {
     var nonce = useSelector(function (state) { return state.connection.nonce; });
@@ -994,7 +1098,7 @@ function useConnectionInfo(env) {
 }
 
 var Avatar = function (props) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e;
     var style = {};
     var child;
     var entity = props.entity;
@@ -1017,7 +1121,9 @@ var Avatar = function (props) {
         child = getVisitorSvg();
     }
     var hasImage = !!style.backgroundImage || !!child;
-    return (jsx("div", { className: "avatar ".concat(agentAva ? "avatar--agent" : "avatar--visitor", " ").concat(!hasImage ? "avatar--empty" : ""), style: style, title: entity ? entity.display_name : "Agent", children: child }));
+    // Show AI badge if configured and the entity is an AI
+    var showAiBadge = ((_e = (_d = (_c = chatConfig === null || chatConfig === void 0 ? void 0 : chatConfig.env) === null || _c === void 0 ? void 0 : _c.connection) === null || _d === void 0 ? void 0 : _d.mcp) === null || _e === void 0 ? void 0 : _e.showAiBadge) && (entity === null || entity === void 0 ? void 0 : entity.isAI);
+    return (jsxs("div", { className: "avatar ".concat(agentAva ? "avatar--agent" : "avatar--visitor", " ").concat(!hasImage ? "avatar--empty" : ""), style: style, title: entity ? entity.display_name : "Agent", children: [child, showAiBadge && jsx("span", { className: "avatar__ai-badge", children: "AI" })] }));
 };
 /**
  * Generates an SVG based on the
@@ -1677,14 +1783,14 @@ function useOpenUrlCallback() {
     }, [env]);
 }
 
-function writeMessage(msg, user) {
+function writeMessage(msg, user, timestamp) {
     return {
         type: "synthetic",
         detail: {
             type: "write_msg",
             user: user,
             msg: msg,
-            timestamp: +new Date()
+            timestamp: timestamp !== undefined ? timestamp : +new Date()
         }
     };
 }
@@ -1696,16 +1802,19 @@ function executeAction(text, meta) {
         attributes = __assign(__assign({}, attributes), { currentUrl: window.location.href });
         var _a = meta || {}, token = _a.token, rest = __rest(_a, ["token"]);
         attributes = __assign(__assign({}, attributes), rest);
+        // Add user message to Redux BEFORE sending to server
+        // to ensure it appears above the bot's streaming response
+        var visitor = getState().visitor;
+        var userMsgTimestamp = +new Date();
+        dispatch(writeMessage({
+            text: !token ? text : "".concat(text, " (from the list)"),
+        }, visitor, userMsgTimestamp));
         chatServer.sendChatMsg({ text: text, token: token, attributes: attributes }, function (err) {
             if (err) {
                 log("Error sending message", err);
                 return;
             }
         });
-        var visitor = getState().visitor;
-        dispatch(writeMessage({
-            text: !token ? text : "".concat(text, " (from the list)"),
-        }, visitor));
     }; };
 }
 
@@ -2602,236 +2711,231 @@ var parseSuggestionsResponse_1 = parseSuggestionsResponse;
 var useSuggestionsFetch_1 = useSuggestionsFetch$1;
 var uuid_1 = uuid;
 
-/**
- * Sends a POST to your STENTOR based server.
- *
- * @param data
- * @param url
- * @param key
- * @param signal
- * @returns
- */
-function postMessageToStentor(data, url, key, signal) {
-    return __awaiter$1(this, void 0, void 0, function () {
-        var body, response;
-        return __generator$1(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    body = JSON.stringify(data);
-                    log("URL: ".concat(url));
-                    log("BODY: ".concat(body));
-                    return [4 /*yield*/, fetch(url, {
-                            method: "POST",
-                            headers: {
-                                "Content-Type": "application/json",
-                                "Authorization": "Bearer ".concat(key),
-                            },
-                            body: body,
-                            mode: "cors",
-                            signal: signal
-                        })];
-                case 1:
-                    response = _a.sent();
-                    if (!response.ok) {
-                        throw new Error("Status ".concat(response.status, ", Text: ").concat(response.statusText));
-                    }
-                    return [2 /*return*/, response.json()];
-            }
-        });
-    });
-}
+var cjs = {};
 
-function convertFromListDisplay(list) {
-    return {
-        type: list.type,
-        title: list.title,
-        items: list.items.map(function (item) {
-            var _a, _b;
-            var responseItem = {
-                title: item.title,
-                subTitle: item.description,
-                token: item.token,
-                url: item.url,
-                hideUrl: item.hideUrl,
-                imageUrl: (_a = item.image) === null || _a === void 0 ? void 0 : _a.url,
-                imageActionUrl: (_b = item.image) === null || _b === void 0 ? void 0 : _b.imageActionUrl
-            };
-            // TODO: Remove any when the buttons are defined on the list (ListButton - title + openUrlAction)
-            var itemButtons = item.buttons;
-            if (itemButtons && itemButtons.length > 0) {
-                responseItem.buttons = itemButtons.map(function (button) { return ({
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    actionUrl: button.openUrlAction,
-                    label: button.title
-                }); });
-            }
-            return responseItem;
-        })
-    };
-}
-function convertToListDisplay(list) {
-    return {
-        type: list.type,
-        title: list.title,
-        items: (list.items || []).map(function (item) {
-            var responseItem = {
-                title: item.title,
-                description: item.subTitle,
-                token: item.token,
-                url: item.url,
-                hideUrl: item.hideUrl,
-                image: {
-                    url: item.imageUrl,
-                    imageActionUrl: item.imageActionUrl,
-                    accessibilityText: ""
-                }
-            };
-            // TODO: Remove any when the buttons are defined on the list (ListButton - title + openUrlAction)
-            var itemButtons = item.buttons;
-            if (itemButtons && itemButtons.length > 0) {
-                responseItem.buttons = itemButtons.map(function (button) { return ({
-                    openUrlAction: button.actionUrl,
-                    title: button.label
-                }); });
-            }
-            return responseItem;
-        })
-    };
-}
-function convertFromCardDisplay(card) {
-    return {
-        content: card.content,
-        imageUrl: card.smallImageUrl,
-        title: card.title,
-        imageActionUrl: card === null || card === void 0 ? void 0 : card.imageActionUrl,
-        buttons: card.buttons ? card.buttons.map(function (button) { return ({
-            actionUrl: button.openUrlAction,
-            label: button.title
-        }); }) : undefined
-    };
-}
-function getOutput(value) {
-    if (value) {
-        if (typeof value === "string") {
-            return {
-                displayText: value
-            };
-        }
-        else {
-            return value;
-        }
-    }
-    return undefined;
-}
-/**
- * Converts a Stentor Response to a ChatMessageRequest
- *
- * @param botResponse
- * @param now
- * @returns
- */
-function responseToMessage(botResponse, now) {
-    var _a, _b, _c, _d, _e;
-    if (now === void 0) { now = new Date().getTime(); }
-    var responseMessage;
-    if (!botResponse) {
-        return responseMessage;
-    }
-    var text;
-    var html;
-    var endSession;
-    var outputSpeech = getOutput(botResponse.outputSpeech);
-    var reprompt = getOutput(botResponse.reprompt);
-    if (outputSpeech) {
-        text = outputSpeech.displayText;
-        html = outputSpeech.html;
-    }
-    if (botResponse.system === "TRANSFER_CALL") {
-        responseMessage = {
-            type: "handOff",
-            timestamp: now,
-            handoffMessage: text,
-            handoffTarget: (_a = botResponse === null || botResponse === void 0 ? void 0 : botResponse.data) === null || _a === void 0 ? void 0 : _a.transferPhoneNumber,
-            endSession: false,
-            user: undefined
-        };
-    }
-    else if ((_b = botResponse.system) === null || _b === void 0 ? void 0 : _b.startsWith("PERMISSION_")) {
-        responseMessage = getPermissionResponse(botResponse, now);
-    }
-    else {
-        endSession = !reprompt || !(reprompt.displayText || reprompt.ssml);
-        responseMessage = {
-            type: "msg",
-            timestamp: now,
-            msg: {
-                displays: botResponse.displays,
-                context: (_d = (_c = botResponse.context) === null || _c === void 0 ? void 0 : _c.active) === null || _d === void 0 ? void 0 : _d.map(function (ctx) { return ctx.name; })
-            },
-            endSession: endSession,
-            user: undefined
-        };
-        if (text && !html) {
-            responseMessage.msg = __assign(__assign({}, responseMessage.msg), { text: text });
-        }
-        if (html) {
-            responseMessage.msg = __assign(__assign({}, responseMessage.msg), { html: html });
-        }
-        if ((_e = outputSpeech === null || outputSpeech === void 0 ? void 0 : outputSpeech.suggestions) === null || _e === void 0 ? void 0 : _e.length) {
-            responseMessage.msg.options = outputSpeech.suggestions.map(function (suggestion) {
-                if (typeof suggestion === "string") {
-                    // Simple chips (strings)
-                    return suggestion;
-                }
-                else {
-                    // "call out" chips
-                    return {
-                        label: suggestion.title,
-                        actionUrl: suggestion.url
-                    };
-                }
-            });
-        }
-    }
-    return responseMessage;
-}
-function getPermissionRequestType(type) {
-    switch (type) {
-        case "PERMISSION_EMAIL":
-            return "EMAIL";
-        case "PERMISSION_LOCATION_PRECISE":
-            return "LOCATION_PRECISE";
-        default:
-            throw new Error("Unsupported permission: ".concat(type));
-    }
-}
-function getPermissionResponse(botResponse, now) {
-    var _a;
-    var type = getPermissionRequestType(botResponse.system);
-    var outputSpeech = getOutput(botResponse.outputSpeech);
-    var permissionPrimerAccepted = botResponse.data.permissionPrimerAccepted;
-    var permissionDenied = botResponse.data.permissionDenied;
-    return {
-        type: "permissionRequest",
-        timestamp: now,
-        msg: {
-            text: (_a = outputSpeech === null || outputSpeech === void 0 ? void 0 : outputSpeech.displayText) !== null && _a !== void 0 ? _a : "".concat(botResponse.data.permissionRequestTTSContext),
-            permissionRequest: {
-                time: now,
-                type: type,
-                approve: typeof permissionPrimerAccepted === "object" ? responseToMessage({
-                    outputSpeech: permissionPrimerAccepted
-                }).msg : undefined,
-                deny: typeof permissionDenied === "object" ? responseToMessage({
-                    outputSpeech: permissionDenied
-                }).msg : undefined
-            }
-        },
-        endSession: false,
-        user: undefined //todo: set
-    };
+var fetch$1 = {};
+
+var parse$3 = {};
+
+Object.defineProperty(parse$3, "__esModule", { value: true });
+parse$3.getMessages = parse$3.getLines = parse$3.getBytes = void 0;
+async function getBytes(stream, onChunk) {
+    const reader = stream.getReader();
+    let result;
+    while (!(result = await reader.read()).done) {
+        onChunk(result.value);
+    }
+}
+parse$3.getBytes = getBytes;
+function getLines(onLine) {
+    let buffer;
+    let position;
+    let fieldLength;
+    let discardTrailingNewline = false;
+    return function onChunk(arr) {
+        if (buffer === undefined) {
+            buffer = arr;
+            position = 0;
+            fieldLength = -1;
+        }
+        else {
+            buffer = concat(buffer, arr);
+        }
+        const bufLength = buffer.length;
+        let lineStart = 0;
+        while (position < bufLength) {
+            if (discardTrailingNewline) {
+                if (buffer[position] === 10) {
+                    lineStart = ++position;
+                }
+                discardTrailingNewline = false;
+            }
+            let lineEnd = -1;
+            for (; position < bufLength && lineEnd === -1; ++position) {
+                switch (buffer[position]) {
+                    case 58:
+                        if (fieldLength === -1) {
+                            fieldLength = position - lineStart;
+                        }
+                        break;
+                    case 13:
+                        discardTrailingNewline = true;
+                    case 10:
+                        lineEnd = position;
+                        break;
+                }
+            }
+            if (lineEnd === -1) {
+                break;
+            }
+            onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+            lineStart = position;
+            fieldLength = -1;
+        }
+        if (lineStart === bufLength) {
+            buffer = undefined;
+        }
+        else if (lineStart !== 0) {
+            buffer = buffer.subarray(lineStart);
+            position -= lineStart;
+        }
+    };
+}
+parse$3.getLines = getLines;
+function getMessages(onId, onRetry, onMessage) {
+    let message = newMessage();
+    const decoder = new TextDecoder();
+    return function onLine(line, fieldLength) {
+        if (line.length === 0) {
+            onMessage === null || onMessage === void 0 ? void 0 : onMessage(message);
+            message = newMessage();
+        }
+        else if (fieldLength > 0) {
+            const field = decoder.decode(line.subarray(0, fieldLength));
+            const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
+            const value = decoder.decode(line.subarray(valueOffset));
+            switch (field) {
+                case 'data':
+                    message.data = message.data
+                        ? message.data + '\n' + value
+                        : value;
+                    break;
+                case 'event':
+                    message.event = value;
+                    break;
+                case 'id':
+                    onId(message.id = value);
+                    break;
+                case 'retry':
+                    const retry = parseInt(value, 10);
+                    if (!isNaN(retry)) {
+                        onRetry(message.retry = retry);
+                    }
+                    break;
+            }
+        }
+    };
+}
+parse$3.getMessages = getMessages;
+function concat(a, b) {
+    const res = new Uint8Array(a.length + b.length);
+    res.set(a);
+    res.set(b, a.length);
+    return res;
+}
+function newMessage() {
+    return {
+        data: '',
+        event: '',
+        id: '',
+        retry: undefined,
+    };
 }
 
+(function (exports$1) {
+	var __rest = (commonjsGlobal && commonjsGlobal.__rest) || function (s, e) {
+	    var t = {};
+	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+	        t[p] = s[p];
+	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+	                t[p[i]] = s[p[i]];
+	        }
+	    return t;
+	};
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.fetchEventSource = exports$1.EventStreamContentType = void 0;
+	const parse_1 = parse$3;
+	exports$1.EventStreamContentType = 'text/event-stream';
+	const DefaultRetryInterval = 1000;
+	const LastEventId = 'last-event-id';
+	function fetchEventSource(input, _a) {
+	    var { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, fetch: inputFetch } = _a, rest = __rest(_a, ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden", "fetch"]);
+	    return new Promise((resolve, reject) => {
+	        const headers = Object.assign({}, inputHeaders);
+	        if (!headers.accept) {
+	            headers.accept = exports$1.EventStreamContentType;
+	        }
+	        let curRequestController;
+	        function onVisibilityChange() {
+	            curRequestController.abort();
+	            if (!document.hidden) {
+	                create();
+	            }
+	        }
+	        if (!openWhenHidden) {
+	            document.addEventListener('visibilitychange', onVisibilityChange);
+	        }
+	        let retryInterval = DefaultRetryInterval;
+	        let retryTimer = 0;
+	        function dispose() {
+	            document.removeEventListener('visibilitychange', onVisibilityChange);
+	            window.clearTimeout(retryTimer);
+	            curRequestController.abort();
+	        }
+	        inputSignal === null || inputSignal === void 0 ? void 0 : inputSignal.addEventListener('abort', () => {
+	            dispose();
+	            resolve();
+	        });
+	        const fetch = inputFetch !== null && inputFetch !== void 0 ? inputFetch : window.fetch;
+	        const onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+	        async function create() {
+	            var _a;
+	            curRequestController = new AbortController();
+	            try {
+	                const response = await fetch(input, Object.assign(Object.assign({}, rest), { headers, signal: curRequestController.signal }));
+	                await onopen(response);
+	                await parse_1.getBytes(response.body, parse_1.getLines(parse_1.getMessages(id => {
+	                    if (id) {
+	                        headers[LastEventId] = id;
+	                    }
+	                    else {
+	                        delete headers[LastEventId];
+	                    }
+	                }, retry => {
+	                    retryInterval = retry;
+	                }, onmessage)));
+	                onclose === null || onclose === void 0 ? void 0 : onclose();
+	                dispose();
+	                resolve();
+	            }
+	            catch (err) {
+	                if (!curRequestController.signal.aborted) {
+	                    try {
+	                        const interval = (_a = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _a !== void 0 ? _a : retryInterval;
+	                        window.clearTimeout(retryTimer);
+	                        retryTimer = window.setTimeout(create, interval);
+	                    }
+	                    catch (innerErr) {
+	                        dispose();
+	                        reject(innerErr);
+	                    }
+	                }
+	            }
+	        }
+	        create();
+	    });
+	}
+	exports$1.fetchEventSource = fetchEventSource;
+	function defaultOnOpen(response) {
+	    const contentType = response.headers.get('content-type');
+	    if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith(exports$1.EventStreamContentType))) {
+	        throw new Error(`Expected content-type to be ${exports$1.EventStreamContentType}, Actual: ${contentType}`);
+	    }
+	}
+	
+} (fetch$1));
+
+(function (exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.EventStreamContentType = exports$1.fetchEventSource = void 0;
+	var fetch_1 = fetch$1;
+	Object.defineProperty(exports$1, "fetchEventSource", { enumerable: true, get: function () { return fetch_1.fetchEventSource; } });
+	Object.defineProperty(exports$1, "EventStreamContentType", { enumerable: true, get: function () { return fetch_1.EventStreamContentType; } });
+	
+} (cjs));
+
 /**
  * Default configuration messages
  * @returns
@@ -2878,6 +2982,1533 @@ function setSessionId(sessionId) {
     };
 }
 
+// Endpoint path constants
+var HOMEOWNER_ENDPOINT_PATH = "/chat/stream";
+var BUSINESS_OWNER_ENDPOINT_PATH = "/api/chat/stream";
+// Default retry configuration for MCP connections
+var DEFAULT_MCP_RETRY_CONFIG = [
+    { retry: 0, delay: 0, text: "" }, // Initial attempt (silent)
+    { retry: 1, delay: 3, text: "Having trouble connecting. Retrying in ${sec} seconds..." },
+    { retry: 2, delay: 5, text: "Still having trouble. Retrying in ${sec} seconds..." },
+    { retry: 0, delay: 0, text: "Unable to connect to the assistant. Please try again later." }, // Final failure
+];
+// Streaming throttle configuration
+// Average reading speed is ~250 words/min (~20 chars/sec). We go slightly faster.
+var STREAM_CHARS_PER_TICK = 3; // Characters to display per tick
+var STREAM_TICK_INTERVAL_MS = 30; // Milliseconds between ticks (~100 chars/sec)
+/**
+ * Storage keys for MCP session persistence.
+ * Uses localStorage directly (not Redux) for MCP-specific data.
+ */
+var MCP_STORAGE_KEYS = {
+    USER_ID: "xapp_mcp_userId",
+    SESSION_ID: "xapp_mcp_sessionId",
+};
+/**
+ * Gets the platform string, preferring the modern userAgentData API.
+ * Falls back to the deprecated navigator.platform for older browsers.
+ */
+function getPlatform() {
+    // Modern API (Chrome 90+, Edge 90+, Opera 76+)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    var userAgentData = navigator.userAgentData;
+    if (userAgentData === null || userAgentData === void 0 ? void 0 : userAgentData.platform) {
+        return userAgentData.platform;
+    }
+    // Fallback for older browsers (deprecated but widely supported)
+    return navigator.platform || undefined;
+}
+/**
+ * Collects non-invasive device/browser fingerprint data.
+ * This helps the server identify returning users without requiring login.
+ *
+ * PRIVACY NOTE: Only basic, non-identifying browser characteristics are collected.
+ * This data cannot be used to personally identify individual users.
+ */
+function getFingerprint() {
+    if (typeof window === "undefined") {
+        return {};
+    }
+    return {
+        userAgent: navigator.userAgent,
+        language: navigator.language,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        screenResolution: "".concat(window.screen.width, "x").concat(window.screen.height),
+        platform: getPlatform(),
+        colorDepth: window.screen.colorDepth,
+        touchSupport: "ontouchstart" in window || navigator.maxTouchPoints > 0,
+    };
+}
+/**
+ * Retrieves stored MCP identity from localStorage.
+ */
+function getStoredIdentity() {
+    if (typeof window === "undefined" || !window.localStorage) {
+        return {};
+    }
+    try {
+        return {
+            userId: localStorage.getItem(MCP_STORAGE_KEYS.USER_ID) || undefined,
+            sessionId: localStorage.getItem(MCP_STORAGE_KEYS.SESSION_ID) || undefined,
+        };
+    }
+    catch (_a) {
+        // localStorage may be unavailable (private browsing, etc.)
+        return {};
+    }
+}
+/**
+ * Stores MCP identity to localStorage.
+ */
+function storeIdentity(userId, sessionId) {
+    if (typeof window === "undefined" || !window.localStorage) {
+        return;
+    }
+    try {
+        if (userId) {
+            localStorage.setItem(MCP_STORAGE_KEYS.USER_ID, userId);
+        }
+        if (sessionId) {
+            localStorage.setItem(MCP_STORAGE_KEYS.SESSION_ID, sessionId);
+        }
+    }
+    catch (_a) {
+        // localStorage may be unavailable
+    }
+}
+/**
+ * Clears stored MCP session (but preserves userId for returning user identification).
+ * Optionally clears the stored lastSeq for the given sessionId.
+ */
+function clearStoredSession(sessionId) {
+    if (typeof window === "undefined" || !window.localStorage) {
+        return;
+    }
+    try {
+        localStorage.removeItem(MCP_STORAGE_KEYS.SESSION_ID);
+        if (sessionId) {
+            clearStoredLastSeq(sessionId);
+        }
+    }
+    catch (_a) {
+        // localStorage may be unavailable
+    }
+}
+/**
+ * Retrieves stored lastSeq from sessionStorage for replay on reconnect.
+ * Uses sessionStorage (not localStorage) because seq is ephemeral to the browser tab.
+ */
+function getStoredLastSeq(sessionId) {
+    if (typeof window === "undefined" || !window.sessionStorage) {
+        return undefined;
+    }
+    try {
+        var stored = sessionStorage.getItem("xapp_mcp_lastSeq_".concat(sessionId));
+        return stored ? parseInt(stored, 10) : undefined;
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/**
+ * Persists lastSeq to sessionStorage for replay on reconnect.
+ */
+function storeLastSeq(sessionId, seq) {
+    if (typeof window === "undefined" || !window.sessionStorage) {
+        return;
+    }
+    try {
+        sessionStorage.setItem("xapp_mcp_lastSeq_".concat(sessionId), String(seq));
+    }
+    catch (_a) {
+        // sessionStorage may be unavailable
+    }
+}
+/**
+ * Clears stored lastSeq from sessionStorage.
+ */
+function clearStoredLastSeq(sessionId) {
+    if (typeof window === "undefined" || !window.sessionStorage) {
+        return;
+    }
+    try {
+        sessionStorage.removeItem("xapp_mcp_lastSeq_".concat(sessionId));
+    }
+    catch (_a) {
+        // sessionStorage may be unavailable
+    }
+}
+/**
+ * Gets the current page context from browser globals.
+ * If an override is provided, uses that instead (useful for testing).
+ *
+ * PRIVACY NOTE: Query strings are stripped from URLs by default as they
+ * may contain sensitive data (tokens, PII). Only origin + pathname are sent.
+ */
+function getPageContext(override) {
+    var localTime = new Date().toISOString();
+    // If override provided, merge with defaults (override wins)
+    // Overrides are typically for testing and may include full URLs
+    if (override && Object.keys(override).length > 0) {
+        log("[getPageContext] Using override: ".concat(JSON.stringify(override)));
+        return {
+            url: override.url,
+            path: override.path,
+            title: override.title,
+            referrer: override.referrer,
+            localTime: localTime,
+        };
+    }
+    if (typeof window === "undefined") {
+        return { localTime: localTime };
+    }
+    // Strip query strings from URL for privacy (may contain tokens/PII)
+    var urlWithoutQuery = window.location.origin + window.location.pathname;
+    // Strip query strings from referrer as well
+    var referrerWithoutQuery;
+    if (document.referrer) {
+        try {
+            var refUrl = new URL(document.referrer);
+            referrerWithoutQuery = refUrl.origin + refUrl.pathname;
+        }
+        catch (_a) {
+            // Invalid referrer URL, skip it
+            referrerWithoutQuery = undefined;
+        }
+    }
+    return {
+        url: urlWithoutQuery,
+        path: window.location.pathname,
+        title: document.title || undefined,
+        referrer: referrerWithoutQuery,
+        localTime: localTime,
+    };
+}
+var MCPChat = /** @class */ (function () {
+    function MCPChat(config, options) {
+        this._userId = "";
+        this._sessionId = "";
+        this._accessToken = "";
+        this._attributes = {};
+        // Streaming throttle state
+        this.streamBuffer = "";
+        // New session initialization state
+        this.isInitializingSession = false;
+        // Session validation state (silent handshake - no stream dispatch)
+        this.isValidatingSession = false;
+        // Tool call tracking for debug mode
+        this.currentToolCalls = [];
+        // TODO: isReplaying and lastSeq are tracked for future replay support.
+        // Wire up replay requests in wakeup() once the server endpoint supports it.
+        this.isReplaying = false;
+        // True when userId was assigned by the server (via connected SSE event),
+        // meaning it should not be overwritten by the default client fingerprint.
+        this.userIdIsServerAssigned = false;
+        this.config = config;
+        this.options = options;
+        this.configurableMessages = options === null || options === void 0 ? void 0 : options.configurableMessages;
+        this.isNewSession = false;
+        this.hooks = options === null || options === void 0 ? void 0 : options.hooks;
+        // Validate business_owner mode requires authToken
+        var mode = config.mode || "homeowner";
+        if (mode === "business_owner" && !config.authToken) {
+            throw new Error("authToken is required for business_owner mode");
+        }
+        // Load stored identity from localStorage
+        var storedIdentity = getStoredIdentity();
+        if (storedIdentity.userId) {
+            this._userId = storedIdentity.userId;
+            this.userIdIsServerAssigned = true;
+            log("[MCPChat] Loaded stored userId: ".concat(this._userId));
+        }
+        if (storedIdentity.sessionId) {
+            this._sessionId = storedIdentity.sessionId;
+            log("[MCPChat] Loaded stored sessionId: ".concat(this._sessionId));
+        }
+        // Config-provided sessionId takes precedence
+        if (config.sessionId) {
+            this._sessionId = config.sessionId;
+        }
+        // Load lastSeq from sessionStorage for replay on reconnect
+        if (this._sessionId) {
+            this.lastSeq = getStoredLastSeq(this._sessionId);
+            if (this.lastSeq !== undefined) {
+                log("[MCPChat] Loaded stored lastSeq: ".concat(this.lastSeq));
+            }
+        }
+    }
+    MCPChat.prototype.init = function (dispatch) {
+        this.dispatch = dispatch;
+        var mode = this.config.mode || "homeowner";
+        log("MCPChat initialized with mode: ".concat(mode));
+        // Warn if not using HTTPS with authentication
+        if (mode === "business_owner" && !this.config.serverUrl.startsWith("https://")) {
+            err("WARNING: Using non-HTTPS URL with authentication tokens. This is insecure in production.");
+        }
+        this.setConnectionStatus("online");
+        this.setAccountStatus("online");
+        // Dispatch bot joined early so it appears before the greeting.
+        // getBot() is config-derived (uses options.bot), so it's safe to call before setVisitorInfo.
+        this.userJoined(this.getBot(undefined));
+        // Returning user with existing session - validate session silently
+        // New user without session - initialize new session to get greeting
+        if (this._sessionId) {
+            this.validateSession();
+        }
+        else {
+            this.initializeNewSession();
+        }
+    };
+    /**
+     * Validates an existing session with the server ("Silent Handshake").
+     * Called when widget reopens with a stored sessionId.
+     *
+     * The server will respond with:
+     * - "connected" event if session is valid
+     * - "session_expired" event if session is gone (triggers initializeNewSession)
+     *
+     * This is lightweight - no LLM call, just a quick DB check to:
+     * - Validate session before user tries to send a message
+     * - Update lastActivityAt in persistent session
+     * - Confirm userId is still valid
+     */
+    MCPChat.prototype.validateSession = function () {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var endpoint, error_1;
+            return __generator$1(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        endpoint = this.getEndpoint();
+                        log("Validating existing session at ".concat(endpoint, ", sessionId: ").concat(this._sessionId));
+                        this.isValidatingSession = true;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, 4, 5]);
+                        return [4 /*yield*/, this.performSSERequest(this.buildRequestPayload({ resumeSession: true }))];
+                    case 2:
+                        _a.sent();
+                        log("Session validation complete");
+                        return [3 /*break*/, 5];
+                    case 3:
+                        error_1 = _a.sent();
+                        err("Failed to validate session: ".concat(error_1));
+                        // If validation fails (network error, etc.), clear session and start fresh
+                        clearStoredSession(this._sessionId);
+                        this._sessionId = "";
+                        this.lastSeq = undefined;
+                        this.initializeNewSession();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        this.isValidatingSession = false;
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Builds the common request payload with identity and context.
+     */
+    MCPChat.prototype.buildRequestPayload = function (additionalData) {
+        if (additionalData === void 0) { additionalData = {}; }
+        return __assign({ 
+            // Identity - server generates these, we just send back what we have
+            userId: this._userId || undefined, sessionId: this._sessionId || undefined, 
+            // Fingerprint for user identification (can be disabled for privacy)
+            fingerprint: this.config.disableFingerprinting ? undefined : getFingerprint(), 
+            // Page context
+            pageContext: getPageContext(this.config.pageContextOverride), 
+            // Client timestamp for latency measurement and clock drift detection
+            clientTime: new Date().toISOString() }, additionalData);
+    };
+    /**
+     * Initializes a new session by calling the endpoint with { newSession: true }.
+     * This returns a greeting message and session ID without making an LLM call.
+     */
+    MCPChat.prototype.initializeNewSession = function () {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var endpoint, error_2;
+            var _this = this;
+            return __generator$1(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Prevent multiple concurrent initialization requests
+                        if (this.isInitializingSession) {
+                            log("New session initialization already in progress, skipping");
+                            return [2 /*return*/];
+                        }
+                        endpoint = this.getEndpoint();
+                        log("Initializing new session at ".concat(endpoint));
+                        this.isInitializingSession = true;
+                        // Create a promise that resolves when initialization completes
+                        this.sessionInitPromise = new Promise(function (resolve) {
+                            _this.resolveSessionInit = resolve;
+                        });
+                        this.typing();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, 4, 5]);
+                        return [4 /*yield*/, this.performSSERequest(this.buildRequestPayload({ newSession: true, generateGreeting: true }))];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 3:
+                        error_2 = _a.sent();
+                        err("Failed to initialize new session: ".concat(error_2));
+                        this.stopTyping();
+                        this.setConnectionStatus("offline");
+                        // Show a failure message but don't block - user can still try sending messages
+                        this.sendFailureMessage(0, 0, this.getErrorMessage(error_2));
+                        return [3 /*break*/, 5];
+                    case 4:
+                        this.isInitializingSession = false;
+                        // Resolve the promise so any waiting postMessage calls can proceed
+                        if (this.resolveSessionInit) {
+                            this.resolveSessionInit();
+                            this.resolveSessionInit = undefined;
+                        }
+                        this.sessionInitPromise = undefined;
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MCPChat.prototype.setConnectionStatus = function (status) {
+        log("SERVER: connection_update: ".concat(JSON.stringify(status)));
+        this.dispatch(setConnectionStatus(status));
+    };
+    MCPChat.prototype.setAccountStatus = function (status) {
+        log("SERVER: account_status: ".concat(JSON.stringify(status)));
+        this.dispatch(setAccountStatus(status));
+    };
+    MCPChat.prototype.getEndpoint = function () {
+        // Normalize serverUrl to remove trailing slashes
+        var serverUrl = this.config.serverUrl.replace(/\/+$/, "");
+        var mode = this.config.mode || "homeowner";
+        if (mode === "business_owner") {
+            return "".concat(serverUrl).concat(BUSINESS_OWNER_ENDPOINT_PATH);
+        }
+        // homeowner mode - serverUrl should already include appId
+        return "".concat(serverUrl).concat(HOMEOWNER_ENDPOINT_PATH);
+    };
+    MCPChat.prototype.sendNewMessage = function (msg, user) {
+        log("SERVER: new message: ".concat(JSON.stringify(msg)));
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.msg",
+                user: user || this.getBot(undefined),
+                msg: msg,
+                timestamp: +new Date(),
+            },
+        });
+    };
+    MCPChat.prototype.userJoined = function (user) {
+        log("SERVER: user joined: ".concat(JSON.stringify(user)));
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.memberjoin",
+                user: user,
+                timestamp: +new Date(),
+            },
+        });
+    };
+    MCPChat.prototype.typing = function () {
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.typing",
+                user: this.getBot(undefined),
+                typing: true,
+                timestamp: +new Date(),
+            },
+        });
+    };
+    MCPChat.prototype.stopTyping = function () {
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.typing",
+                user: this.getBot(undefined),
+                typing: false,
+                timestamp: +new Date(),
+            },
+        });
+    };
+    MCPChat.prototype.sendFailureMessage = function (retry, delay, text) {
+        this.stopTyping();
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.failureMsg",
+                user: this.getBot(undefined),
+                failureMsg: {
+                    retry: retry,
+                    delay: delay,
+                    text: text,
+                },
+                timestamp: +new Date(),
+            },
+        });
+    };
+    /**
+     * Gets the retry configuration, using custom config if provided or defaults.
+     */
+    MCPChat.prototype.getRetryConfig = function () {
+        var _a, _b;
+        if (((_b = (_a = this.configurableMessages) === null || _a === void 0 ? void 0 : _a.items) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+            return getConfigurableMessagesConfig(this.configurableMessages);
+        }
+        return DEFAULT_MCP_RETRY_CONFIG;
+    };
+    /**
+     * Delays execution for the specified number of seconds.
+     */
+    MCPChat.prototype.delay = function (seconds) {
+        return new Promise(function (resolve) { return setTimeout(resolve, seconds * 1000); });
+    };
+    /**
+     * Determines a user-friendly error message based on the error type.
+     */
+    MCPChat.prototype.getErrorMessage = function (error, statusCode) {
+        // Auth errors
+        if (statusCode === 401) {
+            return "Authentication failed. Please check your credentials.";
+        }
+        if (statusCode === 403) {
+            return "Access denied. You don't have permission to access this resource.";
+        }
+        // Server errors
+        if (statusCode && statusCode >= 500) {
+            return "The server is experiencing issues. Please try again later.";
+        }
+        // Not found (likely wrong appId or endpoint)
+        if (statusCode === 404) {
+            return "Service not found. Please check your configuration.";
+        }
+        // Network errors
+        if (error instanceof TypeError && (error.message.includes("fetch") || error.message.includes("network"))) {
+            return "Unable to connect to the server. Please check your internet connection.";
+        }
+        // Connection refused / server down
+        if (error instanceof Error) {
+            var msg = error.message.toLowerCase();
+            if (msg.includes("failed to fetch") || msg.includes("network") || msg.includes("econnrefused")) {
+                return "Unable to reach the server. Please try again later.";
+            }
+        }
+        // Generic fallback
+        return "Something went wrong. Please try again.";
+    };
+    MCPChat.prototype.dispatchStreamStart = function (messageId) {
+        var bot = this.getBot(undefined);
+        var streamTimestamp = +new Date();
+        log("[dispatchStreamStart] Stream started: ".concat(messageId, ", timestamp: ").concat(streamTimestamp));
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.stream.start",
+                user: bot,
+                messageId: messageId,
+                timestamp: streamTimestamp,
+            },
+        });
+    };
+    MCPChat.prototype.dispatchStreamChunk = function (messageId, text) {
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.stream.chunk",
+                user: this.getBot(undefined),
+                messageId: messageId,
+                text: text,
+                timestamp: +new Date(),
+            },
+        });
+    };
+    MCPChat.prototype.dispatchStreamEnd = function (messageId, fullMessage, toolCalls) {
+        log("Stream ended: ".concat(messageId));
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.stream.end",
+                user: this.getBot(undefined),
+                messageId: messageId,
+                msg: fullMessage,
+                toolCalls: toolCalls,
+                timestamp: +new Date(),
+            },
+        });
+    };
+    MCPChat.prototype.dispatchToolStart = function (params) {
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.stream.tool_start",
+                user: this.getBot(undefined),
+                messageId: params.messageId,
+                toolName: params.toolName,
+                toolCallId: params.toolCallId,
+                displayName: params.displayName,
+                label: params.label,
+                hidden: params.hidden,
+                toolInput: params.toolInput,
+                timestamp: +new Date(),
+            },
+        });
+    };
+    MCPChat.prototype.dispatchToolEnd = function (params) {
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.stream.tool_end",
+                user: this.getBot(undefined),
+                messageId: params.messageId,
+                toolName: params.toolName,
+                toolCallId: params.toolCallId,
+                displayName: params.displayName,
+                label: params.label,
+                hidden: params.hidden,
+                toolResult: params.toolResult,
+                toolError: params.toolError,
+                timestamp: +new Date(),
+            },
+        });
+    };
+    /**
+     * Starts the throttled streaming for a message.
+     * Text will be dispatched at a readable pace.
+     */
+    MCPChat.prototype.startStreamThrottle = function (messageId) {
+        var _this = this;
+        this.streamBuffer = "";
+        this.streamingMessageIdForThrottle = messageId;
+        // Clear any existing timer and visibility handler
+        if (this.streamThrottleTimer) {
+            clearInterval(this.streamThrottleTimer);
+        }
+        if (this.visibilityHandler) {
+            document.removeEventListener("visibilitychange", this.visibilityHandler);
+        }
+        // Start interval to dispatch buffered text
+        this.streamThrottleTimer = setInterval(function () {
+            if (_this.streamBuffer.length > 0 && _this.streamingMessageIdForThrottle) {
+                var charsToSend = Math.min(STREAM_CHARS_PER_TICK, _this.streamBuffer.length);
+                var textToDispatch = _this.streamBuffer.slice(0, charsToSend);
+                _this.streamBuffer = _this.streamBuffer.slice(charsToSend);
+                _this.dispatchStreamChunk(_this.streamingMessageIdForThrottle, textToDispatch);
+            }
+        }, STREAM_TICK_INTERVAL_MS);
+        // Handle tab visibility changes - flush buffer when tab becomes visible
+        this.visibilityHandler = function () {
+            if (document.visibilityState === "visible") {
+                log("[Visibility] Tab became visible, buffer length: ".concat(_this.streamBuffer.length, ", messageId: ").concat(_this.streamingMessageIdForThrottle));
+                if (_this.streamBuffer.length > 0 && _this.streamingMessageIdForThrottle) {
+                    // Dispatch all buffered text immediately when tab becomes visible
+                    log("[Visibility] Flushing ".concat(_this.streamBuffer.length, " chars to UI"));
+                    _this.dispatchStreamChunk(_this.streamingMessageIdForThrottle, _this.streamBuffer);
+                    _this.streamBuffer = "";
+                }
+            }
+            else {
+                log("[Visibility] Tab hidden");
+            }
+        };
+        document.addEventListener("visibilitychange", this.visibilityHandler);
+    };
+    /**
+     * Adds text to the stream buffer for throttled dispatch.
+     */
+    MCPChat.prototype.bufferStreamText = function (text) {
+        this.streamBuffer += text;
+    };
+    /**
+     * Flushes any remaining buffered text and stops the throttle timer.
+     * Returns a promise that resolves when all buffered text has been dispatched.
+     */
+    MCPChat.prototype.flushStreamBuffer = function () {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var waitCount, maxWait;
+            return __generator$1(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.streamBuffer.length > 0 && this.streamingMessageIdForThrottle)) return [3 /*break*/, 5];
+                        if (!(document.visibilityState === "hidden")) return [3 /*break*/, 1];
+                        log("[flushStreamBuffer] Tab hidden, dispatching remaining ".concat(this.streamBuffer.length, " chars immediately"));
+                        this.dispatchStreamChunk(this.streamingMessageIdForThrottle, this.streamBuffer);
+                        this.streamBuffer = "";
+                        return [3 /*break*/, 5];
+                    case 1:
+                        waitCount = 0;
+                        maxWait = 100;
+                        _a.label = 2;
+                    case 2:
+                        if (!(this.streamBuffer.length > 0 && waitCount < maxWait)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, STREAM_TICK_INTERVAL_MS); })];
+                    case 3:
+                        _a.sent();
+                        waitCount++;
+                        return [3 /*break*/, 2];
+                    case 4:
+                        // If still has content after timeout, flush it
+                        if (this.streamBuffer.length > 0 && this.streamingMessageIdForThrottle) {
+                            log("[flushStreamBuffer] Timeout waiting for buffer, dispatching remaining ".concat(this.streamBuffer.length, " chars"));
+                            this.dispatchStreamChunk(this.streamingMessageIdForThrottle, this.streamBuffer);
+                            this.streamBuffer = "";
+                        }
+                        _a.label = 5;
+                    case 5:
+                        // Stop the throttle timer
+                        if (this.streamThrottleTimer) {
+                            clearInterval(this.streamThrottleTimer);
+                            this.streamThrottleTimer = undefined;
+                        }
+                        if (this.visibilityHandler) {
+                            document.removeEventListener("visibilitychange", this.visibilityHandler);
+                            this.visibilityHandler = undefined;
+                        }
+                        this.streamingMessageIdForThrottle = undefined;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Immediately stops throttling and clears the buffer (used on abort/error).
+     */
+    MCPChat.prototype.stopStreamThrottle = function () {
+        if (this.streamThrottleTimer) {
+            clearInterval(this.streamThrottleTimer);
+            this.streamThrottleTimer = undefined;
+        }
+        if (this.visibilityHandler) {
+            document.removeEventListener("visibilitychange", this.visibilityHandler);
+            this.visibilityHandler = undefined;
+        }
+        this.streamBuffer = "";
+        this.streamingMessageIdForThrottle = undefined;
+    };
+    MCPChat.prototype.sendOfflineMsg = function (_, cb) {
+        cb();
+    };
+    MCPChat.prototype.sendChatMsg = function (message, cb) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            return __generator$1(this, function (_a) {
+                return [2 /*return*/, this.sendChatMsgRequest({
+                        msg: message,
+                        timestamp: new Date().getTime(),
+                        agent: false,
+                        user: undefined,
+                        type: "msg",
+                    }, cb)];
+            });
+        });
+    };
+    MCPChat.prototype.bargeOut = function (_) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            return __generator$1(this, function (_a) {
+                throw new Error("bargeOut is not supported in MCP mode");
+            });
+        });
+    };
+    MCPChat.prototype.bargeIn = function (_agentName, __) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            return __generator$1(this, function (_a) {
+                throw new Error("bargeIn is not supported in MCP mode");
+            });
+        });
+    };
+    /**
+     * Ensures a nick has the "agent:" prefix required for agent message detection.
+     */
+    MCPChat.prototype.ensureAgentNick = function (nick) {
+        if (!nick)
+            return "agent:robot";
+        if (nick.startsWith("agent:"))
+            return nick;
+        return "agent:".concat(nick);
+    };
+    MCPChat.prototype.getBot = function (user) {
+        var _a;
+        var bot = (_a = this.options) === null || _a === void 0 ? void 0 : _a.bot;
+        if (!user) {
+            // Ensure bot nick has agent: prefix and mark as AI
+            var defaultBot = bot || { nick: "agent:robot", displayName: "Assistant" };
+            return __assign(__assign({}, defaultBot), { nick: this.ensureAgentNick(defaultBot.nick), isAI: true });
+        }
+        if (user.displayName && user.nick && user.avatarPath) {
+            return __assign(__assign({}, user), { nick: this.ensureAgentNick(user.nick), isAI: true });
+        }
+        return __assign(__assign({}, user), { nick: this.ensureAgentNick(user.nick || (bot === null || bot === void 0 ? void 0 : bot.nick)), displayName: user.displayName || (bot === null || bot === void 0 ? void 0 : bot.displayName) || "Assistant", avatarPath: user.avatarPath || (bot === null || bot === void 0 ? void 0 : bot.avatarPath), isAI: true });
+    };
+    MCPChat.prototype.sendChatMsgRequest = function (serviceRequest, cb) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var error_3;
+            return __generator$1(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.postMessage(serviceRequest)];
+                    case 1:
+                        _a.sent();
+                        cb();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_3 = _a.sent();
+                        cb(error_3);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MCPChat.prototype.postMessage = function (message) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var trimmedText, timeout, result, retryConfig, messageText, success, attempt, isLastAttempt, config, error_4, statusCode, errorMessage, statusCode_1, errorMessage, nextConfig, nextConfig;
+            var _a, _b, _c;
+            return __generator$1(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        trimmedText = ((_b = (_a = message.msg) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.trim()) || "";
+                        if (!trimmedText) {
+                            log("Ignoring empty message");
+                            return [2 /*return*/];
+                        }
+                        if (!(this.isInitializingSession && this.sessionInitPromise)) return [3 /*break*/, 2];
+                        log("Waiting for session initialization to complete before sending message...");
+                        timeout = new Promise(function (resolve) {
+                            return setTimeout(function () { return resolve("timeout"); }, 10000);
+                        });
+                        return [4 /*yield*/, Promise.race([this.sessionInitPromise, timeout])];
+                    case 1:
+                        result = _d.sent();
+                        if (result === "timeout" || this.isInitializingSession) {
+                            err("Session initialization timed out");
+                            this.sendFailureMessage(0, 0, "Chat is not ready. Please try again.");
+                            return [2 /*return*/];
+                        }
+                        _d.label = 2;
+                    case 2:
+                        retryConfig = this.getRetryConfig();
+                        messageText = ((_c = message.msg) === null || _c === void 0 ? void 0 : _c.text) || "";
+                        success = false;
+                        attempt = 0;
+                        _d.label = 3;
+                    case 3:
+                        if (!(attempt < retryConfig.length)) return [3 /*break*/, 14];
+                        isLastAttempt = attempt === retryConfig.length - 1;
+                        config = retryConfig[attempt];
+                        log("MCP attempt ".concat(attempt + 1, "/").concat(retryConfig.length, " for message: ").concat(messageText));
+                        // Start typing indicator
+                        this.typing();
+                        _d.label = 4;
+                    case 4:
+                        _d.trys.push([4, 6, , 13]);
+                        return [4 /*yield*/, this.attemptSSERequest(message)];
+                    case 5:
+                        _d.sent();
+                        success = true;
+                        return [3 /*break*/, 14]; // Success - exit retry loop
+                    case 6:
+                        error_4 = _d.sent();
+                        this.stopTyping();
+                        statusCode = error_4 === null || error_4 === void 0 ? void 0 : error_4.statusCode;
+                        err("MCP attempt ".concat(attempt + 1, " failed: ").concat(error_4, ", statusCode: ").concat(statusCode));
+                        log("[postMessage] Error details:", { error: error_4, statusCode: statusCode, messageText: messageText, sessionId: this._sessionId });
+                        // Don't retry on 4xx client errors - these won't succeed on retry
+                        if (statusCode && statusCode >= 400 && statusCode < 500) {
+                            log("Client error ".concat(statusCode, ", not retrying"));
+                            errorMessage = this.getErrorMessage(error_4, statusCode);
+                            this.sendFailureMessage(0, 0, errorMessage);
+                            return [2 /*return*/];
+                        }
+                        // Set offline status
+                        this.setConnectionStatus("offline");
+                        if (!isLastAttempt) return [3 /*break*/, 7];
+                        statusCode_1 = error_4 === null || error_4 === void 0 ? void 0 : error_4.statusCode;
+                        errorMessage = config.text || this.getErrorMessage(error_4, statusCode_1);
+                        this.sendFailureMessage(0, 0, errorMessage);
+                        return [3 /*break*/, 12];
+                    case 7:
+                        if (!(attempt > 0 || config.text)) return [3 /*break*/, 10];
+                        nextConfig = retryConfig[attempt + 1];
+                        if (!(nextConfig && nextConfig.delay > 0)) return [3 /*break*/, 9];
+                        this.sendFailureMessage(nextConfig.retry, nextConfig.delay, nextConfig.text);
+                        // Wait for the delay before retrying
+                        return [4 /*yield*/, this.delay(nextConfig.delay)];
+                    case 8:
+                        // Wait for the delay before retrying
+                        _d.sent();
+                        _d.label = 9;
+                    case 9: return [3 /*break*/, 12];
+                    case 10:
+                        nextConfig = retryConfig[attempt + 1];
+                        if (!(nextConfig && nextConfig.delay > 0)) return [3 /*break*/, 12];
+                        return [4 /*yield*/, this.delay(nextConfig.delay)];
+                    case 11:
+                        _d.sent();
+                        _d.label = 12;
+                    case 12: return [3 /*break*/, 13];
+                    case 13:
+                        attempt++;
+                        return [3 /*break*/, 3];
+                    case 14:
+                        if (!success) {
+                            log("All MCP retry attempts exhausted");
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Attempts a single SSE request. Throws on failure.
+     */
+    MCPChat.prototype.attemptSSERequest = function (message) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var messageText;
+            var _a;
+            return __generator$1(this, function (_b) {
+                messageText = ((_a = message.msg) === null || _a === void 0 ? void 0 : _a.text) || "";
+                log("[attemptSSERequest] Sending message: \"".concat(messageText, "\", userId: ").concat(this._userId, ", sessionId: ").concat(this._sessionId));
+                return [2 /*return*/, this.performSSERequest(this.buildRequestPayload({ message: messageText }))];
+            });
+        });
+    };
+    /**
+     * Performs an SSE request with the given body.
+     * Used for both new session initialization and regular messages.
+     */
+    MCPChat.prototype.performSSERequest = function (body) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var endpoint, messageId, textChunks, hasError, httpStatusCode, sseError;
+            var _this = this;
+            return __generator$1(this, function (_a) {
+                endpoint = this.getEndpoint();
+                log("SSE request to ".concat(endpoint, ": ").concat(JSON.stringify(body)));
+                // Cancel any ongoing stream
+                if (this.abortController) {
+                    this.abortController.abort();
+                    this.abortController = undefined;
+                }
+                this.abortController = new AbortController();
+                messageId = uuid_1();
+                this.currentMessageId = messageId;
+                textChunks = [];
+                hasError = false;
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        // WARNING: Do not log headers object - it contains sensitive auth tokens
+                        cjs.fetchEventSource(endpoint, {
+                            method: "POST",
+                            headers: __assign({ "Content-Type": "application/json" }, ((_this.config.mode || "homeowner") === "business_owner" && _this.config.authToken
+                                ? { Authorization: "Bearer ".concat(_this.config.authToken) }
+                                : {})),
+                            body: JSON.stringify(body),
+                            signal: _this.abortController.signal,
+                            onopen: function (response) { return __awaiter$1(_this, void 0, void 0, function () {
+                                var error;
+                                return __generator$1(this, function (_a) {
+                                    httpStatusCode = response.status;
+                                    if (!response.ok) {
+                                        error = new Error("HTTP error! status: ".concat(response.status));
+                                        error.statusCode = response.status;
+                                        throw error;
+                                    }
+                                    log("SSE connection opened");
+                                    // Connection successful - ensure we're marked as online
+                                    this.setConnectionStatus("online");
+                                    return [2 /*return*/];
+                                });
+                            }); },
+                            onmessage: function (event) {
+                                log("SSE event: ".concat(event.event, ", data: ").concat(event.data));
+                                var eventType = event.event || "message";
+                                var data = {};
+                                try {
+                                    data = JSON.parse(event.data);
+                                }
+                                catch (e) {
+                                    log("Failed to parse SSE data: ".concat(e));
+                                    return;
+                                }
+                                // Track sequence number for replay on reconnect
+                                if (data.seq !== undefined && data.seq !== null) {
+                                    _this.lastSeq = data.seq;
+                                    if (_this._sessionId) {
+                                        storeLastSeq(_this._sessionId, data.seq);
+                                    }
+                                }
+                                switch (eventType) {
+                                    case "connected":
+                                        // Connection established
+                                        log("[SSE] Connected event received, messageId: ".concat(messageId, ", isReturningUser: ").concat(data.isReturningUser, ", isReplay: ").concat(data.isReplay));
+                                        // Track if this is a replay connection
+                                        if (data.isReplay) {
+                                            _this.isReplaying = true;
+                                        }
+                                        // Store identity from server response
+                                        if (data.userId || data.sessionId) {
+                                            if (data.userId) {
+                                                _this._userId = data.userId;
+                                                _this.userIdIsServerAssigned = true;
+                                            }
+                                            if (data.sessionId) {
+                                                _this._sessionId = data.sessionId;
+                                                _this.dispatch(setSessionId(_this._sessionId));
+                                            }
+                                            // Persist to localStorage for session continuity
+                                            storeIdentity(data.userId, data.sessionId);
+                                            log("[SSE] Identity from connected - userId: ".concat(data.userId, ", sessionId: ").concat(data.sessionId));
+                                        }
+                                        // Always start streaming - server sends greeting for both new and returning users
+                                        // (resumeSession requests always get a personalized greeting)
+                                        _this.currentToolCalls = [];
+                                        _this.stopTyping();
+                                        _this.dispatchStreamStart(messageId);
+                                        _this.startStreamThrottle(messageId);
+                                        break;
+                                    case "session_expired":
+                                        // Session no longer exists on server - need to start fresh
+                                        log("[SSE] Session expired: ".concat(data.reason || "Session not found"));
+                                        // Clear stored session (and lastSeq) but keep userId for returning user identification
+                                        clearStoredSession(_this._sessionId);
+                                        _this._sessionId = "";
+                                        _this.lastSeq = undefined;
+                                        _this.stopTyping();
+                                        _this.stopStreamThrottle();
+                                        // Reset validation flag before starting new session
+                                        // (ensures connected handler will dispatch stream for greeting)
+                                        _this.isValidatingSession = false;
+                                        // Start a new session automatically
+                                        _this.initializeNewSession();
+                                        resolve();
+                                        break;
+                                    case "text":
+                                        if (data.text) {
+                                            log("[SSE] Text chunk received (".concat(data.text.length, " chars), total chunks: ").concat(textChunks.length + 1, ", isReplay: ").concat(data.isReplay));
+                                            textChunks.push(data.text);
+                                            if (data.isReplay) {
+                                                // Replayed text — dispatch immediately (no throttle)
+                                                // so the user sees caught-up content instantly
+                                                _this.dispatchStreamChunk(messageId, data.text);
+                                            }
+                                            else {
+                                                // Live text — buffer for throttled dispatch
+                                                _this.bufferStreamText(data.text);
+                                            }
+                                        }
+                                        break;
+                                    case "tool_start":
+                                        log("Tool execution started: ".concat(data.toolName, ", toolCallId: ").concat(data.toolCallId, ", displayName: ").concat(data.displayName, ", label: ").concat(data.label, ", hidden: ").concat(data.hidden));
+                                        if (data.toolName) {
+                                            var toolCall = {
+                                                name: data.toolName,
+                                                toolCallId: data.toolCallId,
+                                                displayName: data.displayName,
+                                                label: data.label,
+                                                hidden: data.hidden,
+                                                input: data.toolInput,
+                                                startTime: Date.now(),
+                                                isExecuting: true,
+                                            };
+                                            _this.currentToolCalls.push(toolCall);
+                                            // Always dispatch tool start for user-friendly progress display
+                                            _this.dispatchToolStart({
+                                                messageId: messageId,
+                                                toolName: data.toolName,
+                                                toolCallId: data.toolCallId,
+                                                displayName: data.displayName,
+                                                label: data.label,
+                                                hidden: data.hidden,
+                                                toolInput: data.toolInput,
+                                            });
+                                        }
+                                        break;
+                                    case "tool_end":
+                                        log("Tool execution ended: ".concat(data.toolName, ", toolCallId: ").concat(data.toolCallId, ", displayName: ").concat(data.displayName, ", label: ").concat(data.label, ", hidden: ").concat(data.hidden));
+                                        if (data.toolName) {
+                                            // Find the matching tool call and update it
+                                            // Match by toolCallId if available, otherwise fall back to name + isExecuting
+                                            var toolCall = _this.currentToolCalls.find(function (tc) {
+                                                return data.toolCallId
+                                                    ? tc.toolCallId === data.toolCallId
+                                                    : tc.name === data.toolName && tc.isExecuting;
+                                            });
+                                            if (toolCall) {
+                                                toolCall.result = data.toolResult;
+                                                toolCall.error = data.toolError;
+                                                toolCall.label = data.label; // Update with completion label
+                                                toolCall.hidden = data.hidden; // Update hidden status
+                                                toolCall.endTime = Date.now();
+                                                toolCall.isExecuting = false;
+                                            }
+                                            // Always dispatch tool end for user-friendly progress display
+                                            _this.dispatchToolEnd({
+                                                messageId: messageId,
+                                                toolName: data.toolName,
+                                                toolCallId: data.toolCallId,
+                                                displayName: data.displayName,
+                                                label: data.label,
+                                                hidden: data.hidden,
+                                                toolResult: data.toolResult,
+                                                toolError: data.toolError,
+                                            });
+                                        }
+                                        break;
+                                    case "done":
+                                        _this.stopTyping();
+                                        if (data.response) {
+                                            // Update session ID if provided and persist to localStorage
+                                            if (data.response.sessionId) {
+                                                _this._sessionId = data.response.sessionId;
+                                                _this.dispatch(setSessionId(_this._sessionId));
+                                                storeIdentity(undefined, data.response.sessionId);
+                                            }
+                                            // Wait for buffer to flush, then finalize
+                                            var accumulatedText = textChunks.join("");
+                                            log("[SSE] Done event received. Total chunks: ".concat(textChunks.length, ", accumulated text length: ").concat(accumulatedText.length));
+                                            log("[SSE] First 100 chars of accumulated: ".concat(accumulatedText.substring(0, 100)));
+                                            // Map suggestions to options (chips) format
+                                            var suggestions = data.response.suggestions;
+                                            var options = suggestions === null || suggestions === void 0 ? void 0 : suggestions.map(function (s) { return ({
+                                                label: s.title,
+                                                actionUrl: s.url || "",
+                                            }); });
+                                            if (options === null || options === void 0 ? void 0 : options.length) {
+                                                log("[SSE] Suggestions: ".concat(options.length, " items"));
+                                            }
+                                            // Map sources for reference links
+                                            var sources = data.response.sources;
+                                            if (sources === null || sources === void 0 ? void 0 : sources.length) {
+                                                log("[SSE] Sources: ".concat(sources.length, " items"));
+                                            }
+                                            var finalMessage_1 = {
+                                                text: accumulatedText || data.response.response || "",
+                                                options: options,
+                                                sources: sources,
+                                            };
+                                            // Capture tool calls before flushing (debug mode)
+                                            var toolCalls_1 = _this.config.debugMode ? __spreadArray$1([], _this.currentToolCalls, true) : undefined;
+                                            _this.flushStreamBuffer().then(function () {
+                                                _this.dispatchStreamEnd(messageId, finalMessage_1, toolCalls_1);
+                                                _this.currentToolCalls = []; // Clear after dispatch
+                                                resolve();
+                                            });
+                                        }
+                                        else {
+                                            _this.stopStreamThrottle();
+                                            resolve();
+                                        }
+                                        break;
+                                    case "replay_complete":
+                                        _this.isReplaying = false;
+                                        log("[SSE] Replay complete: replayed ".concat(data.replayedCount, " events, currentSeq: ").concat(data.currentSeq));
+                                        break;
+                                    case "replay_partial":
+                                        _this.isReplaying = false;
+                                        log("[SSE] Replay partial: some events unavailable, oldestAvailableSeq: ".concat(data.oldestAvailableSeq));
+                                        break;
+                                    case "error":
+                                        hasError = true;
+                                        _this.stopTyping();
+                                        _this.stopStreamThrottle();
+                                        err("SSE error: ".concat(data.error));
+                                        // Server-side errors should not retry - reject immediately with the error
+                                        reject(new Error(data.error || "Server error during processing"));
+                                        break;
+                                }
+                            },
+                            onerror: function (error) {
+                                // Only handle error if this is still the current message
+                                if (_this.currentMessageId === messageId && !hasError) {
+                                    hasError = true;
+                                    _this.isReplaying = false;
+                                    _this.stopStreamThrottle();
+                                    sseError = error instanceof Error ? error : new Error(String(error));
+                                    // Get status code if available
+                                    var statusCode = (error === null || error === void 0 ? void 0 : error.statusCode) || httpStatusCode;
+                                    if (statusCode) {
+                                        sseError.statusCode = statusCode;
+                                    }
+                                    err("SSE connection error: ".concat(error));
+                                }
+                                // Throw to stop fetchEventSource from retrying
+                                throw error;
+                            },
+                        }).catch(function (error) {
+                            // Handle errors that occur before/outside the SSE connection
+                            _this.stopStreamThrottle();
+                            if (!hasError && _this.currentMessageId === messageId) {
+                                var statusCode = (error === null || error === void 0 ? void 0 : error.statusCode) || httpStatusCode;
+                                var wrappedError = error instanceof Error ? error : new Error(String(error));
+                                if (statusCode) {
+                                    wrappedError.statusCode = statusCode;
+                                }
+                                reject(wrappedError);
+                            }
+                            else if (sseError) {
+                                reject(sseError);
+                            }
+                            else {
+                                reject(error);
+                            }
+                        });
+                    })];
+            });
+        });
+    };
+    MCPChat.prototype.sendTyping = function () { };
+    MCPChat.prototype.setVisitorInfo = function (visitorInfo, sessionId, cb) {
+        this.visitorInfo = visitorInfo;
+        this._attributes = __assign({}, this.visitorInfo.attributes);
+        // do not set currentUrl if localhost
+        var href = new URL(window.location.href);
+        if (href === null || href === void 0 ? void 0 : href.host.toLowerCase().startsWith("localhost")) {
+            this._attributes.isLocal = true;
+        }
+        else {
+            this._attributes.currentUrl = window.location.href;
+        }
+        this._accessToken = this.visitorInfo.accessToken;
+        // Bot joined is dispatched in init() to ensure correct ordering
+        // Show typing indicator if we're still waiting for initial greeting
+        if (this.isInitializingSession) {
+            this.typing();
+        }
+        this.startSession(sessionId);
+        cb();
+    };
+    MCPChat.prototype.sendChatRating = function () { };
+    MCPChat.prototype.sendFile = function (_, cb) {
+        cb(new Error("File upload not supported in MCP mode"));
+    };
+    MCPChat.prototype.markAsRead = function () { };
+    MCPChat.prototype.flush = function () { };
+    MCPChat.prototype.dispose = function () {
+        this.stopStreamThrottle();
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = undefined;
+        }
+    };
+    MCPChat.prototype.sleep = function () {
+        this.stopStreamThrottle();
+        this.isReplaying = false;
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = undefined;
+        }
+    };
+    MCPChat.prototype.wakeup = function () {
+        // When tab is foregrounded, just restore connection status.
+        // Don't validate/replay yet — the session will be validated
+        // on the next user message. This avoids creating duplicate
+        // greetings if validation fails transiently.
+        if (this._sessionId) {
+            log("[MCPChat] Wakeup - session exists, lastSeq: ".concat(this.lastSeq));
+            this.setConnectionStatus("online");
+        }
+    };
+    MCPChat.prototype.startSession = function (sessionId) {
+        // userId priority:
+        // 1. Existing server-assigned userId (from localStorage or previous connected event)
+        // 2. Explicitly provided visitorId or email from host app
+        // 3. Generate a new one as last resort
+        if (this.userIdIsServerAssigned) {
+            // Keep server-assigned userId — don't overwrite with default fingerprint
+            log("[startSession] Preserving server-assigned userId: ".concat(this._userId));
+        }
+        else if (this.visitorInfo.visitorId) {
+            this._userId = "".concat(this.visitorInfo.visitorId);
+        }
+        else if (this.visitorInfo.email) {
+            this._userId = "mcp-widget-user-".concat(this.visitorInfo.email);
+        }
+        else if (!this._userId) {
+            // Only generate a new userId if we don't already have one
+            // (preserves userId loaded from localStorage or received from server)
+            this._userId = "mcp-widget-user-".concat(uuid_1());
+        }
+        // Session ID priority:
+        // 1. If explicitly provided via setVisitorInfo, use it
+        // 2. If empty string provided, generate a new session ID
+        // 3. If not provided (undefined) and we have an existing session, keep it
+        if (sessionId) {
+            // Explicit session ID provided - use it
+            this._sessionId = sessionId;
+            log("Using provided session id: ".concat(this._sessionId));
+        }
+        else if (sessionId === "") {
+            // Empty string explicitly passed - generate new session
+            this._sessionId = "mcp-widget-session-".concat(uuid_1());
+            this.dispatch(setSessionId(this._sessionId));
+            log("Using generated session id: ".concat(this._sessionId));
+        }
+        else if (!this._sessionId && this.config.sessionId) {
+            // No existing session and config has one - use config
+            this._sessionId = this.config.sessionId;
+            log("Using config session id: ".concat(this._sessionId));
+        }
+        else if (!this._sessionId) {
+            // No session ID at all - generate one
+            this._sessionId = "mcp-widget-session-".concat(uuid_1());
+            this.dispatch(setSessionId(this._sessionId));
+            log("Using generated session id: ".concat(this._sessionId));
+        }
+        else {
+            log("Keeping existing session id: ".concat(this._sessionId));
+        }
+        this.isNewSession = true;
+    };
+    Object.defineProperty(MCPChat.prototype, "userId", {
+        get: function () {
+            return this._userId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MCPChat.prototype, "sessionId", {
+        get: function () {
+            return this._sessionId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return MCPChat;
+}());
+
+/**
+ * Sends a POST to your STENTOR based server.
+ *
+ * @param data
+ * @param url
+ * @param key
+ * @param signal
+ * @returns
+ */
+function postMessageToStentor(data, url, key, signal) {
+    return __awaiter$1(this, void 0, void 0, function () {
+        var body, response;
+        return __generator$1(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    body = JSON.stringify(data);
+                    log("URL: ".concat(url));
+                    log("BODY: ".concat(body));
+                    return [4 /*yield*/, fetch(url, {
+                            method: "POST",
+                            headers: {
+                                "Content-Type": "application/json",
+                                "Authorization": "Bearer ".concat(key),
+                            },
+                            body: body,
+                            mode: "cors",
+                            signal: signal
+                        })];
+                case 1:
+                    response = _a.sent();
+                    if (!response.ok) {
+                        throw new Error("Status ".concat(response.status, ", Text: ").concat(response.statusText));
+                    }
+                    return [2 /*return*/, response.json()];
+            }
+        });
+    });
+}
+
+function convertFromListDisplay(list) {
+    return {
+        type: list.type,
+        title: list.title,
+        items: list.items.map(function (item) {
+            var _a, _b;
+            var responseItem = {
+                title: item.title,
+                subTitle: item.description,
+                token: item.token,
+                url: item.url,
+                hideUrl: item.hideUrl,
+                imageUrl: (_a = item.image) === null || _a === void 0 ? void 0 : _a.url,
+                imageActionUrl: (_b = item.image) === null || _b === void 0 ? void 0 : _b.imageActionUrl
+            };
+            // TODO: Remove any when the buttons are defined on the list (ListButton - title + openUrlAction)
+            var itemButtons = item.buttons;
+            if (itemButtons && itemButtons.length > 0) {
+                responseItem.buttons = itemButtons.map(function (button) { return ({
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    actionUrl: button.openUrlAction,
+                    label: button.title
+                }); });
+            }
+            return responseItem;
+        })
+    };
+}
+function convertToListDisplay(list) {
+    return {
+        type: list.type,
+        title: list.title,
+        items: (list.items || []).map(function (item) {
+            var responseItem = {
+                title: item.title,
+                description: item.subTitle,
+                token: item.token,
+                url: item.url,
+                hideUrl: item.hideUrl,
+                image: {
+                    url: item.imageUrl,
+                    imageActionUrl: item.imageActionUrl,
+                    accessibilityText: ""
+                }
+            };
+            // TODO: Remove any when the buttons are defined on the list (ListButton - title + openUrlAction)
+            var itemButtons = item.buttons;
+            if (itemButtons && itemButtons.length > 0) {
+                responseItem.buttons = itemButtons.map(function (button) { return ({
+                    openUrlAction: button.actionUrl,
+                    title: button.label
+                }); });
+            }
+            return responseItem;
+        })
+    };
+}
+function convertFromCardDisplay(card) {
+    return {
+        content: card.content,
+        imageUrl: card.smallImageUrl,
+        title: card.title,
+        imageActionUrl: card === null || card === void 0 ? void 0 : card.imageActionUrl,
+        buttons: card.buttons ? card.buttons.map(function (button) { return ({
+            actionUrl: button.openUrlAction,
+            label: button.title
+        }); }) : undefined
+    };
+}
+function getOutput(value) {
+    if (value) {
+        if (typeof value === "string") {
+            return {
+                displayText: value
+            };
+        }
+        else {
+            return value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Converts a Stentor Response to a ChatMessageRequest
+ *
+ * @param botResponse
+ * @param now
+ * @returns
+ */
+function responseToMessage(botResponse, now) {
+    var _a, _b, _c, _d, _e;
+    if (now === void 0) { now = new Date().getTime(); }
+    var responseMessage;
+    if (!botResponse) {
+        return responseMessage;
+    }
+    var text;
+    var html;
+    var endSession;
+    var outputSpeech = getOutput(botResponse.outputSpeech);
+    var reprompt = getOutput(botResponse.reprompt);
+    if (outputSpeech) {
+        text = outputSpeech.displayText;
+        html = outputSpeech.html;
+    }
+    if (botResponse.system === "TRANSFER_CALL") {
+        responseMessage = {
+            type: "handOff",
+            timestamp: now,
+            handoffMessage: text,
+            handoffTarget: (_a = botResponse === null || botResponse === void 0 ? void 0 : botResponse.data) === null || _a === void 0 ? void 0 : _a.transferPhoneNumber,
+            endSession: false,
+            user: undefined
+        };
+    }
+    else if ((_b = botResponse.system) === null || _b === void 0 ? void 0 : _b.startsWith("PERMISSION_")) {
+        responseMessage = getPermissionResponse(botResponse, now);
+    }
+    else {
+        endSession = !reprompt || !(reprompt.displayText || reprompt.ssml);
+        responseMessage = {
+            type: "msg",
+            timestamp: now,
+            msg: {
+                displays: botResponse.displays,
+                context: (_d = (_c = botResponse.context) === null || _c === void 0 ? void 0 : _c.active) === null || _d === void 0 ? void 0 : _d.map(function (ctx) { return ctx.name; })
+            },
+            endSession: endSession,
+            user: undefined
+        };
+        if (text && !html) {
+            responseMessage.msg = __assign(__assign({}, responseMessage.msg), { text: text });
+        }
+        if (html) {
+            responseMessage.msg = __assign(__assign({}, responseMessage.msg), { html: html });
+        }
+        if ((_e = outputSpeech === null || outputSpeech === void 0 ? void 0 : outputSpeech.suggestions) === null || _e === void 0 ? void 0 : _e.length) {
+            responseMessage.msg.options = outputSpeech.suggestions.map(function (suggestion) {
+                if (typeof suggestion === "string") {
+                    // Simple chips (strings)
+                    return suggestion;
+                }
+                else {
+                    // "call out" chips
+                    return {
+                        label: suggestion.title,
+                        actionUrl: suggestion.url
+                    };
+                }
+            });
+        }
+    }
+    return responseMessage;
+}
+function getPermissionRequestType(type) {
+    switch (type) {
+        case "PERMISSION_EMAIL":
+            return "EMAIL";
+        case "PERMISSION_LOCATION_PRECISE":
+            return "LOCATION_PRECISE";
+        default:
+            throw new Error("Unsupported permission: ".concat(type));
+    }
+}
+function getPermissionResponse(botResponse, now) {
+    var _a;
+    var type = getPermissionRequestType(botResponse.system);
+    var outputSpeech = getOutput(botResponse.outputSpeech);
+    var permissionPrimerAccepted = botResponse.data.permissionPrimerAccepted;
+    var permissionDenied = botResponse.data.permissionDenied;
+    return {
+        type: "permissionRequest",
+        timestamp: now,
+        msg: {
+            text: (_a = outputSpeech === null || outputSpeech === void 0 ? void 0 : outputSpeech.displayText) !== null && _a !== void 0 ? _a : "".concat(botResponse.data.permissionRequestTTSContext),
+            permissionRequest: {
+                time: now,
+                type: type,
+                approve: typeof permissionPrimerAccepted === "object" ? responseToMessage({
+                    outputSpeech: permissionPrimerAccepted
+                }).msg : undefined,
+                deny: typeof permissionDenied === "object" ? responseToMessage({
+                    outputSpeech: permissionDenied
+                }).msg : undefined
+            }
+        },
+        endSession: false,
+        user: undefined //todo: set
+    };
+}
+
 var PERMISSION_QUESTION_EXPIRATION_MS$1 = 300000; // 5 minutes
 // interface UserLeaveMessage {
 //     readonly user: ChatUserInfo;
@@ -4760,7 +6391,7 @@ function createPacketDecoderStream(maxPayload, binaryType) {
         },
     });
 }
-const protocol$1 = 4;
+const protocol = 4;
 
 /**
  * Expose `Emitter`.
@@ -6036,7 +7667,7 @@ class SocketWithoutUpgrade extends Emitter_1 {
     createTransport(name) {
         const query = Object.assign({}, this.opts.query);
         // append engine.io protocol identifier
-        query.EIO = protocol$1;
+        query.EIO = protocol;
         // transport name
         query.transport = name;
         // session id if we already have one
@@ -6411,7 +8042,7 @@ class SocketWithoutUpgrade extends Emitter_1 {
         }
     }
 }
-SocketWithoutUpgrade.protocol = protocol$1;
+SocketWithoutUpgrade.protocol = protocol;
 /**
  * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
  * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
@@ -6807,12 +8438,6 @@ const RESERVED_EVENTS$1 = [
     "newListener",
     "removeListener", // used by the Node.js EventEmitter
 ];
-/**
- * Protocol version.
- *
- * @public
- */
-const protocol = 5;
 var PacketType;
 (function (PacketType) {
     PacketType[PacketType["CONNECT"] = 0] = "CONNECT";
@@ -7109,8 +8734,7 @@ var parser = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	Decoder: Decoder,
 	Encoder: Encoder,
-	get PacketType () { return PacketType; },
-	protocol: protocol
+	get PacketType () { return PacketType; }
 });
 
 function on(obj, ev, fn) {
@@ -8664,6 +10288,7 @@ var StentorServerChat = /** @class */ (function () {
 }());
 
 function createChatServerCore(config, options) {
+    var _a, _b, _c, _d, _e;
     switch (config.type) {
         case "direct":
             return new StentorDirectChat({
@@ -8679,6 +10304,15 @@ function createChatServerCore(config, options) {
             return new StentorRouterChat({
                 url: config.serverUrl,
             }, options);
+        case "mcp":
+            return new MCPChat({
+                serverUrl: config.serverUrl,
+                mode: (_a = config.mcp) === null || _a === void 0 ? void 0 : _a.mode,
+                authToken: (_b = config.mcp) === null || _b === void 0 ? void 0 : _b.authToken,
+                debugMode: (_c = config.mcp) === null || _c === void 0 ? void 0 : _c.debugMode,
+                pageContextOverride: (_d = config.mcp) === null || _d === void 0 ? void 0 : _d.pageContextOverride,
+                showAiBadge: (_e = config.mcp) === null || _e === void 0 ? void 0 : _e.showAiBadge,
+            }, options);
         case "local":
             return new StentorLocalChat();
         default:
@@ -8832,6 +10466,79 @@ var DrawerBars = function (props) {
     return (jsx("button", { className: "drawer-bars", tabIndex: props.tabIndex ? Number(props.tabIndex) : 0, "aria-label": "open menu", "aria-hidden": false, onClick: props.onToggle, children: getBars() }));
 };
 
+/**
+ * Type guard for ChatMsgDetail.
+ * Use this to safely narrow ChatDetail to ChatMsgDetail.
+ */
+function isChatMsgDetail(chat) {
+    return chat.type === "chat.msg";
+}
+
+/**
+ * Formats a suggestion chip for export
+ */
+function formatSuggestion(option) {
+    if (isChatServerActionLink(option)) {
+        return option.actionUrl ? "[".concat(option.label, "](").concat(option.actionUrl, ")") : option.label;
+    }
+    return option;
+}
+/**
+ * Formats chat messages for export
+ */
+function formatConversation(chats) {
+    return chats
+        .filter(isChatMsgDetail)
+        .map(function (chat) {
+        var _a, _b, _c;
+        var isVisitor = (_a = chat.user.nick) === null || _a === void 0 ? void 0 : _a.startsWith("visitor:");
+        var role = isVisitor ? "User" : "Assistant";
+        var text = ((_b = chat.msg) === null || _b === void 0 ? void 0 : _b.text) || "";
+        var result = "".concat(role, ": ").concat(text);
+        // Add suggestion chips if present
+        var options = (_c = chat.msg) === null || _c === void 0 ? void 0 : _c.options;
+        if (options && options.length > 0) {
+            var suggestions = options.map(formatSuggestion).join(", ");
+            result += "\nSuggestions: ".concat(suggestions);
+        }
+        return result;
+    })
+        .join("\n");
+}
+var ExportButton = function (props) {
+    var chats = useSelector(function (state) { return state.chats; });
+    var handleClick = function () { return __awaiter$1(void 0, void 0, void 0, function () {
+        var conversation, textarea;
+        return __generator$1(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    conversation = formatConversation(chats);
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, navigator.clipboard.writeText(conversation)];
+                case 2:
+                    _b.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    _b.sent();
+                    // Fallback for older browsers using deprecated execCommand
+                    // Note: execCommand is deprecated and may be removed in future browsers
+                    console.warn("[ExportButton] Using deprecated execCommand fallback for clipboard copy");
+                    textarea = document.createElement("textarea");
+                    textarea.value = conversation;
+                    document.body.appendChild(textarea);
+                    textarea.select();
+                    document.execCommand("copy");
+                    document.body.removeChild(textarea);
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); };
+    return (jsx("div", { id: "xapp-widget-export", "aria-label": "export conversation", "aria-hidden": false, tabIndex: props.tabIndex ? Number(props.tabIndex) : 0, className: "export-button", onClick: handleClick }));
+};
+
 var MenuButton = function (props) {
     return (jsx("div", { id: "xapp-widget-menu", "aria-label": "open menu", "aria-hidden": false, tabIndex: props.tabIndex ? Number(props.tabIndex) : 0, className: "menu-button", onClick: props.onClick }));
 };
@@ -8975,7 +10682,7 @@ var closeButtonAriaLabel = "To close widget click on close icon in top right sid
 var ChatHeader = function (props) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
     var innerDispatch = useChatDispatch();
-    var menuConfig = props.menuConfig, onSubmit = props.onSubmit;
+    var menuConfig = props.menuConfig, onSubmit = props.onSubmit, debugMode = props.debugMode;
     var _r = useState(false), drawerOpen = _r[0], setDrawerState = _r[1]; // false initially
     var menuPosition = (menuConfig === null || menuConfig === void 0 ? void 0 : menuConfig.menuButtonLocation) || "FOOTER";
     var showMenuLeft = menuPosition === "HEADER_LEFT";
@@ -9014,7 +10721,7 @@ var ChatHeader = function (props) {
                                 ? "status-text-positionLeftNoAvatar"
                                 : "status-text-positionLeft", "\n                        ").concat(((_d = props.config) === null || _d === void 0 ? void 0 : _d.alignTextCenter)
                             ? "status-text-positionCenter"
-                            : "", "                     \n                        "), children: [jsx("span", { className: "status-text-title", children: getStatusText(props.accountStatus, (_e = props.config) === null || _e === void 0 ? void 0 : _e.status) }), ((_g = (_f = props.config) === null || _f === void 0 ? void 0 : _f.subtitle) === null || _g === void 0 ? void 0 : _g.enabled) && (jsx("span", { className: "status-text-subtitle", children: renderSubtitleText((_j = (_h = props.config) === null || _h === void 0 ? void 0 : _h.subtitle) === null || _j === void 0 ? void 0 : _j.text) }))] }), jsxs(ButtonGroup, { children: [hasRightMenu && (jsx(MenuButton, { onClick: toggleDrawer, tabIndex: menuButtonTabIndex })), props.canRefresh && (jsx(RefreshButton, { onClick: props.refreshOnClick, tabIndex: (_l = (_k = props.config) === null || _k === void 0 ? void 0 : _k.actions) === null || _l === void 0 ? void 0 : _l.refreshTabIndex, showInLeft: false, showInRight: false })), props.canMinimize && (jsx(MinimizeButton, { onClick: props.minimizeOnClick, tabIndex: (_o = (_m = props.config) === null || _m === void 0 ? void 0 : _m.actions) === null || _o === void 0 ? void 0 : _o.minimizeTabIndex, showInRight: false })), props.canCancel && (jsx(CancelButton, { onClick: props.cancelOnClick, tabIndex: (_q = (_p = props.config) === null || _p === void 0 ? void 0 : _p.actions) === null || _q === void 0 ? void 0 : _q.cancelTabIndex }))] })] }), drawerOpen ? (jsx("div", { className: "xa-chat-menu-container", children: jsx(ChatMenu, { openFrom: showMenuRight ? "right" : "left", opened: drawerOpen, tabIndex: menuItemsTabIndex, onItemClick: handleMenuItem, items: menuItems }) })) : (jsx(Fragment, {}))] }));
+                            : "", "                     \n                        "), children: [jsx("span", { className: "status-text-title", children: getStatusText(props.accountStatus, (_e = props.config) === null || _e === void 0 ? void 0 : _e.status) }), ((_g = (_f = props.config) === null || _f === void 0 ? void 0 : _f.subtitle) === null || _g === void 0 ? void 0 : _g.enabled) && (jsx("span", { className: "status-text-subtitle", children: renderSubtitleText((_j = (_h = props.config) === null || _h === void 0 ? void 0 : _h.subtitle) === null || _j === void 0 ? void 0 : _j.text) }))] }), jsxs(ButtonGroup, { children: [hasRightMenu && (jsx(MenuButton, { onClick: toggleDrawer, tabIndex: menuButtonTabIndex })), debugMode && jsx(ExportButton, {}), props.canRefresh && (jsx(RefreshButton, { onClick: props.refreshOnClick, tabIndex: (_l = (_k = props.config) === null || _k === void 0 ? void 0 : _k.actions) === null || _l === void 0 ? void 0 : _l.refreshTabIndex, showInLeft: false, showInRight: false })), props.canMinimize && (jsx(MinimizeButton, { onClick: props.minimizeOnClick, tabIndex: (_o = (_m = props.config) === null || _m === void 0 ? void 0 : _m.actions) === null || _o === void 0 ? void 0 : _o.minimizeTabIndex, showInRight: false })), props.canCancel && (jsx(CancelButton, { onClick: props.cancelOnClick, tabIndex: (_q = (_p = props.config) === null || _p === void 0 ? void 0 : _p.actions) === null || _q === void 0 ? void 0 : _q.cancelTabIndex }))] })] }), drawerOpen ? (jsx("div", { className: "xa-chat-menu-container", children: jsx(ChatMenu, { openFrom: showMenuRight ? "right" : "left", opened: drawerOpen, tabIndex: menuItemsTabIndex, onItemClick: handleMenuItem, items: menuItems }) })) : (jsx(Fragment, {}))] }));
 };
 
 var UnknownMessage = function () { return jsx(Fragment, {}); };
@@ -9028,7 +10735,8 @@ var ChatMessagePart = function (props) {
     var containerClass = "xappw-chat-msg-part" +
         (position === "below" ? " xappw-chat-msg-part--avatar-below" : "") +
         (position === "bottom" ? " xappw-chat-msg-part--avatar-bottom" : "") +
-        (props.fullWidth ? " xappw-chat-msg-part--full-width" : "");
+        (props.fullWidth ? " xappw-chat-msg-part--full-width" : "") +
+        (props.isStreaming ? " xappw-chat-msg-part--streaming" : "");
     var user = props.user, hideUserInfo = props.hideUserInfo;
     // Hide user info if hideUserInfo is true and position is "bottom"
     var shouldHideUserInfo = hideUserInfo && position === "bottom";
@@ -9526,12 +11234,169 @@ var ChatPermissionMessage = function (props) {
     return (jsxs("div", { className: "chat-msg", children: [jsx("span", { className: "message-sr-only", children: "at " + props.time + (agentMessage ? " the bot said" : " the user said") }), jsxs("div", { className: "buttons-container", children: [jsx(ActionButton, { label: allowLabel, addClass: "button", onClick: handleAllow }), jsx(ActionButton, { label: denyLabel, addClass: "button", onClick: handleDeny })] })] }));
 };
 
+var CopyButton = function (_a) {
+    var text = _a.text;
+    var _b = useState(false), copied = _b[0], setCopied = _b[1];
+    var handleCopy = function (e) { return __awaiter$1(void 0, void 0, void 0, function () {
+        var textarea;
+        return __generator$1(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    e.stopPropagation();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, navigator.clipboard.writeText(text)];
+                case 2:
+                    _b.sent();
+                    setCopied(true);
+                    setTimeout(function () { return setCopied(false); }, 1500);
+                    return [3 /*break*/, 4];
+                case 3:
+                    _b.sent();
+                    textarea = document.createElement("textarea");
+                    textarea.value = text;
+                    document.body.appendChild(textarea);
+                    textarea.select();
+                    document.execCommand("copy");
+                    document.body.removeChild(textarea);
+                    setCopied(true);
+                    setTimeout(function () { return setCopied(false); }, 1500);
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); };
+    return (jsx("button", { className: "tool-call-item__copy-btn", onClick: handleCopy, title: "Copy to clipboard", children: copied ? "✓" : "⧉" }));
+};
+/**
+ * Gets the display text for a tool call, using fallback chain:
+ * label -> displayName -> toolName -> "Working..."
+ */
+var getDisplayLabel = function (toolCall) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = toolCall.label) !== null && _a !== void 0 ? _a : toolCall.displayName) !== null && _b !== void 0 ? _b : toolCall.name) !== null && _c !== void 0 ? _c : "Working...";
+};
+/**
+ * User-friendly tool progress item (non-debug mode)
+ * Shows just the label with a spinner or checkmark
+ */
+var ToolProgressItem = function (_a) {
+    var toolCall = _a.toolCall;
+    var label = getDisplayLabel(toolCall);
+    return (jsxs("div", { className: "tool-progress-item ".concat(toolCall.isExecuting ? "tool-progress-item--executing" : "", " ").concat(toolCall.error ? "tool-progress-item--error" : ""), children: [jsx("span", { className: "tool-progress-item__icon", children: toolCall.isExecuting ? (jsx("span", { className: "tool-progress-item__spinner", "aria-label": "executing" })) : toolCall.error ? (jsx("span", { className: "tool-progress-item__status tool-progress-item__status--error", children: "!" })) : (jsx("span", { className: "tool-progress-item__status tool-progress-item__status--success", children: "\u2713" })) }), jsx("span", { className: "tool-progress-item__label", children: label })] }));
+};
+/**
+ * Debug mode tool call item with expandable details
+ * Shows label, tool name, and expandable input/output
+ */
+var ToolCallItem = function (_a) {
+    var toolCall = _a.toolCall;
+    var _b = useState(false), isExpanded = _b[0], setIsExpanded = _b[1];
+    var toggleExpanded = function () { return setIsExpanded(!isExpanded); };
+    var formatJson = function (data) {
+        if (data === undefined || data === null)
+            return "";
+        try {
+            // If it's a string, try to parse it as JSON first (server may send stringified JSON)
+            if (typeof data === "string") {
+                try {
+                    var parsed = JSON.parse(data);
+                    return JSON.stringify(parsed, null, 2);
+                }
+                catch (_a) {
+                    // Not valid JSON, return as-is
+                    return data;
+                }
+            }
+            return JSON.stringify(data, null, 2);
+        }
+        catch (_b) {
+            return String(data);
+        }
+    };
+    var label = getDisplayLabel(toolCall);
+    var duration = toolCall.endTime
+        ? "".concat(((toolCall.endTime - toolCall.startTime) / 1000).toFixed(2), "s")
+        : null;
+    var hasInput = toolCall.input !== undefined && toolCall.input !== null;
+    var hasResult = toolCall.result !== undefined && toolCall.result !== null;
+    var hasError = !!toolCall.error;
+    return (jsxs("div", { className: "tool-call-item ".concat(toolCall.isExecuting ? "tool-call-item--executing" : ""), children: [jsxs("button", { className: "tool-call-item__header", onClick: toggleExpanded, "aria-expanded": isExpanded, children: [jsx("span", { className: "tool-call-item__icon", children: toolCall.isExecuting ? (jsx("span", { className: "tool-call-item__spinner", "aria-label": "executing" })) : toolCall.error ? (jsx("span", { className: "tool-call-item__status tool-call-item__status--error", children: "!" })) : (jsx("span", { className: "tool-call-item__status tool-call-item__status--success", children: "\u2713" })) }), jsxs("span", { className: "tool-call-item__info", children: [jsx("span", { className: "tool-call-item__label", children: label }), jsx("span", { className: "tool-call-item__name", children: toolCall.name })] }), duration && jsx("span", { className: "tool-call-item__duration", children: duration }), jsx("span", { className: "tool-call-item__chevron ".concat(isExpanded ? "tool-call-item__chevron--expanded" : ""), children: "\u25BE" })] }), isExpanded && (jsxs("div", { className: "tool-call-item__content", children: [hasInput && (jsxs("div", { className: "tool-call-item__section", children: [jsxs("div", { className: "tool-call-item__section-header", children: [jsx("span", { className: "tool-call-item__section-label", children: "Input" }), jsx(CopyButton, { text: formatJson(toolCall.input) })] }), jsx("pre", { className: "tool-call-item__code", children: formatJson(toolCall.input) })] })), hasResult && (jsxs("div", { className: "tool-call-item__section", children: [jsxs("div", { className: "tool-call-item__section-header", children: [jsx("span", { className: "tool-call-item__section-label", children: "Output" }), jsx(CopyButton, { text: formatJson(toolCall.result) })] }), jsx("pre", { className: "tool-call-item__code", children: formatJson(toolCall.result) })] })), hasError && (jsxs("div", { className: "tool-call-item__section", children: [jsxs("div", { className: "tool-call-item__section-header", children: [jsx("span", { className: "tool-call-item__section-label tool-call-item__section-label--error", children: "Error" }), jsx(CopyButton, { text: toolCall.error || "" })] }), jsx("pre", { className: "tool-call-item__code tool-call-item__code--error", children: toolCall.error })] })), !hasInput && !hasResult && !hasError && (jsx("div", { className: "tool-call-item__empty", children: "No data available" }))] }))] }));
+};
+var ToolCallDisplay = function (_a) {
+    var toolCalls = _a.toolCalls, _b = _a.debugMode, debugMode = _b === void 0 ? false : _b;
+    if (!toolCalls || toolCalls.length === 0) {
+        return null;
+    }
+    // Debug mode: show all tools with full expandable details
+    if (debugMode) {
+        return (jsxs("div", { className: "tool-call-display", children: [jsxs("div", { className: "tool-call-display__header", children: [jsx("span", { className: "tool-call-display__icon", children: "\u2699" }), jsxs("span", { className: "tool-call-display__title", children: ["Tool Calls (", toolCalls.length, ")"] })] }), jsx("div", { className: "tool-call-display__list", children: toolCalls.map(function (toolCall, index) { return (jsx(ToolCallItem, { toolCall: toolCall }, "".concat(toolCall.name, "-").concat(toolCall.startTime, "-").concat(index))); }) })] }));
+    }
+    // Normal mode: filter out hidden tools and show user-friendly progress
+    var visibleToolCalls = toolCalls.filter(function (tc) { return !tc.hidden; });
+    if (visibleToolCalls.length === 0) {
+        return null;
+    }
+    return (jsx("div", { className: "tool-progress-display", children: visibleToolCalls.map(function (toolCall, index) { return (jsx(ToolProgressItem, { toolCall: toolCall }, "".concat(toolCall.name, "-").concat(toolCall.startTime, "-").concat(index))); }) }));
+};
+
+/**
+ * Parses basic markdown to HTML.
+ * Supports: bold, italic, links, headers, and unordered lists.
+ */
+function parseMarkdown(text) {
+    if (!text)
+        return "";
+    var html = text
+        // Escape HTML entities first
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        // Headers (must be at start of line)
+        .replace(/^### (.+)$/gm, "<h4>$1</h4>")
+        .replace(/^## (.+)$/gm, "<h3>$1</h3>")
+        .replace(/^# (.+)$/gm, "<h2>$1</h2>")
+        // Bold (** or __)
+        .replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>")
+        .replace(/__(.+?)__/g, "<strong>$1</strong>")
+        // Italic (* or _) - must come after bold
+        .replace(/\*([^*]+?)\*/g, "<em>$1</em>")
+        .replace(/_([^_]+?)_/g, "<em>$1</em>")
+        // Links [text](url)
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>')
+        // Unordered lists (- or *)
+        .replace(/^[-*] (.+)$/gm, "<li>$1</li>")
+        // Line breaks
+        .replace(/\n/g, "<br>");
+    // Wrap consecutive <li> elements in <ul>
+    html = html.replace(/(<li>.*?<\/li>)(<br>)?/g, "$1");
+    html = html.replace(/(<li>.*?<\/li>)+/g, "<ul>$&</ul>");
+    // Clean up <br> inside <ul>
+    html = html.replace(/<ul>(.*?)<\/ul>/g, function (match) {
+        return match.replace(/<br>/g, "");
+    });
+    return html;
+}
 var ChatTextMessage = function (props) {
+    var _a;
     var message = props.message;
     var date = new Date(message.timestamp);
     var time = date.getHours() + ":" + date.getMinutes();
-    var agentMessage = isAgent(props.message.user.nick);
-    return (jsx("div", { className: "chat-msg", children: jsx("div", { className: "chat-text-container", children: jsxs(ChatMessageBubble, { owner: agentMessage ? "others" : "mine", hasTail: agentMessage && !props.sibling, children: [jsx("span", { className: "message-sr-only", children: "at " + time + (agentMessage ? " the bot said" : " the user said") }), jsx("span", { children: message.msg.text })] }) }) }));
+    var agentMessage = isAgent((_a = props.message.user) === null || _a === void 0 ? void 0 : _a.nick);
+    var isStreaming = message.isStreaming;
+    // Parse markdown for agent messages
+    var parsedHtml = useMemo(function () {
+        if (agentMessage && message.msg.text) {
+            return parseMarkdown(message.msg.text);
+        }
+        return null;
+    }, [agentMessage, message.msg.text]);
+    // No tail for streaming messages (or messages that were streamed)
+    var wasStreamed = message.wasStreamed;
+    var showTail = agentMessage && !props.sibling && !isStreaming && !wasStreamed;
+    var hasToolCalls = props.toolCalls && props.toolCalls.length > 0;
+    return (jsxs("div", { className: "chat-msg".concat(isStreaming ? " chat-msg--streaming" : ""), children: [hasToolCalls && (jsx(ToolCallDisplay, { toolCalls: props.toolCalls, debugMode: props.debugMode })), jsx("div", { className: "chat-text-container", children: jsxs(ChatMessageBubble, { owner: agentMessage ? "others" : "mine", hasTail: showTail, children: [jsx("span", { className: "message-sr-only", children: "at " + time + (agentMessage ? (isStreaming ? " the bot is typing" : " the bot said") : " the user said") }), parsedHtml ? (jsx("span", { className: "chat-msg__content", dangerouslySetInnerHTML: { __html: parsedHtml } })) : (jsx("span", { className: "chat-msg__content", children: message.msg.text })), isStreaming && jsx("span", { className: "streaming-cursor", "aria-hidden": "true" })] }) })] }));
 };
 
 var ChatScheduleWidget = function (props) {
@@ -9545,6 +11410,24 @@ var ChatScheduleWidget = function (props) {
     return (jsx("div", { className: "chat-schedule-button-container", children: jsxs("button", { className: "chat-schedule-button", onClick: handleClick, children: [jsx("i", { className: "fa fa-lg fa-calendar" }), jsx("span", { children: display.label || "Schedule Now!" })] }) }));
 };
 
+/**
+ * Displays source links below a chat message.
+ * Designed to be compact and unobtrusive, unlike suggestion chips.
+ */
+var SourceLinks = function (props) {
+    var sources = props.sources, _a = props.prefix, prefix = _a === void 0 ? "Sources:" : _a, onSourceClick = props.onSourceClick;
+    if (!sources || sources.length === 0) {
+        return null;
+    }
+    var handleClick = function (source, e) {
+        if (onSourceClick) {
+            e.preventDefault();
+            onSourceClick(source);
+        }
+    };
+    return (jsxs("div", { className: "source-links", children: [prefix && jsx("span", { className: "source-links__prefix", children: prefix }), jsx("span", { className: "source-links__list", children: sources.map(function (source, index) { return (jsxs("span", { className: "source-links__item", children: [jsx("a", { href: source.url, target: source.newTab !== false ? "_blank" : "_self", rel: source.newTab !== false ? "noopener noreferrer" : undefined, className: "source-links__link", onClick: function (e) { return handleClick(source, e); }, title: source.url, children: source.title }), index < sources.length - 1 && (jsx("span", { className: "source-links__separator", children: "\u00B7" }))] }, index)); }) })] }));
+};
+
 function getClassName(msg) {
     return isAgent(msg.user.nick) ? "agent" : "visitor";
 }
@@ -9556,7 +11439,7 @@ var avaKeys = ["text", "html", "card", "list"];
  * @returns
  */
 var ChatMessage = function (props) {
-    var _a;
+    var _a, _b, _c;
     var middleware = props.messageMiddleware || StandardMiddlewares;
     var chatConfig = useContext(ChatConfigContext);
     // console.log(`########### chatConfig: ${JSON.stringify(chatConfig, null, 2)}`);
@@ -9566,7 +11449,7 @@ var ChatMessage = function (props) {
     var agentInfo = (_a = props.agents) === null || _a === void 0 ? void 0 : _a[props.message.user.nick];
     var hideUserInfo = (agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.hideUserInfo) || false;
     function renderByType() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
         var msg = props.message.msg;
         switch (props.message.type) {
             // TODO: props actually requires it to be "chat.msg". Fix prop typing?
@@ -9574,27 +11457,42 @@ var ChatMessage = function (props) {
                 // Here is the deal. If we have text (output speech), then text - card - list - options
                 // OR card OR list only. Avatar with text bubble.
                 var avaKey = avaKeys.find(function (key) { return !!msg[key]; });
-                return (jsxs(Fragment, { children: [msg.text &&
-                            jsx(ChatMessagePart, { showAvatar: avaKey === "text", user: user, avatarPosition: (_c = (_b = (_a = chatConfig === null || chatConfig === void 0 ? void 0 : chatConfig.env) === null || _a === void 0 ? void 0 : _a.theme) === null || _b === void 0 ? void 0 : _b.messages) === null || _c === void 0 ? void 0 : _c.avatarPosition, hideUserInfo: hideUserInfo, children: jsx(ChatTextMessage, { message: props.message, sibling: props.sibling }) }), msg.html &&
-                            jsx(ChatMessagePart, { showAvatar: avaKey === "html", user: user, avatarPosition: (_f = (_e = (_d = chatConfig === null || chatConfig === void 0 ? void 0 : chatConfig.env) === null || _d === void 0 ? void 0 : _d.theme) === null || _e === void 0 ? void 0 : _e.messages) === null || _f === void 0 ? void 0 : _f.avatarPosition, hideUserInfo: hideUserInfo, children: jsx(ChatMarkdownMessage, { message: props.message, sibling: props.sibling, onOpenUrl: (_g = props.middlewareContext) === null || _g === void 0 ? void 0 : _g.openUrl }) }), msg.displays && middleware && msg.displays.map(function (display, index) {
+                var isStreaming_1 = props.message.isStreaming;
+                var wasStreamed = props.message.wasStreamed;
+                // Tool calls - show progress while tools execute (before text arrives)
+                var toolCalls = props.message.toolCalls;
+                var hasToolCalls = toolCalls && toolCalls.length > 0;
+                var debugMode = (_d = (_c = (_b = (_a = chatConfig === null || chatConfig === void 0 ? void 0 : chatConfig.env) === null || _a === void 0 ? void 0 : _a.connection) === null || _b === void 0 ? void 0 : _b.mcp) === null || _c === void 0 ? void 0 : _c.debugMode) !== null && _d !== void 0 ? _d : false;
+                // Show tool progress with avatar when no text yet, or above text when text exists
+                var showToolProgressWithAvatar = hasToolCalls && !msg.text;
+                return (jsxs(Fragment, { children: [showToolProgressWithAvatar && (jsx(ChatMessagePart, { showAvatar: true, user: user, avatarPosition: (_g = (_f = (_e = chatConfig === null || chatConfig === void 0 ? void 0 : chatConfig.env) === null || _e === void 0 ? void 0 : _e.theme) === null || _f === void 0 ? void 0 : _f.messages) === null || _g === void 0 ? void 0 : _g.avatarPosition, hideUserInfo: hideUserInfo, isStreaming: true, children: jsx("div", { className: "chat-msg", children: jsx(ToolCallDisplay, { toolCalls: toolCalls, debugMode: debugMode }) }) })), msg.text && (jsx(ChatMessagePart, { showAvatar: avaKey === "text", user: user, avatarPosition: (_k = (_j = (_h = chatConfig === null || chatConfig === void 0 ? void 0 : chatConfig.env) === null || _h === void 0 ? void 0 : _h.theme) === null || _j === void 0 ? void 0 : _j.messages) === null || _k === void 0 ? void 0 : _k.avatarPosition, hideUserInfo: hideUserInfo, isStreaming: isStreaming_1 || wasStreamed, children: jsx(ChatTextMessage, { message: props.message, sibling: props.sibling, user: user, toolCalls: hasToolCalls ? toolCalls : undefined, debugMode: debugMode }) })), msg.html &&
+                            jsx(ChatMessagePart, { showAvatar: avaKey === "html", user: user, avatarPosition: (_o = (_m = (_l = chatConfig === null || chatConfig === void 0 ? void 0 : chatConfig.env) === null || _l === void 0 ? void 0 : _l.theme) === null || _m === void 0 ? void 0 : _m.messages) === null || _o === void 0 ? void 0 : _o.avatarPosition, hideUserInfo: hideUserInfo, children: jsx(ChatMarkdownMessage, { message: props.message, sibling: props.sibling, onOpenUrl: (_p = props.middlewareContext) === null || _p === void 0 ? void 0 : _p.openUrl }) }), msg.displays && middleware && msg.displays.map(function (display, index) {
                             if (display.type === "ScheduleButton") {
                                 return (jsx(ChatScheduleWidget, { minimizeOnClick: props.minimizeOnClick, display: display }));
                             }
                             var Middleware = middleware;
                             return (jsx(Middleware, { msg: display, ctx: props.middlewareContext }, index));
                         }), msg.permissionRequest && ctx &&
-                            jsx(ChatMessagePart, { showAvatar: avaKey === "permissionRequest", user: user, avatarPosition: (_k = (_j = (_h = chatConfig === null || chatConfig === void 0 ? void 0 : chatConfig.env) === null || _h === void 0 ? void 0 : _h.theme) === null || _j === void 0 ? void 0 : _j.messages) === null || _k === void 0 ? void 0 : _k.avatarPosition, hideUserInfo: hideUserInfo, children: jsx(ChatPermissionMessage, { message: props.message, sibling: props.sibling, ctx: ctx }) })] }));
+                            jsx(ChatMessagePart, { showAvatar: avaKey === "permissionRequest", user: user, avatarPosition: (_s = (_r = (_q = chatConfig === null || chatConfig === void 0 ? void 0 : chatConfig.env) === null || _q === void 0 ? void 0 : _q.theme) === null || _r === void 0 ? void 0 : _r.messages) === null || _s === void 0 ? void 0 : _s.avatarPosition, hideUserInfo: hideUserInfo, children: jsx(ChatPermissionMessage, { message: props.message, sibling: props.sibling, ctx: ctx }) })] }));
         }
         return (jsx(Fragment, {}));
     }
-    function renderTimestamp() {
+    function renderTimestampAndSources() {
+        var _a;
         var timestamp = props.message.timestamp;
         var ts = new Date(timestamp);
         var timeAgo = getTimeAgo(ts);
-        return (jsx("div", { className: "chat-msg-timestamp ".concat(isAgent(props.message.user.nick) ? "agent" : "visitor"), children: jsx("span", { children: timeAgo }) }));
-    }
+        var sources = (_a = props.message.msg) === null || _a === void 0 ? void 0 : _a.sources;
+        var hasSources = sources && sources.length > 0;
+        var isAgentMessage = isAgent(props.message.user.nick);
+        return (jsxs("div", { className: "chat-msg-footer ".concat(isAgentMessage ? "agent" : "visitor"), children: [jsx("span", { className: "chat-msg-timestamp", children: timeAgo }), hasSources && (jsx(SourceLinks, { sources: sources.map(function (s) { return ({ title: s.title, url: s.url, newTab: s.newTab }); }) }))] }));
+    }
+    // Don't show timestamp/sources while streaming or if message has no content yet
+    var isStreaming = props.message.isStreaming;
+    var hasContent = !!(((_b = props.message.msg) === null || _b === void 0 ? void 0 : _b.text) || ((_c = props.message.msg) === null || _c === void 0 ? void 0 : _c.html));
+    var showFooter = !isStreaming && hasContent;
     // empty
-    return (jsx("div", { className: "chat-msg-container-wrapper ".concat(isAgent(props.message.user.nick) ? "agent" : "visitor", " ").concat(props.sibling ? "sibling" : ""), children: jsxs("div", { className: "chat-msg-container ".concat(getClassName(props.message)), children: [renderByType(), renderTimestamp()] }) }));
+    return (jsx("div", { className: "chat-msg-container-wrapper ".concat(isAgent(props.message.user.nick) ? "agent" : "visitor", " ").concat(props.sibling ? "sibling" : ""), children: jsxs("div", { className: "chat-msg-container ".concat(getClassName(props.message)), children: [renderByType(), showFooter && renderTimestampAndSources()] }) }));
 };
 
 /**
@@ -33546,7 +35444,7 @@ var ChatWidgetConnected = function (props) {
  * Exported for use by StaticChatWidgetContainer to avoid infinite loops.
  */
 var ChatWidgetUI = function (props) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14;
     var innerDispatch = useChatDispatch();
     var dispatch = useChatServerDispatch();
     // From Redux
@@ -33576,12 +35474,12 @@ var ChatWidgetUI = function (props) {
         chatState.visuals = {};
     }
     // Our state - pull from storage
-    var _10 = useState((!canMinimize && !canCancel) ||
+    var _15 = useState((!canMinimize && !canCancel) ||
         // !!get("visible") ||
         chatState.visuals.visible ||
         (((_m = props.config) === null || _m === void 0 ? void 0 : _m.autoOpenOnWidth) &&
-            window.matchMedia("(min-width: ".concat((_o = props.config) === null || _o === void 0 ? void 0 : _o.autoOpenOnWidth, ")")).matches)), visible = _10[0], setVisibleState = _10[1];
-    var _11 = useState(false); _11[0]; var setTypingState = _11[1]; // false initially - state kept for potential external observers
+            window.matchMedia("(min-width: ".concat((_o = props.config) === null || _o === void 0 ? void 0 : _o.autoOpenOnWidth, ")")).matches)), visible = _15[0], setVisibleState = _15[1];
+    var _16 = useState(false); _16[0]; var setTypingState = _16[1]; // false initially - state kept for potential external observers
     // Ref to track typing state for use in timeout callbacks
     var typingRef = useRef(false);
     // Timeout ref for debouncing "stop typing" events
@@ -33627,7 +35525,7 @@ var ChatWidgetUI = function (props) {
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
-    var _12 = useState(!document.hidden), isTabVisible = _12[0], setIsTabVisible = _12[1];
+    var _17 = useState(!document.hidden), isTabVisible = _17[0], setIsTabVisible = _17[1];
     useEffect(function () {
         var handleVisibilityChange = function () {
             setIsTabVisible(!document.hidden);
@@ -33839,8 +35737,8 @@ var ChatWidgetUI = function (props) {
         }));
     }
     // Action Bar state and handlers
-    var _13 = useState(false), formModalOpen = _13[0], setFormModalOpen = _13[1];
-    var _14 = useState(null), activeFormConfig = _14[0], setActiveFormConfig = _14[1];
+    var _18 = useState(false), formModalOpen = _18[0], setFormModalOpen = _18[1];
+    var _19 = useState(null), activeFormConfig = _19[0], setActiveFormConfig = _19[1];
     var handleFormButtonClick = useCallback(function (formButton) {
         // If form-widget is configured, use its openForm API
         // The form-widget script should already be pre-loaded
@@ -33954,7 +35852,9 @@ var ChatWidgetUI = function (props) {
         avatarPath: config.avatarUrl,
         display_name: "Agent",
     };
-    return (jsxs(Fragment, { children: [jsxs("div", { className: "widget-container ".concat(modeClass, " ").concat(getVisibilityClass()).concat(actionBarEnabled ? " widget-container--with-action-bar" : ""), children: [jsx(WidgetStylesheet, { theme: config === null || config === void 0 ? void 0 : config.theme }), jsx(ChatHeader, { accountStatus: chatState.accountStatus, refreshOnClick: handleRestartClick, minimizeOnClick: handleMinimizeClick, cancelOnClick: handleCancelClick, agent: widgetAgent, canRefresh: canRefresh, canMinimize: canMinimize, canCancel: canCancel, config: config === null || config === void 0 ? void 0 : config.header, menuConfig: config.menu, onSubmit: handleOnSubmit }), jsx(MessageList, { visible: visible, queuePosition: chatState.queuePosition, isChatting: chatState.isChatting, isOffline: isOffline, messages: messages, agents: chatState.agents, agent: config === null || config === void 0 ? void 0 : config.agent, lastRatingRequestTimestamp: chatState.lastRatingRequestTimestamp, hasRating: chatState.hasRating, visitorId: chatState.visitorId, hasWsButton: !!chatState.wsButton, messageMiddleware: props.messageMiddleware, textTypingStatusEnabled: (_x = (_w = props.config) === null || _w === void 0 ? void 0 : _w.typingStatus) === null || _x === void 0 ? void 0 : _x.textTypingStatusEnabled, disableAutoScroll: props.disableAutoScroll, onSend: handleSendMessage, onWrite: handleWriteMessage, onOpenUrl: handleOpenUrl, minimizeOnClick: handleMinimizeClick }), jsx("div", { className: "xa-spinner-container ".concat(visible && connectionStatus === "pending" ? "visible" : ""), children: jsx("div", { className: "xa-spinner" }) }), connectionStatus === "offline" && jsx(ServerOffline, {}), chatState.wsButton && visible && (jsx(WsButton, { button: chatState.wsButton, onPress: handleWsButtonPress })), jsx(ChatFooter, { isAdmin: config === null || config === void 0 ? void 0 : config.isAdmin, isChatting: chatState.isChatting, placeholder: (_y = config === null || config === void 0 ? void 0 : config.input) === null || _y === void 0 ? void 0 : _y.placeholder, sendButtonIcon: (_0 = (_z = config === null || config === void 0 ? void 0 : config.footer) === null || _z === void 0 ? void 0 : _z.sendButton) === null || _0 === void 0 ? void 0 : _0.icon, sendButtonIconHover: (_2 = (_1 = config === null || config === void 0 ? void 0 : config.footer) === null || _1 === void 0 ? void 0 : _1.sendButton) === null || _2 === void 0 ? void 0 : _2.iconHover, sendButtonIconDisabled: (_4 = (_3 = config === null || config === void 0 ? void 0 : config.footer) === null || _3 === void 0 ? void 0 : _3.sendButton) === null || _4 === void 0 ? void 0 : _4.iconDisabled, visible: visible, hasWsButton: !!chatState.wsButton, menuConfig: (_5 = props.config) === null || _5 === void 0 ? void 0 : _5.menu, footerConfig: (_6 = props.config) === null || _6 === void 0 ? void 0 : _6.footer, inputConfig: (_7 = props.config) === null || _7 === void 0 ? void 0 : _7.input, disabled: previewMode, onChange: handleOnChange, onSubmit: handleOnSubmit, onFileUpload: handleFileUpload }), jsx("div", { className: "restartModal", ref: modalRef, onClick: handleRestartModalCloseClick, children: jsx(ModalContent, { onClose: handleRestartModalCloseClick, onReset: handleReset }) })] }), actionBarEnabled && config.actionBar ? (jsxs(Fragment, { children: [jsx(ActionBar, { config: config.actionBar, visible: visible, chatDisabled: config.disabled, onChatClick: chatButtonOnClick, onChatMinimize: handleMinimizeClick, onFormClick: handleFormButtonClick }), formModalOpen && activeFormConfig && (jsx(FormModal, { config: activeFormConfig, widgetEnv: config, onClose: handleFormModalClose }))] })) : (jsx(ChatButton, { addClass: visible ? "visible" : "", onClick: chatButtonOnClick, config: config === null || config === void 0 ? void 0 : config.cta, imageUrl: (_8 = config === null || config === void 0 ? void 0 : config.chatButton) === null || _8 === void 0 ? void 0 : _8.imageUrl, visible: visible, hasInteracted: (_9 = chatState.visuals) === null || _9 === void 0 ? void 0 : _9.hasInteracted, onCtaDismiss: handleCtaDismiss })), jsx(ErrorOverlay, { enableErrorOverlay: config === null || config === void 0 ? void 0 : config.enableErrorOverlay })] }));
+    return (jsxs(Fragment, { children: [jsxs("div", { className: "widget-container ".concat(modeClass, " ").concat(getVisibilityClass()).concat(actionBarEnabled ? " widget-container--with-action-bar" : ""), children: [jsx(WidgetStylesheet, { theme: config === null || config === void 0 ? void 0 : config.theme }), jsx(ChatHeader, { accountStatus: chatState.accountStatus, refreshOnClick: handleRestartClick, minimizeOnClick: handleMinimizeClick, cancelOnClick: handleCancelClick, agent: widgetAgent, canRefresh: canRefresh, canMinimize: canMinimize, canCancel: canCancel, config: config === null || config === void 0 ? void 0 : config.header, menuConfig: config.menu, debugMode: (_y = (_x = (_w = props.config) === null || _w === void 0 ? void 0 : _w.connection) === null || _x === void 0 ? void 0 : _x.mcp) === null || _y === void 0 ? void 0 : _y.debugMode, onSubmit: handleOnSubmit }), jsx(MessageList, { visible: visible, queuePosition: chatState.queuePosition, isChatting: chatState.isChatting, isOffline: isOffline, messages: messages, agents: chatState.agents, agent: config === null || config === void 0 ? void 0 : config.agent, lastRatingRequestTimestamp: chatState.lastRatingRequestTimestamp, hasRating: chatState.hasRating, visitorId: chatState.visitorId, hasWsButton: !!chatState.wsButton, messageMiddleware: props.messageMiddleware, textTypingStatusEnabled: (_0 = (_z = props.config) === null || _z === void 0 ? void 0 : _z.typingStatus) === null || _0 === void 0 ? void 0 : _0.textTypingStatusEnabled, disableAutoScroll: props.disableAutoScroll, onSend: handleSendMessage, onWrite: handleWriteMessage, onOpenUrl: handleOpenUrl, minimizeOnClick: handleMinimizeClick }), jsx("div", { className: "xa-spinner-container ".concat(visible && connectionStatus === "pending" ? "visible" : ""), children: jsx("div", { className: "xa-spinner" }) }), connectionStatus === "offline" && jsx(ServerOffline, {}), chatState.wsButton && visible && (jsx(WsButton, { button: chatState.wsButton, onPress: handleWsButtonPress })), jsx(ChatFooter, { isAdmin: config === null || config === void 0 ? void 0 : config.isAdmin, isChatting: chatState.isChatting, placeholder: (_1 = config === null || config === void 0 ? void 0 : config.input) === null || _1 === void 0 ? void 0 : _1.placeholder, sendButtonIcon: (_3 = (_2 = config === null || config === void 0 ? void 0 : config.footer) === null || _2 === void 0 ? void 0 : _2.sendButton) === null || _3 === void 0 ? void 0 : _3.icon, sendButtonIconHover: (_5 = (_4 = config === null || config === void 0 ? void 0 : config.footer) === null || _4 === void 0 ? void 0 : _4.sendButton) === null || _5 === void 0 ? void 0 : _5.iconHover, sendButtonIconDisabled: (_7 = (_6 = config === null || config === void 0 ? void 0 : config.footer) === null || _6 === void 0 ? void 0 : _6.sendButton) === null || _7 === void 0 ? void 0 : _7.iconDisabled, visible: visible, hasWsButton: !!chatState.wsButton, menuConfig: (_8 = props.config) === null || _8 === void 0 ? void 0 : _8.menu, footerConfig: (_9 = props.config) === null || _9 === void 0 ? void 0 : _9.footer, inputConfig: (_10 = props.config) === null || _10 === void 0 ? void 0 : _10.input, disabled: previewMode, onChange: handleOnChange, onSubmit: handleOnSubmit, onFileUpload: handleFileUpload }), jsx("div", { className: "restartModal", ref: modalRef, onClick: handleRestartModalCloseClick, children: jsx(ModalContent, { onClose: handleRestartModalCloseClick, onReset: handleReset }) })] }), actionBarEnabled && config.actionBar ? (jsxs(Fragment, { children: [jsx(ActionBar, { config: __assign(__assign({}, config.actionBar), { 
+                            // Use actionBar.cta if set, otherwise fall back to widget-level cta
+                            cta: (_11 = config.actionBar.cta) !== null && _11 !== void 0 ? _11 : config.cta }), visible: visible, chatDisabled: config.disabled, hasUserInteracted: (_12 = chatState.visuals) === null || _12 === void 0 ? void 0 : _12.hasInteracted, onChatClick: chatButtonOnClick, onChatMinimize: handleMinimizeClick, onFormClick: handleFormButtonClick, onCtaDismiss: handleCtaDismiss }), formModalOpen && activeFormConfig && (jsx(FormModal, { config: activeFormConfig, widgetEnv: config, onClose: handleFormModalClose }))] })) : (jsx(ChatButton, { addClass: visible ? "visible" : "", onClick: chatButtonOnClick, config: config === null || config === void 0 ? void 0 : config.cta, imageUrl: (_13 = config === null || config === void 0 ? void 0 : config.chatButton) === null || _13 === void 0 ? void 0 : _13.imageUrl, visible: visible, hasInteracted: (_14 = chatState.visuals) === null || _14 === void 0 ? void 0 : _14.hasInteracted, onCtaDismiss: handleCtaDismiss })), jsx(ErrorOverlay, { enableErrorOverlay: config === null || config === void 0 ? void 0 : config.enableErrorOverlay })] }));
 };
 /**
  * Top-level wrapper that dispatches between preview mode and connected mode.
@@ -34136,6 +36036,7 @@ function memberLeave(state, detail) {
 }
 
 function resetReducer(state) {
+    var _a;
     if (state === void 0) { state = DEFAULT_STATE; }
     var defaultState = createDefaultState({
         accessToken: state.accessToken,
@@ -34145,6 +36046,8 @@ function resetReducer(state) {
     });
     // If we have an active connection, preserve status to avoid showing offline during reconnect
     var wasOnline = state.connection.connectionStatus === 'online';
+    // Preserve opened state so widget doesn't close on refresh
+    var wasOpened = (_a = state.visuals) === null || _a === void 0 ? void 0 : _a.opened;
     return __assign(__assign({}, defaultState), { connection: __assign(__assign({}, defaultState.connection), { greetingRequested: false, 
             // Generate new nonce to trigger server recreation and start fresh session
             nonce: uuid_1(), 
@@ -34152,8 +36055,11 @@ function resetReducer(state) {
             connectionStatus: wasOnline ? 'online' : defaultState.connection.connectionStatus }), 
         // Preserve accountStatus if we were online to avoid showing offline message during reconnect
         accountStatus: wasOnline ? 'online' : defaultState.accountStatus, visitor: state.visitor, visitorId: state.visitorId, 
-        // Explicitly reset visuals to clear hasInteracted flag for widget refresh
-        visuals: {} });
+        // Reset visuals but preserve opened state so widget stays open during refresh
+        visuals: {
+            opened: wasOpened,
+            hasInteracted: false
+        } });
 }
 
 // Type guard for ChatSystemMessageDetail
@@ -34169,7 +36075,7 @@ function appendMessageToState(state, msg) {
 }
 function update(state, action) {
     var _a, _b, _c, _d;
-    var _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+    var _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
     if (state === void 0) { state = DEFAULT_STATE; }
     log("action", action);
     if (action.type === "reset") {
@@ -34277,6 +36183,121 @@ function update(state, action) {
                 case "chat.typing":
                     var agent = state.agents[action.detail.user.nick];
                     return __assign(__assign({}, state), { lastTimestamp: (_v = action.detail) === null || _v === void 0 ? void 0 : _v.timestamp, agents: __assign(__assign({}, state.agents), (_d = {}, _d[action.detail.user.nick] = __assign(__assign({}, agent), { typing: action.detail.typing }), _d)) });
+                case "chat.stream.start":
+                    // Add placeholder message with streaming state
+                    var streamingMsg = {
+                        type: "chat.msg",
+                        user: action.detail.user,
+                        timestamp: action.detail.timestamp,
+                        msg: {
+                            text: "",
+                        },
+                        isStreaming: true,
+                    };
+                    return __assign(__assign({}, newState), { chats: __spreadArray$1(__spreadArray$1([], newState.chats, true), [streamingMsg], false), streamingMessageId: action.detail.messageId });
+                case "chat.stream.chunk": {
+                    // Find the streaming message by ID and append text
+                    var chunkDetail = action.detail;
+                    if (state.streamingMessageId === chunkDetail.messageId) {
+                        // Find the streaming message by ID (not by index - other messages could be inserted)
+                        var streamingIndex_1 = state.chats.findIndex(function (chat) { return isChatMsgDetail(chat) && chat.isStreaming; });
+                        if (streamingIndex_1 >= 0) {
+                            var chunkText_1 = chunkDetail.text;
+                            return __assign(__assign({}, state), { lastTimestamp: chunkDetail === null || chunkDetail === void 0 ? void 0 : chunkDetail.timestamp, chats: state.chats.map(function (chat, index) {
+                                    var _a;
+                                    if (index === streamingIndex_1 && isChatMsgDetail(chat)) {
+                                        return __assign(__assign({}, chat), { msg: __assign(__assign({}, chat.msg), { text: (((_a = chat.msg) === null || _a === void 0 ? void 0 : _a.text) || "") + chunkText_1 }) });
+                                    }
+                                    return chat;
+                                }) });
+                        }
+                    }
+                    return state;
+                }
+                case "chat.stream.tool_start": {
+                    // Add tool call to the streaming message (in-progress state)
+                    log("Tool execution started: ".concat(action.detail.toolName));
+                    var toolStartDetail_1 = action.detail;
+                    if (state.streamingMessageId === toolStartDetail_1.messageId) {
+                        // Find the streaming message by ID (not by index - other messages could be inserted)
+                        var streamingIndex_2 = state.chats.findIndex(function (chat) { return isChatMsgDetail(chat) && chat.isStreaming; });
+                        if (streamingIndex_2 >= 0) {
+                            return __assign(__assign({}, state), { lastTimestamp: toolStartDetail_1.timestamp, chats: state.chats.map(function (chat, index) {
+                                    if (index === streamingIndex_2 && isChatMsgDetail(chat)) {
+                                        var existingToolCalls = chat.toolCalls || [];
+                                        return __assign(__assign({}, chat), { toolCalls: __spreadArray$1(__spreadArray$1([], existingToolCalls, true), [
+                                                {
+                                                    name: toolStartDetail_1.toolName,
+                                                    toolCallId: toolStartDetail_1.toolCallId,
+                                                    displayName: toolStartDetail_1.displayName,
+                                                    label: toolStartDetail_1.label,
+                                                    hidden: toolStartDetail_1.hidden,
+                                                    input: toolStartDetail_1.toolInput,
+                                                    startTime: toolStartDetail_1.timestamp,
+                                                    isExecuting: true,
+                                                },
+                                            ], false) });
+                                    }
+                                    return chat;
+                                }) });
+                        }
+                    }
+                    return state;
+                }
+                case "chat.stream.tool_end": {
+                    // Update tool call with result in the streaming message
+                    log("Tool execution ended: ".concat(action.detail.toolName));
+                    var toolEndDetail_1 = action.detail;
+                    if (state.streamingMessageId === toolEndDetail_1.messageId) {
+                        // Find the streaming message by ID (not by index - other messages could be inserted)
+                        var streamingIndex_3 = state.chats.findIndex(function (chat) { return isChatMsgDetail(chat) && chat.isStreaming; });
+                        if (streamingIndex_3 >= 0) {
+                            return __assign(__assign({}, state), { lastTimestamp: toolEndDetail_1.timestamp, chats: state.chats.map(function (chat, index) {
+                                    var _a;
+                                    if (index === streamingIndex_3 && isChatMsgDetail(chat)) {
+                                        var toolCalls = (_a = chat.toolCalls) === null || _a === void 0 ? void 0 : _a.map(function (tc) {
+                                            var _a;
+                                            // Match by toolCallId if available, otherwise fall back to name + isExecuting
+                                            var isMatch = toolEndDetail_1.toolCallId
+                                                ? tc.toolCallId === toolEndDetail_1.toolCallId
+                                                : tc.name === toolEndDetail_1.toolName && tc.isExecuting;
+                                            if (isMatch) {
+                                                return __assign(__assign({}, tc), { displayName: toolEndDetail_1.displayName || tc.displayName, label: toolEndDetail_1.label, hidden: (_a = toolEndDetail_1.hidden) !== null && _a !== void 0 ? _a : tc.hidden, result: toolEndDetail_1.toolResult, error: toolEndDetail_1.toolError, endTime: toolEndDetail_1.timestamp, isExecuting: false });
+                                            }
+                                            return tc;
+                                        });
+                                        return __assign(__assign({}, chat), { toolCalls: toolCalls });
+                                    }
+                                    return chat;
+                                }) });
+                        }
+                    }
+                    return state;
+                }
+                case "chat.stream.end": {
+                    // Finalize the streaming message
+                    var endDetail = action.detail;
+                    if (state.streamingMessageId === endDetail.messageId) {
+                        // Find the streaming message by ID (not by index - other messages could be inserted)
+                        var streamingIndex_4 = state.chats.findIndex(function (chat) { return isChatMsgDetail(chat) && chat.isStreaming; });
+                        var endStreamingChat = streamingIndex_4 >= 0 ? state.chats[streamingIndex_4] : undefined;
+                        // Verify it's the right message using type guard
+                        if (streamingIndex_4 >= 0 && endStreamingChat && isChatMsgDetail(endStreamingChat)) {
+                            var finalMsg_1 = endDetail.msg;
+                            // Preserve tool calls from either the action or the existing message
+                            var toolCalls_1 = endDetail.toolCalls || endStreamingChat.toolCalls;
+                            // Update chips from message options (same as chat.msg handler)
+                            var chips = ((_w = finalMsg_1 === null || finalMsg_1 === void 0 ? void 0 : finalMsg_1.options) === null || _w === void 0 ? void 0 : _w.length) ? finalMsg_1.options : [];
+                            return __assign(__assign({}, state), { lastTimestamp: endDetail === null || endDetail === void 0 ? void 0 : endDetail.timestamp, streamingMessageId: undefined, chips: chips, chats: state.chats.map(function (chat, index) {
+                                    if (index === streamingIndex_4 && isChatMsgDetail(chat)) {
+                                        return __assign(__assign({}, chat), { msg: finalMsg_1, isStreaming: false, wasStreamed: true, toolCalls: toolCalls_1 });
+                                    }
+                                    return chat;
+                                }) });
+                        }
+                    }
+                    return state;
+                }
                 default:
                     return state;
             }