impact-chatbot 2.3.84 → 2.3.86

package/dist/index.esm.js

@@ -19,7 +19,7 @@ import remarkGfm from 'remark-gfm';
 import DOMPurify from 'dompurify';
 import { useNavigate, useLocation } from 'react-router-dom-v5-compat';
 import { setSelectedFilters, setFilterConfiguration, getFilterUserConfiguration } from 'core/actions/filterAction';
-import { setChatbotContext, setStepFormStreamData, setMinimizedStreamData, setThinkingContext, setPersistedFormValues, clearPersistedFormValues, setCurrentAgentChatId, setHierarchyKeyValue, setChatbotFilterOptions, setSavedFilterSets } from 'core/actions/smartBotActions';
+import { setThinkingContext, setChatbotContext, setStepFormStreamData, setMinimizedStreamData, setPersistedFormValues, clearPersistedFormValues, setCurrentAgentChatId, setHierarchyKeyValue, setChatbotFilterOptions, setSavedFilterSets } from 'core/actions/smartBotActions';
 import RefreshIcon from '@mui/icons-material/Refresh';
 import styled from 'styled-components';
 import { CircularProgress, Typography, Grid } from '@mui/material';
@@ -653,8 +653,11 @@ const handleMessageLike = async (question, liked, setLoadingState, displaySnackM
     try {
         let request;
         if (currentMode === "agent") {
+            // Use the session stored on this specific message. The live sessionId is
+            // reset once a flow completes / awaits follow-up, so relying on it would
+            // send an empty session_id or the session of a newer chat.
             const agentPayload = {
-                session_id: sessionId,
+                session_id: activeMessage?.chatSessionId || activeMessage?.sessionId || sessionId,
                 liked,
             };
             request = await likeDislikeCommentForAgent(agentPayload, baseUrl);
@@ -1417,31 +1420,50 @@ const ThinkinHeaderInfo = (props) => {
     });
     const { streamStartTime, isStreamCompleted, finalElapsedSeconds, thinkingHeaderMessage } = thinkingContext;
     const [elapsed, setElapsed] = useState(0);
+    const [frozenText, setFrozenText] = useState(null);
     const intervalRef = useRef(null);
     // Once this instance sees "completed", freeze it permanently so a future
     // chat's streamStartTime doesn't cause it to start ticking again.
     const frozenRef = useRef(false);
     const frozenTextRef = useRef(null);
-    const streamStartTimeRef = useRef(null); // Track streamStartTime changes to unfreeze
+    // The streamStartTime this instance latched onto. Used to detect when a
+    // different stream has taken over (e.g. the user asked a new question while
+    // this message's step form was still waiting for input).
+    const ownStartTimeRef = useRef(null);
+    /**
+     * Freezes this instance permanently on a final label and elapsed value.
+     */
+    const freeze = (text, seconds) => {
+        frozenRef.current = true;
+        frozenTextRef.current = text;
+        setFrozenText(text);
+        setElapsed(seconds);
+    };
     useEffect(() => {
         // If already frozen (stream completed), NEVER unfreeze.
         // This prevents a new chat's streamStartTime from restarting this timer.
         if (frozenRef.current)
             return;
-        // Track streamStartTime changes for non-frozen instances
-        if (streamStartTimeRef.current !== streamStartTime) {
-            streamStartTimeRef.current = streamStartTime;
+        // Adopt the first non-null streamStartTime we see as this instance's own
+        if (ownStartTimeRef.current === null && streamStartTime) {
+            ownStartTimeRef.current = streamStartTime;
         }
+        const ownStartTime = ownStartTimeRef.current;
         // Clear any existing interval
         if (intervalRef.current) {
             clearInterval(intervalRef.current);
             intervalRef.current = null;
         }
         if (isStreamCompleted && typeof finalElapsedSeconds === 'number') {
-            // Freeze this instance — it will never tick again
-            frozenRef.current = true;
-            frozenTextRef.current = `Completed in ${formatElapsedTime(finalElapsedSeconds)}`;
-            setElapsed(finalElapsedSeconds);
+            // Freeze this instance - it will never tick again
+            freeze(`Completed in ${formatElapsedTime(finalElapsedSeconds)}`, finalElapsedSeconds);
+        }
+        else if (ownStartTime !== null && streamStartTime !== ownStartTime) {
+            // A different stream has started (new question) while this one never
+            // completed - typically an abandoned step form. Freeze on this
+            // instance's OWN elapsed time instead of following the new stream.
+            const ownElapsed = Math.floor((Date.now() - ownStartTime) / 1000);
+            freeze(`Completed in ${formatElapsedTime(ownElapsed)}`, ownElapsed);
         }
         else if (streamStartTime && !isStreamCompleted) {
             // Live timer — update every second
@@ -1462,8 +1484,8 @@ const ThinkinHeaderInfo = (props) => {
     }, [streamStartTime, isStreamCompleted, finalElapsedSeconds]);
     // Determine display text
     let displayText = thinkingHeaderMessage || '';
-    if (frozenRef.current && frozenTextRef.current) {
-        displayText = frozenTextRef.current;
+    if (frozenText || (frozenRef.current && frozenTextRef.current)) {
+        displayText = frozenText || frozenTextRef.current;
     }
     else if (streamStartTime && !isStreamCompleted) {
         displayText = `Working for ${formatElapsedTime(elapsed)}`;
@@ -2457,6 +2479,20 @@ const useChatFlow = (chatDataRef, setLoader, setFlowType, setScreenName, setUser
         }
         if (data.flow_type === "agent" && data.actionType === "direct") {
             data.baseUrl = baseUrl;
+            // Reset the timer before the request goes out (same as index.jsx
+            // handleSendMessage). Without this the new ThinkinHeaderInfo mounts while
+            // the previous response's "completed" state is still in Redux and freezes
+            // itself on that stale elapsed time.
+            // streamStartTime stays null here: processStream sets it, so a question
+            // has exactly one start time (two would make the new header look like a
+            // superseded one and freeze it at 0m:00s).
+            dispatch(setThinkingContext({
+                thinkingContent: "",
+                thinkingHeaderMessage: "Working for 0m:00s",
+                streamStartTime: null,
+                isStreamCompleted: false,
+                finalElapsedSeconds: null,
+            }));
             prepareDataAndSendToAgent(data, false, {
                 chatbotContext: chatbotContext,
                 setChatbotContext: setChatbotContext,
@@ -5315,6 +5351,13 @@ const sseevent = (message, messageToStoreRef) => {
                 ? parsedData.chat_id
                 : "";
             messageToStoreRef.current.sessionId = parsedData?.session_id;
+            // Sticky copy of the session id this message belongs to. sessionId gets
+            // cleared on completed/follow-up so the next user message starts a fresh
+            // session, but message level actions (like/dislike) still need to refer
+            // to the session that actually produced this response.
+            if (parsedData?.session_id) {
+                messageToStoreRef.current.chatSessionId = parsedData.session_id;
+            }
         }
         if (messageToStoreRef.current.currentMode === "navigation" &&
             parsedData?.session_id) {
@@ -8663,7 +8706,7 @@ const StreamedContent = ({ botData, botProps }) => {
     const retryTimerRef = useRef(null); // Interval ref for countdown
     const retryCountdownRef = useRef(0); // Non-state countdown for interval callback
     const thinkingContentRef = useRef("");
-    useSelector((state) => {
+    const thinkingContext = useSelector((state) => {
         return state.smartBotReducer.thinkingContext;
     });
     const stepRef = useRef(_isAbortedRemount
@@ -8686,7 +8729,10 @@ const StreamedContent = ({ botData, botProps }) => {
     const thinkingStartTimeRef = useRef(null);
     const thinkingTimeFinalRef = useRef(0);
     const thinkingHeaderMessageRef = useRef("Working for 0m:00s");
-    const streamStartTimeRef = useRef(null);
+    // Inherit the in-flight start time so a remount (e.g. tab switch, where
+    // processStream is not re-run) keeps the original one instead of resetting.
+    // Null for a fresh question - processStream sets it.
+    const streamStartTimeRef = useRef(thinkingContext?.isStreamCompleted ? null : thinkingContext?.streamStartTime || null);
     const thinkingDoneRef = useRef(false);
     const thinkingStartedRef = useRef(false);
     const setThinkingContentRef = useRef(setThinkingContent); // Store current setThinkingContent function
@@ -9661,7 +9707,12 @@ const StreamedContent = ({ botData, botProps }) => {
                     },
                 };
                 const hasStepFormWidgets = !isEmpty(stepFormDataMapRef.current);
-                processResponse(response, botData.inputBody, currentMode, botData.utilityObject.customChatConfig, {
+                // response.session_id is intentionally blank once the flow completes, so
+                // keep the retained session separately and stamp it on the stored message.
+                const messageChatSessionId = messageToStoreRef.current.chatSessionId ||
+                    messageToStoreRef.current.sessionId ||
+                    "";
+                Promise.resolve(processResponse(response, botData.inputBody, currentMode, botData.utilityObject.customChatConfig, {
                     newChatData: chatDataInfoRef,
                     isTabEnabled: true,
                     steps: stepRef.current.map(s => ({ ...s })),
@@ -9669,7 +9720,15 @@ const StreamedContent = ({ botData, botProps }) => {
                     questions: [...questionsRef.current],
                     questionsStepsMap: { ...questionsStepsMapRef.current },
                     stepFormDataMap: { ...stepFormDataMapRef.current },
-                }, activeConversationId);
+                }, activeConversationId)).then(() => {
+                    if (!messageChatSessionId)
+                        return;
+                    const storedMessages = chatDataInfoRef.current?.[currentMode]?.conversations?.[activeConversationId]?.messages;
+                    if (storedMessages?.length) {
+                        storedMessages[storedMessages.length - 1].chatSessionId =
+                            messageChatSessionId;
+                    }
+                });
                 // [
                 //   {
                 //     header: "Finding relevant information",
@@ -15833,10 +15892,14 @@ const SmartBot = (props) => {
                     answerMode: answerMode,
                 };
                 // if(!isEmpty(userInput)) {
+                // Clear the previous response's completed state so the incoming
+                // ThinkinHeaderInfo doesn't freeze on it. streamStartTime stays null
+                // here: processStream sets it, so a question has exactly one start
+                // time (two would make the new header look like a superseded one).
                 dispatch(setThinkingContext({
                     thinkingContent: "",
                     thinkingHeaderMessage: "Working for 0m:00s",
-                    streamStartTime: Date.now(),
+                    streamStartTime: null,
                     isStreamCompleted: false,
                     finalElapsedSeconds: null,
                 }));