@xapp/chat-widget 1.88.0 → 1.91.0

package/dist/index.es.js

@@ -1899,7 +1899,15 @@ function sendGreeting(PRECHAT_FORM_ENABLED) {
 }
 
 function sendMessage(msg) {
-    return function (chatServer) { return function () {
+    return function (chatServer) { return function (dispatch, getState) {
+        var state = getState();
+        // Don't allow visitor to send message if offline
+        if (state.accountStatus === "offline" && !state.isChatting)
+            return;
+        // Write user message to Redux before server send so it appears above streaming response
+        if (msg.msg) {
+            dispatch(writeMessage(msg.msg, state.visitor, +new Date()));
+        }
         chatServer.sendChatMsgRequest(msg, function () { });
     }; };
 }
@@ -2984,7 +2992,9 @@ function setSessionId(sessionId) {
 
 // Endpoint path constants
 var HOMEOWNER_ENDPOINT_PATH = "/chat/stream";
+var HOMEOWNER_CLOSE_ENDPOINT_PATH = "/chat/close";
 var BUSINESS_OWNER_ENDPOINT_PATH = "/api/chat/stream";
+var BUSINESS_OWNER_CLOSE_ENDPOINT_PATH = "/api/chat/close";
 // Default retry configuration for MCP connections
 var DEFAULT_MCP_RETRY_CONFIG = [
     { retry: 0, delay: 0, text: "" }, // Initial attempt (silent)
@@ -3138,6 +3148,22 @@ function clearStoredLastSeq(sessionId) {
         // sessionStorage may be unavailable
     }
 }
+/**
+ * Returns the current local time as an ISO 8601 string with the local timezone offset.
+ * Unlike toISOString(), this preserves the user's local time zone (e.g. "2024-01-15T14:30:00-04:00")
+ * so the agent server can correctly determine time-of-day context (morning greetings, etc.).
+ */
+function getLocalISOString(date) {
+    if (date === void 0) { date = new Date(); }
+    var offsetMinutes = -date.getTimezoneOffset();
+    var sign = offsetMinutes >= 0 ? "+" : "-";
+    var pad = function (n) { return String(Math.abs(n)).padStart(2, "0"); };
+    var offsetHours = Math.floor(Math.abs(offsetMinutes) / 60);
+    var offsetMins = Math.abs(offsetMinutes) % 60;
+    return ("".concat(date.getFullYear(), "-").concat(pad(date.getMonth() + 1), "-").concat(pad(date.getDate())) +
+        "T".concat(pad(date.getHours()), ":").concat(pad(date.getMinutes()), ":").concat(pad(date.getSeconds())) +
+        "".concat(sign).concat(pad(offsetHours), ":").concat(pad(offsetMins)));
+}
 /**
  * Gets the current page context from browser globals.
  * If an override is provided, uses that instead (useful for testing).
@@ -3146,7 +3172,7 @@ function clearStoredLastSeq(sessionId) {
  * may contain sensitive data (tokens, PII). Only origin + pathname are sent.
  */
 function getPageContext(override) {
-    var localTime = new Date().toISOString();
+    var localTime = getLocalISOString();
     // 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) {
@@ -3198,12 +3224,15 @@ var MCPChat = /** @class */ (function () {
         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;
+        // Sleep/wakeup state for tab backgrounding recovery
+        this.isSleeping = false;
+        this.isRequestingReplay = false;
+        this.needsReplayOnWakeup = 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.sentMessageCount = 0;
         this.config = config;
         this.options = options;
         this.configurableMessages = options === null || options === void 0 ? void 0 : options.configurableMessages;
@@ -3239,6 +3268,7 @@ var MCPChat = /** @class */ (function () {
     }
     MCPChat.prototype.init = function (dispatch) {
         this.dispatch = dispatch;
+        this.sessionStartTime = Date.now();
         var mode = this.config.mode || "homeowner";
         log("MCPChat initialized with mode: ".concat(mode));
         // Warn if not using HTTPS with authentication
@@ -3319,7 +3349,9 @@ var MCPChat = /** @class */ (function () {
             // Page context
             pageContext: getPageContext(this.config.pageContextOverride), 
             // Client timestamp for latency measurement and clock drift detection
-            clientTime: new Date().toISOString() }, additionalData);
+            clientTime: new Date().toISOString(), 
+            // Last sequence number for replay on reconnect
+            lastSeq: this.lastSeq }, additionalData);
     };
     /**
      * Initializes a new session by calling the endpoint with { newSession: true }.
@@ -3392,6 +3424,14 @@ var MCPChat = /** @class */ (function () {
         // homeowner mode - serverUrl should already include appId
         return "".concat(serverUrl).concat(HOMEOWNER_ENDPOINT_PATH);
     };
+    MCPChat.prototype.getCloseEndpoint = function () {
+        var serverUrl = this.config.serverUrl.replace(/\/+$/, "");
+        var mode = this.config.mode || "homeowner";
+        if (mode === "business_owner") {
+            return "".concat(serverUrl).concat(BUSINESS_OWNER_CLOSE_ENDPOINT_PATH);
+        }
+        return "".concat(serverUrl).concat(HOMEOWNER_CLOSE_ENDPOINT_PATH);
+    };
     MCPChat.prototype.sendNewMessage = function (msg, user) {
         log("SERVER: new message: ".concat(JSON.stringify(msg)));
         this.dispatch({
@@ -3542,6 +3582,30 @@ var MCPChat = /** @class */ (function () {
             },
         });
     };
+    MCPChat.prototype.dispatchStreamAbort = function (messageId) {
+        log("[dispatchStreamAbort] Stream aborted: ".concat(messageId));
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.stream.abort",
+                user: this.getBot(undefined),
+                messageId: messageId,
+                timestamp: Date.now(),
+            },
+        });
+    };
+    MCPChat.prototype.dispatchStreamResume = function (messageId) {
+        log("[dispatchStreamResume] Stream resumed: ".concat(messageId));
+        this.dispatch({
+            type: "chat",
+            detail: {
+                type: "chat.stream.resume",
+                user: this.getBot(undefined),
+                messageId: messageId,
+                timestamp: Date.now(),
+            },
+        });
+    };
     MCPChat.prototype.dispatchToolStart = function (params) {
         this.dispatch({
             type: "chat",
@@ -3855,7 +3919,10 @@ var MCPChat = /** @class */ (function () {
                         attempt++;
                         return [3 /*break*/, 3];
                     case 14:
-                        if (!success) {
+                        if (success) {
+                            this.sentMessageCount++;
+                        }
+                        else {
                             log("All MCP retry attempts exhausted");
                         }
                         return [2 /*return*/];
@@ -3907,6 +3974,10 @@ var MCPChat = /** @class */ (function () {
                                 : {})),
                             body: JSON.stringify(body),
                             signal: _this.abortController.signal,
+                            // Keep the connection open when the tab is hidden. Without this,
+                            // fetchEventSource closes and re-POSTs on visibility change, which
+                            // creates duplicate streaming messages and out-of-order responses.
+                            openWhenHidden: true,
                             onopen: function (response) { return __awaiter$1(_this, void 0, void 0, function () {
                                 var error;
                                 return __generator$1(this, function (_a) {
@@ -3923,6 +3994,11 @@ var MCPChat = /** @class */ (function () {
                                 });
                             }); },
                             onmessage: function (event) {
+                                // Guard: ignore events from stale/aborted requests
+                                if (_this.currentMessageId !== messageId) {
+                                    log("[SSE] Ignoring stale event for messageId: ".concat(messageId, ", current: ").concat(_this.currentMessageId));
+                                    return;
+                                }
                                 log("SSE event: ".concat(event.event, ", data: ").concat(event.data));
                                 var eventType = event.event || "message";
                                 var data = {};
@@ -3962,11 +4038,17 @@ var MCPChat = /** @class */ (function () {
                                             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);
+                                        if (data.isReplay) {
+                                            // Replay connection — resume into the existing partial
+                                            // message instead of creating a duplicate placeholder
+                                            _this.dispatchStreamResume(messageId);
+                                        }
+                                        else {
+                                            // Normal connection — create new streaming placeholder
+                                            _this.dispatchStreamStart(messageId);
+                                        }
                                         _this.startStreamThrottle(messageId);
                                         break;
                                     case "session_expired":
@@ -3989,9 +4071,9 @@ var MCPChat = /** @class */ (function () {
                                         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
+                                            if (data.isReplay || _this.isSleeping) {
+                                                // Replayed text or tab hidden — dispatch immediately
+                                                // (no throttle timer running in either case)
                                                 _this.dispatchStreamChunk(messageId, data.text);
                                             }
                                             else {
@@ -4088,6 +4170,7 @@ var MCPChat = /** @class */ (function () {
                                                 text: accumulatedText || data.response.response || "",
                                                 options: options,
                                                 sources: sources,
+                                                displays: data.response.displays,
                                             };
                                             // Capture tool calls before flushing (debug mode)
                                             var toolCalls_1 = _this.config.debugMode ? __spreadArray$1([], _this.currentToolCalls, true) : undefined;
@@ -4125,7 +4208,20 @@ var MCPChat = /** @class */ (function () {
                                 if (_this.currentMessageId === messageId && !hasError) {
                                     hasError = true;
                                     _this.isReplaying = false;
-                                    _this.stopStreamThrottle();
+                                    if (_this.isSleeping) {
+                                        // Connection dropped while tab is hidden — don't treat as
+                                        // normal error. Finalize partial message and request replay
+                                        // when the user returns.
+                                        log("[MCPChat] SSE error during sleep - will request replay on wakeup");
+                                        _this.needsReplayOnWakeup = true;
+                                        if (_this.streamingMessageIdForThrottle) {
+                                            _this.dispatchStreamAbort(messageId);
+                                        }
+                                        _this.stopStreamThrottle();
+                                    }
+                                    else {
+                                        _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;
@@ -4194,23 +4290,138 @@ var MCPChat = /** @class */ (function () {
         }
     };
     MCPChat.prototype.sleep = function () {
-        this.stopStreamThrottle();
-        this.isReplaying = false;
-        if (this.abortController) {
-            this.abortController.abort();
-            this.abortController = undefined;
+        this.isSleeping = true;
+        if (this.streamingMessageIdForThrottle) {
+            // Active stream in progress — keep SSE connection alive so the
+            // response completes naturally while the tab is hidden.
+            this.needsReplayOnWakeup = false;
+            log("[MCPChat] sleep() - stream in progress, keeping SSE connection alive");
+            // Flush any buffered text to Redux immediately
+            if (this.streamBuffer.length > 0) {
+                this.dispatchStreamChunk(this.streamingMessageIdForThrottle, this.streamBuffer);
+                this.streamBuffer = "";
+            }
+            // Stop the visual throttle timer (browsers throttle timers anyway)
+            // but keep streamingMessageIdForThrottle so incoming chunks can be dispatched
+            if (this.streamThrottleTimer) {
+                clearInterval(this.streamThrottleTimer);
+                this.streamThrottleTimer = undefined;
+            }
+            if (this.visibilityHandler) {
+                document.removeEventListener("visibilitychange", this.visibilityHandler);
+                this.visibilityHandler = undefined;
+            }
+        }
+        else {
+            // No active stream — safe to abort the idle connection
+            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.
+        this.isSleeping = false;
+        if (this.streamingMessageIdForThrottle && this.abortController) {
+            // Stream is still in progress — restart the visual throttle
+            log("[MCPChat] wakeup() - stream still in progress, restarting throttle");
+            // Flush accumulated buffer before startStreamThrottle (which resets it)
+            if (this.streamBuffer.length > 0) {
+                this.dispatchStreamChunk(this.streamingMessageIdForThrottle, this.streamBuffer);
+                this.streamBuffer = "";
+            }
+            this.startStreamThrottle(this.streamingMessageIdForThrottle);
+        }
+        else if (this.needsReplayOnWakeup) {
+            this.needsReplayOnWakeup = false;
+            if (this.lastSeq !== undefined && this._sessionId) {
+                // Connection dropped during sleep — request replay of missed events.
+                // Don't set "online" yet — requestReplay is fire-and-forget and the
+                // connection status will be updated by the SSE onopen handler.
+                log("[MCPChat] wakeup() - connection lost during sleep, requesting replay");
+                this.requestReplay();
+                return;
+            }
+            // Cannot replay — missing lastSeq or sessionId
+            err("[MCPChat] wakeup() - cannot replay, missing lastSeq (".concat(this.lastSeq, ") or sessionId (").concat(this._sessionId, ")"));
+        }
         if (this._sessionId) {
             log("[MCPChat] Wakeup - session exists, lastSeq: ".concat(this.lastSeq));
             this.setConnectionStatus("online");
         }
     };
+    MCPChat.prototype.requestReplay = function () {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var error_5;
+            return __generator$1(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.isRequestingReplay) {
+                            log("[MCPChat] Replay already in progress, skipping");
+                            return [2 /*return*/];
+                        }
+                        this.isRequestingReplay = true;
+                        this.typing();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, 4, 5]);
+                        // lastSeq is already included by buildRequestPayload
+                        return [4 /*yield*/, this.performSSERequest(this.buildRequestPayload())];
+                    case 2:
+                        // lastSeq is already included by buildRequestPayload
+                        _a.sent();
+                        log("[MCPChat] Replay request completed");
+                        return [3 /*break*/, 5];
+                    case 3:
+                        error_5 = _a.sent();
+                        err("[MCPChat] Replay request failed: ".concat(error_5));
+                        this.setConnectionStatus("offline");
+                        return [3 /*break*/, 5];
+                    case 4:
+                        this.stopTyping();
+                        this.isRequestingReplay = false;
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Sends a best-effort close notification to the agent server.
+     * Uses navigator.sendBeacon() so the request survives page unload.
+     * Called from the beforeunload event handler and the widget close button.
+     */
+    MCPChat.prototype.notifyDisconnecting = function (reason) {
+        if (reason === void 0) { reason = "close_tab"; }
+        if (!this._sessionId) {
+            return;
+        }
+        var endpoint = this.getCloseEndpoint();
+        var payload = JSON.stringify({
+            sessionId: this._sessionId,
+            userId: this._userId || undefined,
+            reason: reason,
+            messageCount: this.sentMessageCount,
+            durationMs: this.sessionStartTime !== undefined ? Date.now() - this.sessionStartTime : 0,
+        });
+        log("[MCPChat] notifyDisconnecting: reason=".concat(reason, ", endpoint=").concat(endpoint));
+        // For widget_close, the page is not unloading so fetch() can be used — it supports
+        // auth headers (needed for business_owner mode) unlike sendBeacon.
+        if (reason === "widget_close" && typeof fetch !== "undefined") {
+            var headers = { "Content-Type": "application/json" };
+            if (this.config.authToken) {
+                headers["Authorization"] = "Bearer ".concat(this.config.authToken);
+            }
+            fetch(endpoint, { method: "POST", headers: headers, body: payload, keepalive: true });
+            return;
+        }
+        if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+            var blob = new Blob([payload], { type: "application/json" });
+            navigator.sendBeacon(endpoint, blob);
+        }
+    };
     MCPChat.prototype.startSession = function (sessionId) {
         // userId priority:
         // 1. Existing server-assigned userId (from localStorage or previous connected event)
@@ -35558,7 +35769,7 @@ var ChatWidgetUI = function (props) {
         var handleBeforeUnload = function () {
             log("beforeunload - notifying router of user disconnecting");
             if (chatServer.notifyDisconnecting) {
-                chatServer.notifyDisconnecting();
+                chatServer.notifyDisconnecting("close_tab");
             }
         };
         window.addEventListener("beforeunload", handleBeforeUnload);
@@ -35712,6 +35923,9 @@ var ChatWidgetUI = function (props) {
     }
     /** Called when cancel is clicked */
     function handleCancelClick() {
+        if (chatServer === null || chatServer === void 0 ? void 0 : chatServer.notifyDisconnecting) {
+            chatServer.notifyDisconnecting("widget_close");
+        }
         // First reset to clear all state
         innerDispatch(reset());
         // Then set hasInteracted to prevent CTA from showing after cancel
@@ -36066,6 +36280,20 @@ function resetReducer(state) {
 function isChatSystemMessage(chat) {
     return chat.type === "chat.systemmessage";
 }
+/**
+ * Find the LAST streaming message index. We must search from the end because
+ * orphan isStreaming messages from interrupted streams may exist earlier in the
+ * array. The active streaming message is always the most recently inserted one.
+ */
+function findLastStreamingIndex(chats) {
+    for (var i = chats.length - 1; i >= 0; i--) {
+        var chat = chats[i];
+        if (isChatMsgDetail(chat) && chat.isStreaming) {
+            return i;
+        }
+    }
+    return -1;
+}
 // todo: create reducer (requires redux-thunk dependency)
 function appendMessageToState(state, msg) {
     state.chats = joinMessages(state.chats, msg);
@@ -36183,8 +36411,19 @@ 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
+                case "chat.stream.start": {
+                    // Clean up any orphan streaming messages from interrupted streams
+                    // before creating the new placeholder.
+                    var cleanedChats = newState.chats.map(function (chat) {
+                        if (isChatMsgDetail(chat) && chat.isStreaming) {
+                            return __assign(__assign({}, chat), { isStreaming: false, wasStreamed: true });
+                        }
+                        return chat;
+                    });
+                    // Add placeholder message with streaming state.
+                    // Use joinMessages (insertSorted by timestamp) instead of append to
+                    // guarantee correct ordering even if events arrive out of order
+                    // (e.g., after an SSE abort/retry during tab backgrounding).
                     var streamingMsg = {
                         type: "chat.msg",
                         user: action.detail.user,
@@ -36194,13 +36433,15 @@ function update(state, action) {
                         },
                         isStreaming: true,
                     };
-                    return __assign(__assign({}, newState), { chats: __spreadArray$1(__spreadArray$1([], newState.chats, true), [streamingMsg], false), streamingMessageId: action.detail.messageId });
+                    var newChats = joinMessages(cleanedChats, streamingMsg);
+                    return __assign(__assign({}, newState), { chats: newChats, 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; });
+                        var streamingIndex_1 = findLastStreamingIndex(state.chats);
                         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) {
@@ -36220,7 +36461,7 @@ function update(state, action) {
                     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; });
+                        var streamingIndex_2 = findLastStreamingIndex(state.chats);
                         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)) {
@@ -36250,7 +36491,7 @@ function update(state, action) {
                     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; });
+                        var streamingIndex_3 = findLastStreamingIndex(state.chats);
                         if (streamingIndex_3 >= 0) {
                             return __assign(__assign({}, state), { lastTimestamp: toolEndDetail_1.timestamp, chats: state.chats.map(function (chat, index) {
                                     var _a;
@@ -36279,7 +36520,7 @@ function update(state, action) {
                     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 streamingIndex_4 = findLastStreamingIndex(state.chats);
                         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)) {
@@ -36298,6 +36539,51 @@ function update(state, action) {
                     }
                     return state;
                 }
+                case "chat.stream.abort": {
+                    // Finalize a streaming message interrupted by connection loss during sleep.
+                    // Keeps whatever partial text is already in the message.
+                    var abortDetail = action.detail;
+                    if (state.streamingMessageId === abortDetail.messageId) {
+                        var streamingIndex_5 = findLastStreamingIndex(state.chats);
+                        if (streamingIndex_5 >= 0) {
+                            return __assign(__assign({}, state), { lastTimestamp: abortDetail.timestamp, streamingMessageId: undefined, chats: state.chats.map(function (chat, index) {
+                                    if (index === streamingIndex_5 && isChatMsgDetail(chat)) {
+                                        return __assign(__assign({}, chat), { isStreaming: false, wasStreamed: true });
+                                    }
+                                    return chat;
+                                }) });
+                        }
+                    }
+                    return state;
+                }
+                case "chat.stream.resume": {
+                    // Re-enable streaming on the last aborted bot message after replay reconnect.
+                    // Targets the most recent wasStreamed message that is NOT currently streaming
+                    // (i.e., the one finalized by chat.stream.abort). Updates streamingMessageId
+                    // so replayed chunks route to the existing message.
+                    // Guard: only resume if no stream is currently active.
+                    var resumeDetail = action.detail;
+                    if (state.streamingMessageId) {
+                        return state;
+                    }
+                    var lastBotIndex_1 = -1;
+                    for (var i = state.chats.length - 1; i >= 0; i--) {
+                        var chat = state.chats[i];
+                        if (isChatMsgDetail(chat) && chat.wasStreamed && !chat.isStreaming) {
+                            lastBotIndex_1 = i;
+                            break;
+                        }
+                    }
+                    if (lastBotIndex_1 >= 0) {
+                        return __assign(__assign({}, state), { lastTimestamp: resumeDetail.timestamp, streamingMessageId: resumeDetail.messageId, chats: state.chats.map(function (chat, index) {
+                                if (index === lastBotIndex_1 && isChatMsgDetail(chat)) {
+                                    return __assign(__assign({}, chat), { isStreaming: true, wasStreamed: false });
+                                }
+                                return chat;
+                            }) });
+                    }
+                    return state;
+                }
                 default:
                     return state;
             }