@xapp/chat-widget 1.100.0 → 1.101.0

package/dist/index.js

@@ -4644,8 +4644,8 @@ var MCPChat = /** @class */ (function () {
         // Generic fallback
         return "Something went wrong. Please try again.";
     };
-    MCPChat.prototype.dispatchStreamStart = function (messageId) {
-        var bot = this.getBot(undefined);
+    MCPChat.prototype.dispatchStreamStart = function (messageId, user) {
+        var bot = this.getBot(user);
         var streamTimestamp = +new Date();
         log("[dispatchStreamStart] Stream started: ".concat(messageId, ", timestamp: ").concat(streamTimestamp));
         this.dispatch({
@@ -4658,30 +4658,25 @@ var MCPChat = /** @class */ (function () {
             },
         });
     };
-    MCPChat.prototype.dispatchStreamChunk = function (messageId, text) {
+    MCPChat.prototype.dispatchStreamChunk = function (messageId, text, user) {
         this.dispatch({
             type: "chat",
             detail: {
                 type: "chat.stream.chunk",
-                user: this.getBot(undefined),
+                user: this.getBot(user),
                 messageId: messageId,
                 text: text,
                 timestamp: +new Date(),
             },
         });
     };
-    MCPChat.prototype.dispatchStreamEnd = function (messageId, fullMessage, toolCalls) {
+    MCPChat.prototype.dispatchStreamEnd = function (messageId, fullMessage, options) {
+        if (options === void 0) { options = {}; }
+        var toolCalls = options.toolCalls, user = options.user, preserveChips = options.preserveChips;
         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(),
-            },
+            detail: __assign$1(__assign$1({ type: "chat.stream.end", user: this.getBot(user), messageId: messageId, msg: fullMessage, toolCalls: toolCalls }, (preserveChips && { preserveChips: preserveChips })), { timestamp: +new Date() }),
         });
     };
     MCPChat.prototype.dispatchStreamAbort = function (messageId) {
@@ -4791,6 +4786,19 @@ var MCPChat = /** @class */ (function () {
     MCPChat.prototype.bufferStreamText = function (text) {
         this.streamBuffer += text;
     };
+    /**
+     * Dispatches whatever is buffered right now, without waiting on the throttle timer.
+     *
+     * Used when a bubble has to be closed mid-turn (`message_start`): the split has to be
+     * synchronous, because frames arrive in order on one `onmessage` callback and deferring it
+     * to a microtask would let the next `text` frame land in the bubble we are closing.
+     */
+    MCPChat.prototype.flushStreamBufferSync = function () {
+        if (this.streamBuffer.length > 0 && this.streamingMessageIdForThrottle) {
+            this.dispatchStreamChunk(this.streamingMessageIdForThrottle, this.streamBuffer);
+            this.streamBuffer = "";
+        }
+    };
     /**
      * Flushes any remaining buffered text and stops the throttle timer.
      * Returns a promise that resolves when all buffered text has been dispatched.
@@ -5071,7 +5079,7 @@ var MCPChat = /** @class */ (function () {
      */
     MCPChat.prototype.performSSERequest = function (body) {
         return __awaiter$1(this, void 0, void 0, function () {
-            var endpoint, messageId, textChunks, hasError, httpStatusCode, sseError;
+            var endpoint, messageId, bubbleId, bubbleUser, bubbleChunks, hasError, httpStatusCode, sseError;
             var _this = this;
             return __generator$1(this, function (_a) {
                 endpoint = this.getEndpoint();
@@ -5084,7 +5092,8 @@ var MCPChat = /** @class */ (function () {
                 this.abortController = new AbortController();
                 messageId = uuid_1();
                 this.currentMessageId = messageId;
-                textChunks = [];
+                bubbleId = messageId;
+                bubbleChunks = [];
                 hasError = false;
                 return [2 /*return*/, new Promise(function (resolve, reject) {
                         // WARNING: Do not log headers object - it contains sensitive auth tokens
@@ -5115,6 +5124,7 @@ var MCPChat = /** @class */ (function () {
                                 });
                             }); },
                             onmessage: function (event) {
+                                var _a;
                                 // Guard: ignore events from stale/aborted requests
                                 if (_this.currentMessageId !== messageId) {
                                     log("[SSE] Ignoring stale event for messageId: ".concat(messageId, ", current: ").concat(_this.currentMessageId));
@@ -5145,6 +5155,10 @@ var MCPChat = /** @class */ (function () {
                                         if (data.isReplay) {
                                             _this.isReplaying = true;
                                         }
+                                        // A server may name the participant up front.
+                                        if (data.user) {
+                                            bubbleUser = data.user;
+                                        }
                                         // Store identity from server response
                                         if (data.userId || data.sessionId) {
                                             if (data.userId) {
@@ -5164,13 +5178,13 @@ var MCPChat = /** @class */ (function () {
                                         if (data.isReplay) {
                                             // Replay connection — resume into the existing partial
                                             // message instead of creating a duplicate placeholder
-                                            _this.dispatchStreamResume(messageId);
+                                            _this.dispatchStreamResume(bubbleId);
                                         }
                                         else {
                                             // Normal connection — create new streaming placeholder
-                                            _this.dispatchStreamStart(messageId);
+                                            _this.dispatchStreamStart(bubbleId, bubbleUser);
                                         }
-                                        _this.startStreamThrottle(messageId);
+                                        _this.startStreamThrottle(bubbleId);
                                         break;
                                     case "session_expired":
                                         // Session no longer exists on server - need to start fresh
@@ -5188,14 +5202,40 @@ var MCPChat = /** @class */ (function () {
                                         _this.initializeNewSession();
                                         resolve();
                                         break;
+                                    case "message_start": {
+                                        // Close the bubble being streamed and open a new one, optionally
+                                        // under a different participant. This is the only way a turn can
+                                        // render as more than one message: the reducer creates a fresh
+                                        // bubble per `chat.stream.start` and finalizes any still-streaming
+                                        // one, so a server can make a handoff look like someone joining.
+                                        // Servers that never send this are unaffected.
+                                        log("[SSE] message_start \u2014 splitting bubble, user: ".concat((_a = data.user) === null || _a === void 0 ? void 0 : _a.displayName));
+                                        _this.flushStreamBufferSync();
+                                        _this.dispatchStreamEnd(bubbleId, { text: bubbleChunks.join("") }, {
+                                            // Same debug-mode capture as `done`, scoped to this bubble:
+                                            // stream.end replaces a bubble's toolCalls wholesale, so any
+                                            // left in currentToolCalls would reappear on the next one.
+                                            toolCalls: (_this.config.debugMode || _this._debugMode) ? __spreadArray$1([], _this.currentToolCalls, true) : undefined,
+                                            user: bubbleUser,
+                                            // Chips belong to the turn; its final end sets them.
+                                            preserveChips: true,
+                                        });
+                                        _this.currentToolCalls = [];
+                                        bubbleId = uuid_1();
+                                        bubbleChunks = [];
+                                        bubbleUser = data.user;
+                                        _this.dispatchStreamStart(bubbleId, bubbleUser);
+                                        _this.startStreamThrottle(bubbleId);
+                                        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);
+                                            log("[SSE] Text chunk received (".concat(data.text.length, " chars), chunks in this bubble: ").concat(bubbleChunks.length + 1, ", isReplay: ").concat(data.isReplay));
+                                            bubbleChunks.push(data.text);
                                             if (data.isReplay || _this.isSleeping) {
                                                 // Replayed text or tab hidden — dispatch immediately
                                                 // (no throttle timer running in either case)
-                                                _this.dispatchStreamChunk(messageId, data.text);
+                                                _this.dispatchStreamChunk(bubbleId, data.text, bubbleUser);
                                             }
                                             else {
                                                 // Live text — buffer for throttled dispatch
@@ -5219,7 +5259,7 @@ var MCPChat = /** @class */ (function () {
                                             _this.currentToolCalls.push(toolCall);
                                             // Always dispatch tool start for user-friendly progress display
                                             _this.dispatchToolStart({
-                                                messageId: messageId,
+                                                messageId: bubbleId,
                                                 toolName: data.toolName,
                                                 toolCallId: data.toolCallId,
                                                 displayName: data.displayName,
@@ -5260,7 +5300,7 @@ var MCPChat = /** @class */ (function () {
                                             }
                                             // Always dispatch tool end for user-friendly progress display
                                             _this.dispatchToolEnd({
-                                                messageId: messageId,
+                                                messageId: bubbleId,
                                                 toolName: data.toolName,
                                                 toolCallId: data.toolCallId,
                                                 displayName: data.displayName,
@@ -5282,8 +5322,10 @@ var MCPChat = /** @class */ (function () {
                                                 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));
+                                            // The bubble's own text, not the whole turn's — a turn split by
+                                            // `message_start` has already committed its earlier bubbles.
+                                            var accumulatedText = bubbleChunks.join("");
+                                            log("[SSE] Done event received. Chunks in this bubble: ".concat(bubbleChunks.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;
@@ -5299,8 +5341,14 @@ var MCPChat = /** @class */ (function () {
                                             if (sources === null || sources === void 0 ? void 0 : sources.length) {
                                                 log("[SSE] Sources: ".concat(sources.length, " items"));
                                             }
+                                            // `response.response` is request-scoped. For an unsplit turn it is
+                                            // the whole answer, and the fallback serves servers that deliver it
+                                            // only via `done`. Once `message_start` has fired it would copy every
+                                            // earlier bubble's text into this one, so a split turn's bubbles
+                                            // must stream their text as `text` frames.
+                                            var isSplitTurn = bubbleId !== messageId;
                                             var finalMessage_1 = {
-                                                text: accumulatedText || data.response.response || "",
+                                                text: accumulatedText || (isSplitTurn ? "" : data.response.response) || "",
                                                 options: options,
                                                 sources: sources,
                                                 displays: data.response.displays,
@@ -5308,7 +5356,7 @@ var MCPChat = /** @class */ (function () {
                                             // Capture tool calls before flushing (debug mode — config or runtime toggle)
                                             var toolCalls_1 = (_this.config.debugMode || _this._debugMode) ? __spreadArray$1([], _this.currentToolCalls, true) : undefined;
                                             _this.flushStreamBuffer().then(function () {
-                                                _this.dispatchStreamEnd(messageId, finalMessage_1, toolCalls_1);
+                                                _this.dispatchStreamEnd(bubbleId, finalMessage_1, { toolCalls: toolCalls_1, user: bubbleUser });
                                                 _this.currentToolCalls = []; // Clear after dispatch
                                                 resolve();
                                             });
@@ -5348,7 +5396,7 @@ var MCPChat = /** @class */ (function () {
                                         log("[MCPChat] SSE error during sleep - will request replay on wakeup");
                                         _this.needsReplayOnWakeup = true;
                                         if (_this.streamingMessageIdForThrottle) {
-                                            _this.dispatchStreamAbort(messageId);
+                                            _this.dispatchStreamAbort(bubbleId);
                                         }
                                         _this.stopStreamThrottle();
                                     }
@@ -37948,8 +37996,11 @@ function update(state, action) {
                             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 : [];
+                            // Update chips from message options (same as chat.msg handler) — unless this closes
+                            // an intermediate bubble of a split turn, whose chips arrive with the final end.
+                            var chips = endDetail.preserveChips
+                                ? state.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$1(__assign$1({}, 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$1(__assign$1({}, chat), { msg: finalMsg_1, isStreaming: false, wasStreamed: true, toolCalls: toolCalls_1 });