impact-chatbot 2.3.8 → 2.3.10

package/dist/index.cjs.js

@@ -5837,6 +5837,12 @@ const StepsResponseTab = (props) => {
             ], value: tabValue }) }));
 };
 
+/**
+ * Module-level Map to persist streaming state across component remounts (tab switches).
+ * Keyed by a stable identifier derived from input payload + mode + conversation ID.
+ * This survives the cloneDeep replacement of botData in SmartBot's useEffect.
+ */
+const streamStateMap = new Map();
 /**
  * Formats thinking time to display minutes when appropriate
  * @param {number} seconds - Time in seconds
@@ -5919,9 +5925,13 @@ const StreamedContent = ({ botData }) => {
     const thinkingDoneRef = React.useRef(false);
     const setThinkingContentRef = React.useRef(setThinkingContent); // Store current setThinkingContent function
     const streamTimeoutRef = React.useRef(null); // Ref for stream timeout
-    const messageToStoreRef = React.useRef({
-        // Accumulates the complete response
+    // Stable key for the module-level streamStateMap (survives cloneDeep of botData)
+    const streamKey = React.useRef(`${currentMode}_${activeConversationId}_${JSON.stringify(botData.inputBody)}`).current;
+    // Look up existing stream state from the Map (persists across tab-switch remounts)
+    const existingStreamState = streamStateMap.get(streamKey);
+    const messageToStoreRef = React.useRef(existingStreamState?.messageStore || {
         status: "",
+        currentMode: currentMode,
         chatData: {
             response: "",
             response_heading: "",
@@ -5932,12 +5942,11 @@ const StreamedContent = ({ botData }) => {
                 thinkingHeading: botData?.utilityObject?.thinkingResponse?.thinkingHeading
             },
         },
-        currentMode: currentMode,
         appendedData: {},
         appendedDataFromLastChunk: {},
         initValue: false,
         sessionId: "",
-        uniqueChatId: ""
+        uniqueChatId: "",
     });
     React.useRef(new Set()); // Tracks processed message chunks to prevent duplicates
     React.useRef(""); // Tracks current content before adding new chunk
@@ -5988,239 +5997,171 @@ const StreamedContent = ({ botData }) => {
                     : undefined,
                 timeout: 30000, // 30 second timeout
             }, messageToStoreRef);
+            // Persist source in module-level Map so the connection survives tab-switch unmounts
+            const state = streamStateMap.get(streamKey);
+            if (state) {
+                state.source = sourceRef.current;
+                state.initiated = true;
+            }
             // localStorage.setItem("isStreaming", "true");
             // Handle incoming messages
-            sourceRef.current.addEventListener("message", (event) => {
-                try {
-                    if (currentMode === "agent" && !isThinkingFromParent) {
-                        setIsThinkingFromParent(true);
-                        botData.utilityObject.isThinking = true;
-                        botData.utilityObject.thinkingResponse.isThinking = true;
-                        thinkingStartTimeRef.current = Date.now();
+            attachListeners(sourceRef.current);
+        }
+        catch (error) {
+            console.error("Error processing stream:", error);
+            setContent("Error streaming response. Please try again.");
+            setIsStreaming(false);
+            if (isThinking) {
+                setIsThinking(false);
+                const endTime = Date.now();
+                const duration = Math.round((endTime - thinkingStartTimeRef.current) / 1000);
+                const finalThinkingTime = Math.max(duration, 1); // Ensure at least 1 second
+                setThinkingTime(finalThinkingTime);
+                setShowThoughtDropdown(true);
+                // Store thinking time in messageToStoreRef for persistence
+                messageToStoreRef.current.chatData.thinkingResponse.thinkingTime = finalThinkingTime;
+            }
+        }
+    };
+    /**
+     * Attaches event listeners to an SSE source with generation-based stale detection.
+     * Only the latest mount's listeners will actually update state.
+     */
+    const attachListeners = (source) => {
+        const state = streamStateMap.get(streamKey);
+        const generation = state ? ++state.listenerGeneration : 0;
+        source.addEventListener("message", (event) => {
+            // Skip if this listener is from a stale (previous) mount
+            const currState = streamStateMap.get(streamKey);
+            if (!currState || currState.listenerGeneration !== generation)
+                return;
+            try {
+                if (currentMode === "agent" && !isThinkingFromParent) {
+                    setIsThinkingFromParent(true);
+                    botData.utilityObject.isThinking = true;
+                    botData.utilityObject.thinkingResponse.isThinking = true;
+                    thinkingStartTimeRef.current = Date.now();
+                }
+                const data = JSON.parse(event.data);
+                if (data?.message || data?.status === "step" || data?.status === "thinking" || data?.status === "questions") {
+                    if (data.status === "questions") {
+                        const incomingQuestions = data.widget_data?.[0]?.questions || [];
+                        questionsRef.current = incomingQuestions;
+                        setQuestions(incomingQuestions);
+                        const initialMap = {};
+                        incomingQuestions.forEach((q) => {
+                            initialMap[q] = [
+                                {
+                                    header: "Processing Request",
+                                    sub_header: "Analyzing the current request",
+                                    step_status: "not-completed",
+                                },
+                            ];
+                        });
+                        questionsStepsMapRef.current = initialMap;
+                        setQuestionsStepsMap(lodash.cloneDeep(initialMap));
                     }
-                    const data = JSON.parse(event.data);
-                    if (data?.message || data?.status === "step" || data?.status === "thinking" || data?.status === "questions") {
-                        if (data.status === "questions") {
-                            const incomingQuestions = data.widget_data?.[0]?.questions || [];
-                            questionsRef.current = incomingQuestions;
-                            setQuestions(incomingQuestions);
-                            const initialMap = {};
-                            incomingQuestions.forEach((q) => {
-                                initialMap[q] = [
-                                    {
-                                        header: "Processing Request",
-                                        sub_header: "Analyzing the current request",
-                                        step_status: "not-completed",
-                                    },
-                                ];
+                    else if (data.status === "thinking") {
+                        messageToStoreRef.current.chatData.thinkingResponse.thinkingHeading = "Planning next moves";
+                        // Start thinking if not already started
+                        if (!isThinking) {
+                            setIsThinking(true);
+                        }
+                        // Update thinking content in a more reliable way
+                        const newValue = (thinkingContentRef.current || "") + data.message;
+                        setThinkingContentRef.current(newValue);
+                        thinkingContentRef.current = thinkingContentRef.current + data.message;
+                        messageToStoreRef.current.chatData.thinkingResponse.thinkingStream = newValue;
+                        dispatch(smartBotActions.setThinkingContext({
+                            thinkingHeaderMessage: thinkingHeaderMessageRef.current,
+                            thinkingContent: thinkingContentRef.current,
+                        }));
+                        setThinkingStarted(true);
+                        setIsThinkingFromParent(false);
+                    }
+                    else if (data.status === "step") {
+                        let newStep = data.widget_data[0];
+                        const currentIntent = data.widget_data[0]?.current_intent;
+                        setSteps([...steps, newStep]);
+                        let newSteps = lodash.cloneDeep(stepRef.current);
+                        if (newSteps.length === 1) {
+                            newSteps.forEach((step) => {
+                                step.step_status = "completed";
                             });
-                            questionsStepsMapRef.current = initialMap;
-                            setQuestionsStepsMap(lodash.cloneDeep(initialMap));
                         }
-                        else if (data.status === "thinking") {
-                            messageToStoreRef.current.chatData.thinkingResponse.thinkingHeading = "Planning next moves";
-                            // Start thinking if not already started
-                            if (!isThinking) {
-                                setIsThinking(true);
-                            }
-                            // Update thinking content in a more reliable way
-                            const newValue = (thinkingContentRef.current || "") + data.message;
-                            setThinkingContentRef.current(newValue);
-                            thinkingContentRef.current = thinkingContentRef.current + data.message;
-                            messageToStoreRef.current.chatData.thinkingResponse.thinkingStream = newValue;
-                            // Update the ThinkingIndicator components with the new accumulated content
-                            // messageToStoreRef.current.chatData.thinkingResponse.thinkingContent = (
-                            //   <ThinkingIndicator
-                            //     thinkingContent={newValue}
-                            //     isStreaming={isStreaming}
-                            //     thinkDone={thinkDone}
-                            //     renderThinkingLoader={renderThinkingLoader}
-                            //     thinkingStarted={thinkingStarted}
-                            //   />
-                            // );
-                            dispatch(smartBotActions.setThinkingContext({
-                                thinkingHeaderMessage: thinkingHeaderMessageRef.current,
-                                thinkingContent: thinkingContentRef.current,
-                            }));
-                            setThinkingStarted(true);
-                            setIsThinkingFromParent(false);
-                            // botData.utilityObject.thinkingResponse.thinkingContent = (
-                            //   <ThinkingIndicator
-                            //     thinkingContent={newValue}
-                            //     isStreaming={isStreaming}
-                            //     thinkDone={thinkDone}
-                            //     renderThinkingLoader={renderThinkingLoader}
-                            //     thinkingStarted={thinkingStarted}
-                            //   />
-                            // );
+                        const existingStepIndex = newSteps.findIndex((step) => step.header === newStep.header);
+                        if (existingStepIndex !== -1) {
+                            newSteps[existingStepIndex] = newStep;
                         }
-                        else if (data.status === "step") {
-                            let newStep = data.widget_data[0];
-                            const currentIntent = data.widget_data[0]?.current_intent;
-                            setSteps([...steps, newStep]);
-                            let newSteps = lodash.cloneDeep(stepRef.current);
-                            if (newSteps.length === 1) {
-                                newSteps.forEach((step) => {
-                                    step.step_status = "completed";
-                                });
+                        else {
+                            newSteps.push(newStep);
+                        }
+                        stepRef.current = newSteps;
+                        setSteps(newSteps);
+                        if (currentIntent && questionsStepsMapRef.current[currentIntent]) {
+                            let intentSteps = lodash.cloneDeep(questionsStepsMapRef.current[currentIntent]);
+                            if (intentSteps.length === 1 && intentSteps[0].header === "Processing Request") {
+                                intentSteps[0].step_status = "completed";
                             }
-                            const existingStepIndex = newSteps.findIndex((step) => step.header === newStep.header);
-                            if (existingStepIndex !== -1) {
-                                newSteps[existingStepIndex] = newStep;
+                            const existingIdx = intentSteps.findIndex((s) => s.header === newStep.header);
+                            if (existingIdx !== -1) {
+                                intentSteps[existingIdx] = newStep;
                             }
                             else {
-                                newSteps.push(newStep);
-                            }
-                            stepRef.current = newSteps;
-                            setSteps(newSteps);
-                            if (currentIntent && questionsStepsMapRef.current[currentIntent]) {
-                                let intentSteps = lodash.cloneDeep(questionsStepsMapRef.current[currentIntent]);
-                                if (intentSteps.length === 1 && intentSteps[0].header === "Processing Request") {
-                                    intentSteps[0].step_status = "completed";
-                                }
-                                const existingIdx = intentSteps.findIndex((s) => s.header === newStep.header);
-                                if (existingIdx !== -1) {
-                                    intentSteps[existingIdx] = newStep;
-                                }
-                                else {
-                                    intentSteps.push(newStep);
-                                }
-                                questionsStepsMapRef.current[currentIntent] = intentSteps;
-                                setQuestionsStepsMap(lodash.cloneDeep(questionsStepsMapRef.current));
+                                intentSteps.push(newStep);
                             }
-                            setStepChange((prev) => !prev);
+                            questionsStepsMapRef.current[currentIntent] = intentSteps;
+                            setQuestionsStepsMap(lodash.cloneDeep(questionsStepsMapRef.current));
                         }
-                        else if (data.message !== "[DONE]") {
-                            setStepsDone(true);
-                            // setTimeout(() => {
-                            //   setStepsDone(true);
-                            // }, 5000);
-                            if (!thinkingDoneRef?.current && currentMode === "agent") {
-                                thinkingDoneRef.current = true;
-                                setThinkDone(true);
-                                setIsThinkingFromParent(false);
-                                const endTime = Date.now();
-                                const startTime = thinkingStartTimeRef.current || endTime - 1000; // Fallback to 1 second ago
-                                const duration = Math.round((endTime - startTime) / 1000);
-                                const finalThinkingTime = Math.max(duration, 1); // Ensure at least 1 second
-                                setThinkingTime(finalThinkingTime);
-                                setShowThoughtDropdown(true);
-                                setIsThinking(false);
-                                // Store thinking time in messageToStoreRef for persistence
-                                messageToStoreRef.current.chatData.thinkingResponse.thinkingTime = finalThinkingTime;
-                                thinkingTimeFinalRef.current = finalThinkingTime;
-                                setThinkingHeaderMessage(`Thought for ${formatThinkingTime(finalThinkingTime)}`);
-                                thinkingHeaderMessageRef.current = `Thought for ${formatThinkingTime(finalThinkingTime)}`;
-                                dispatch(smartBotActions.setThinkingContext({
-                                    thinkingHeaderMessage: `Thinking Completed`,
-                                    thinkingContent: thinkingContentRef.current,
-                                }));
-                                // dispatch(setThinkingContext({
-                                //   thinkingHeaderMessage: `Thought for ${formatThinkingTime(finalThinkingTime)}`,
-                                //   thinkingContent: thinkingContentRef.current,
-                                // }));
-                                // botData.utilityObject.thinkingResponse.thinkingHeading = (
-                                //   <ThinkinHeaderInfo
-                                //     thinkingHeaderMessage={`Thought for ${formatThinkingTime(finalThinkingTime)}`}
-                                //   />
-                                // );
-                            }
-                            // if(thinkingStarted.current && !thinkDone){
-                            //   setThinkDone(true);
-                            //   thinkingStarted.current = false;
-                            // }
-                            setContent((prev) => {
-                                return prev + data.message;
-                            });
-                            // if (currentMode === "agent") {
-                            //   setIsThinkingFromParent(false);
-                            //   botData.utilityObject.isThinking = false;
-                            //   botData.utilityObject.thinkingResponse.isThinking = false;
-                            //   const finalThinkingTime =
-                            //   thinkingTime || thinkingTimeFinalRef.current || 1;
-                            //   let thinkingTimeFinal = cloneDeep(finalThinkingTime);
-                            //   botData.utilityObject.thinkingResponse.thinkingHeading = (
-                            //     <ThinkinHeaderInfo
-                            //       thinkingHeaderMessage={`Thought for ${formatThinkingTime(thinkingTimeFinal)}`}
-                            //     />
-                            //   );
-                            // }
-                            // // End thinking when regular content starts
-                            // if (isThinking && currentMode === "agent") {
-                            //   setIsThinking(false);
-                            //   if (!thinkDone) {
-                            //     const endTime = Date.now();
-                            //     const startTime =
-                            //       thinkingStartTimeRef.current || endTime - 1000; // Fallback to 1 second ago
-                            //     const duration = Math.round((endTime - startTime) / 1000);
-                            //     const finalThinkingTime = Math.max(duration, 1); // Ensure at least 1 second
-                            //     setThinkingTime(finalThinkingTime);
-                            //     setShowThoughtDropdown(true);
-                            //     // Store thinking time in messageToStoreRef for persistence
-                            //     messageToStoreRef.current.chatData.thinkingResponse.thinkingTime = finalThinkingTime;
-                            //     thinkingTimeFinalRef.current = finalThinkingTime;
-                            //   }
-                            // }
-                            // if(!thinkDone && currentMode === "agent") {
-                            //   setThinkDone(true);
-                            //   setIsThinking(false);
-                            //   setTimeout(() => {
-                            //     // setThinkDone(true);
-                            //     const endTime = Date.now();
-                            //     const startTime =
-                            //       thinkingStartTimeRef.current || endTime - 1000; // Fallback to 1 second ago
-                            //     const duration = Math.round((endTime - startTime) / 1000);
-                            //     const finalThinkingTime = Math.max(duration, 1); // Ensure at least 1 second
-                            //     setThinkingTime(finalThinkingTime);
-                            //     setShowThoughtDropdown(true);
-                            //     // Store thinking time in messageToStoreRef for persistence
-                            //     messageToStoreRef.current.chatData.thinkingResponse.thinkingTime = finalThinkingTime;
-                            //     thinkingTimeFinalRef.current = finalThinkingTime;
-                            //     setContent((prev) => {
-                            //       return prev + data.message;
-                            //     });
-                            //   }, 1000);
-                            // }
-                            // else {
-                            //   setContent((prev) => {
-                            //     return prev + data.message;
-                            //   });
-                            // }
-                        }
-                        else {
-                            setIsStreamingDone(true);
+                        setStepChange((prev) => !prev);
+                    }
+                    else if (data.message !== "[DONE]") {
+                        setStepsDone(true);
+                        if (!thinkingDoneRef?.current && currentMode === "agent") {
+                            thinkingDoneRef.current = true;
+                            setThinkDone(true);
+                            setIsThinkingFromParent(false);
+                            const endTime = Date.now();
+                            const startTime = thinkingStartTimeRef.current || endTime - 1000; // Fallback to 1 second ago
+                            const duration = Math.round((endTime - startTime) / 1000);
+                            const finalThinkingTime = Math.max(duration, 1); // Ensure at least 1 second
+                            setThinkingTime(finalThinkingTime);
+                            setShowThoughtDropdown(true);
+                            setIsThinking(false);
+                            // Store thinking time in messageToStoreRef for persistence
+                            messageToStoreRef.current.chatData.thinkingResponse.thinkingTime = finalThinkingTime;
+                            thinkingTimeFinalRef.current = finalThinkingTime;
+                            setThinkingHeaderMessage(`Thought for ${formatThinkingTime(finalThinkingTime)}`);
+                            thinkingHeaderMessageRef.current = `Thought for ${formatThinkingTime(finalThinkingTime)}`;
+                            dispatch(smartBotActions.setThinkingContext({
+                                thinkingHeaderMessage: `Thinking Completed`,
+                                thinkingContent: thinkingContentRef.current,
+                            }));
                         }
+                        setContent((prev) => {
+                            return prev + data.message;
+                        });
+                    }
+                    else {
+                        setIsStreamingDone(true);
+                        const doneState = streamStateMap.get(streamKey);
+                        if (doneState)
+                            doneState.completed = true;
                     }
                 }
-                catch (e) {
-                    console.error("Error processing message:", e);
-                }
-            });
-            // Handle stream errors
-            sourceRef.current.addEventListener("error", (event) => {
-                console.error("Stream error:", event.reason);
-                setIsStreaming(false);
-                if (isThinking) {
-                    setIsThinking(false);
-                    const endTime = Date.now();
-                    const duration = Math.round((endTime - thinkingStartTimeRef.current) / 1000);
-                    const finalThinkingTime = Math.max(duration, 1); // Ensure at least 1 second
-                    setThinkingTime(finalThinkingTime);
-                    setShowThoughtDropdown(true);
-                    thinkingStartTimeRef.current = finalThinkingTime;
-                    // Store thinking time in messageToStoreRef for persistence
-                    messageToStoreRef.current.chatData.thinkingResponse.thinkingTime = finalThinkingTime;
-                }
-            });
-            // Handle stream closure
-            sourceRef.current.addEventListener("close", () => {
-                setIsStreaming(false);
-            });
-        }
-        catch (error) {
-            console.error("Error processing stream:", error);
-            setContent("Error streaming response. Please try again.");
+            }
+            catch (e) {
+                console.error("Error processing message:", e);
+            }
+        });
+        // Handle stream errors
+        source.addEventListener("error", (event) => {
+            const errState = streamStateMap.get(streamKey);
+            if (!errState || errState.listenerGeneration !== generation)
+                return;
+            console.error("Stream error:", event.reason);
             setIsStreaming(false);
+            errState.completed = true;
             if (isThinking) {
                 setIsThinking(false);
                 const endTime = Date.now();
@@ -6228,13 +6169,62 @@ const StreamedContent = ({ botData }) => {
                 const finalThinkingTime = Math.max(duration, 1); // Ensure at least 1 second
                 setThinkingTime(finalThinkingTime);
                 setShowThoughtDropdown(true);
+                thinkingStartTimeRef.current = finalThinkingTime;
                 // Store thinking time in messageToStoreRef for persistence
                 messageToStoreRef.current.chatData.thinkingResponse.thinkingTime = finalThinkingTime;
             }
-        }
+        });
+        // Handle stream closure
+        source.addEventListener("close", () => {
+            const closeState = streamStateMap.get(streamKey);
+            if (!closeState || closeState.listenerGeneration !== generation)
+                return;
+            setIsStreaming(false);
+            closeState.completed = true;
+        });
     };
+    /**
+     * Effect to initialize streaming or restore state on tab-switch remount.
+     * Uses module-level streamStateMap to detect remounts and avoid re-triggering the API.
+     */
     React.useEffect(() => {
-        processStream();
+        const mapState = streamStateMap.get(streamKey);
+        if (mapState?.initiated) {
+            // Remount after tab switch - restore state from persisted data
+            const store = messageToStoreRef.current;
+            // Restore accumulated content
+            setContent(store.chatData?.response || "");
+            // Restore thinking state
+            if (store.chatData?.thinkingResponse?.thinkingStream) {
+                thinkingContentRef.current = store.chatData.thinkingResponse.thinkingStream;
+            }
+            if (store.chatData?.thinkingResponse?.thinkingTime) {
+                thinkingTimeFinalRef.current = store.chatData.thinkingResponse.thinkingTime;
+                setThinkingTime(store.chatData.thinkingResponse.thinkingTime);
+            }
+            if (mapState.completed) {
+                // Stream already finished while we were unmounted - trigger completion
+                setIsStreaming(false);
+                setIsStreamingDone(true);
+            }
+            else if (mapState.source) {
+                // Stream still in progress - re-attach listeners to existing source
+                sourceRef.current = mapState.source;
+                setIsStreaming(true);
+                attachListeners(mapState.source);
+            }
+        }
+        else {
+            // First mount - initialize Map entry and start streaming
+            streamStateMap.set(streamKey, {
+                messageStore: messageToStoreRef.current,
+                source: null,
+                initiated: false,
+                completed: false,
+                listenerGeneration: 0,
+            });
+            processStream();
+        }
     }, []);
     /**
      * Effect to update chat data when streaming is complete
@@ -6403,6 +6393,8 @@ const StreamedContent = ({ botData }) => {
                     questionsStepsMap: lodash.cloneDeep(questionsStepsMapRef.current),
                 });
             }
+            // Clean up module-level Map entry - stream is fully processed
+            streamStateMap.delete(streamKey);
             // Trigger re-render by updating chatDataState
             setTimeout(() => {
                 setChatDataState({ ...chatDataRef.current });
@@ -6434,6 +6426,11 @@ const StreamedContent = ({ botData }) => {
             sourceRef.current.close();
             setIsStreaming(false);
             setIsStreamingDone(true);
+            // Delete module-level Map entry immediately on abort.
+            // This ensures if the component unmounts before the isStreamingDone effect runs
+            // (e.g. handleNewChatClick clears conversation), the next mount with the same
+            // streamKey starts a fresh stream instead of restoring the aborted one.
+            streamStateMap.delete(streamKey);
             // Stop the agent flow on the backend
             if (messageToStoreRef.current.sessionId) {
                 chatbotServices.stopAgentFlow({ session_id: messageToStoreRef.current.sessionId }, baseUrl);
@@ -6477,13 +6474,13 @@ const StreamedContent = ({ botData }) => {
         };
     }, [isStreaming]);
     /**
-     * Cleanup function to abort streaming on unmount
+     * Cleanup on unmount: Do NOT close the stream here.
+     * The stream connection is kept alive in streamStateMap so it survives
+     * tab-switch remounts. It is only closed by explicit abortStreaming() or new chat.
      */
     React.useEffect(() => {
         return () => {
-            if (sourceRef.current && isStreaming) {
-                sourceRef.current.close();
-            }
+            // Intentionally not closing the stream - it persists in streamStateMap
         };
     }, []);
     /**