impact-chatbot 2.3.61 → 2.3.63

package/dist/index.cjs.js

@@ -5225,9 +5225,28 @@ const sseevent = (message, messageToStoreRef) => {
             messageToStoreRef.current.navSessionId = parsedData.session_id;
         }
         if (parsedData?.is_error) {
-            messageToStoreRef.current.chatData.response =
-                messageToStoreRef.current.chatData.response +
-                    "There is an error, please reach out to IA with this use case.";
+            // Only append the error message once, even if multiple is_error chunks arrive.
+            // Append as a widget item to appendedData so it renders AFTER any existing
+            // widgets (tables, graphs, text widgets) rather than at the top of the response.
+            if (!messageToStoreRef.current.hasErrorMessage) {
+                messageToStoreRef.current.hasErrorMessage = true;
+                const errorMsg = parsedData?.message && parsedData.message !== "[DONE]"
+                    ? parsedData.message
+                    : "There is an error, please reach out to IA with this use case.";
+                const errorWidget = { type: "text", response: errorMsg };
+                const prevAppended = messageToStoreRef.current.appendedData;
+                if (Array.isArray(prevAppended) && prevAppended.length > 0) {
+                    messageToStoreRef.current.appendedData = [...prevAppended, errorWidget];
+                }
+                else if (prevAppended && typeof prevAppended === "object" && Object.keys(prevAppended).length > 0) {
+                    messageToStoreRef.current.appendedData = [prevAppended, errorWidget];
+                }
+                else {
+                    // No existing widgets — put on chatData.response instead
+                    messageToStoreRef.current.chatData.response =
+                        messageToStoreRef.current.chatData.response + errorMsg;
+                }
+            }
             // Still process completed/follow-up status even on error chunks
             // so that initValue is set correctly and dummyButton is suppressed
             if (parsedData?.status === "completed" ||
@@ -5409,6 +5428,7 @@ const AxiosSource = (url, opts, messageToStoreRef) => {
         })
             .catch((error) => {
             let reason = "Network request failed";
+            let statusCode = 0;
             console.error("[AxiosSource] Request failed:", error);
             // Determine specific error reasons
             if (axios.isCancel(error)) {
@@ -5417,8 +5437,15 @@ const AxiosSource = (url, opts, messageToStoreRef) => {
             else if (error.code === "ECONNABORTED") {
                 reason = "Network request timed out";
             }
-            // Emit error event with the specific reason
-            eventTarget.dispatchEvent(new CloseEvent("error", { reason }));
+            // Capture HTTP status code from the error response (e.g. 503)
+            if (error.response && error.response.status) {
+                statusCode = error.response.status;
+                reason = `HTTP ${statusCode}: ${reason}`;
+            }
+            // Emit error event with the specific reason and status code
+            const errorEvent = new CloseEvent("error", { reason });
+            errorEvent.statusCode = statusCode;
+            eventTarget.dispatchEvent(errorEvent);
         });
         // Add method to manually close the connection
         eventTarget.close = () => {
@@ -5459,10 +5486,15 @@ const useStyles$6 = styles.makeStyles((theme) => ({
         marginTop: pxToRem(16),
     }
 }));
+const MAX_RETRY_COUNT_BUTTON = 1;
+const RETRY_COUNTDOWN_SECONDS_BUTTON = 15;
 const ButtonContent = ({ bodyText, isFormDisabled = false, isStepFormSubmit = false, isFormValid = true }) => {
     const classes = useStyles$6();
     const dispatch = reactRedux.useDispatch();
     const sourceRef = React.useRef(null);
+    const retryCountRef = React.useRef(0);
+    const retryTimerRef = React.useRef(null);
+    const retryPayloadRef = React.useRef(null);
     const messageStoreRef = React.useRef({
         currentMode: "agent",
         chatData: {
@@ -5506,6 +5538,8 @@ const ButtonContent = ({ bodyText, isFormDisabled = false, isStepFormSubmit = fa
         sendButton.click();
     };
     const callInitApiStream = (userInput) => {
+        // Store payload for potential retries
+        retryPayloadRef.current = userInput;
         // Prefer module-level values (set synchronously by StreamedContent), fall back to sessionStorage
         // If a previous completed/follow-up response updated the state, use those values.
         // Read from module-level stepFormStreamControl (survives remounts) instead of local messageStoreRef.
@@ -5705,12 +5739,65 @@ const ButtonContent = ({ bodyText, isFormDisabled = false, isStepFormSubmit = fa
                 console.error("[ButtonContent] SSE parse error:", e);
             }
         });
-        sourceRef.current.addEventListener("error", () => {
-            // On error, still dispatch whatever we collected
+        sourceRef.current.addEventListener("error", (event) => {
             stepFormStreamControl.isStreaming = false;
             stepFormStreamControl.abort = null;
             window.dispatchEvent(new CustomEvent("stepFormStreamEnd"));
-            dispatch(smartBotActions.setStepFormStreamData({ status: "error", chunks: chunksRef, sessionId }));
+            // Don't retry if the user manually aborted the request
+            const isUserAbort = event.reason === "Network request aborted";
+            // Check if we can auto-retry (abrupt close or 503, but not user abort)
+            if (!isUserAbort && retryCountRef.current < MAX_RETRY_COUNT_BUTTON) {
+                // Dispatch a "retrying" status so TabularContent can show countdown UI
+                dispatch(smartBotActions.setStepFormStreamData({ status: "retrying", chunks: [...chunksRef], sessionId, countdown: RETRY_COUNTDOWN_SECONDS_BUTTON }));
+                // Start countdown and auto-retry
+                let countdown = RETRY_COUNTDOWN_SECONDS_BUTTON;
+                retryTimerRef.current = setInterval(() => {
+                    countdown -= 1;
+                    if (countdown <= 0) {
+                        clearInterval(retryTimerRef.current);
+                        retryTimerRef.current = null;
+                        retryCountRef.current += 1;
+                        // Re-invoke with same payload
+                        callInitApiStream(retryPayloadRef.current);
+                    }
+                    else {
+                        // Update countdown in Redux for UI
+                        dispatch(smartBotActions.setStepFormStreamData({ status: "retrying", chunks: [...chunksRef], sessionId, countdown }));
+                    }
+                }, 1000);
+            }
+            else {
+                // Retries exhausted or user-aborted — show final message
+                chunksRef.push({ status: "content", message: "Please reach out to IA for this, as this didn't work even after retry" });
+                dispatch(smartBotActions.setStepFormStreamData({ status: "error", chunks: [...chunksRef], sessionId }));
+            }
+        });
+        sourceRef.current.addEventListener("close", () => {
+            if (stepFormStreamControl.isStreaming) {
+                stepFormStreamControl.isStreaming = false;
+                stepFormStreamControl.abort = null;
+                window.dispatchEvent(new CustomEvent("stepFormStreamEnd"));
+                if (retryCountRef.current < MAX_RETRY_COUNT_BUTTON) {
+                    dispatch(smartBotActions.setStepFormStreamData({ status: "retrying", chunks: [...chunksRef], sessionId, countdown: RETRY_COUNTDOWN_SECONDS_BUTTON }));
+                    let countdown = RETRY_COUNTDOWN_SECONDS_BUTTON;
+                    retryTimerRef.current = setInterval(() => {
+                        countdown -= 1;
+                        if (countdown <= 0) {
+                            clearInterval(retryTimerRef.current);
+                            retryTimerRef.current = null;
+                            retryCountRef.current += 1;
+                            callInitApiStream(retryPayloadRef.current);
+                        }
+                        else {
+                            dispatch(smartBotActions.setStepFormStreamData({ status: "retrying", chunks: [...chunksRef], sessionId, countdown }));
+                        }
+                    }, 1000);
+                }
+                else {
+                    chunksRef.push({ status: "content", message: "Please reach out to IA for this, as this didn't work even after retry" });
+                    dispatch(smartBotActions.setStepFormStreamData({ status: "error", chunks: [...chunksRef], sessionId }));
+                }
+            }
         });
     };
     const renderButtons = () => {
@@ -6016,6 +6103,15 @@ const useStyles$5 = styles.makeStyles((theme) => ({
         position: "relative",
         background: colours.white,
     },
+    retryContainer: {
+        marginTop: pxToRem(8),
+    },
+    retryMessage: {
+        fontFamily: "Manrope",
+        fontSize: pxToRem(13),
+        fontWeight: 500,
+        color: "#374151",
+    },
 }));
 
 var _path$i, _path2$2, _defs$5;
@@ -7720,8 +7816,20 @@ const AgentResponse$1 = (props) => {
 };
 
 const StepsResponseTab = (props) => {
-    const { steps, setSteps, stepsDone, setStepsDone, finalStepDone, setFinalStepDone, content, isStreaming, stepChange, currentMode, questions, questionsStepsMap, stepFormDataMap, isFormDisabled, streamingWidgetData, } = props;
+    const { steps, setSteps, stepsDone, setStepsDone, finalStepDone, setFinalStepDone, content, isStreaming, stepChange, currentMode, questions, questionsStepsMap, stepFormDataMap, isFormDisabled, streamingWidgetData, isRetrying, } = props;
     const [tabValue, setTabValue] = React.useState("steps");
+    // When retry countdown starts, switch to agent_response to show it.
+    // When retry actually fires (isRetrying goes false + isStreaming goes true), switch back to steps.
+    React.useEffect(() => {
+        if (isRetrying) {
+            setTabValue("agent_response");
+        }
+    }, [isRetrying]);
+    React.useEffect(() => {
+        if (isStreaming && !isRetrying) {
+            setTabValue("steps");
+        }
+    }, [isStreaming, isRetrying]);
     const handleChangeTabValue = (_event, newValue) => {
         setTabValue(newValue);
     };
@@ -7951,6 +8059,14 @@ const StreamedContent = ({ botData }) => {
     const [finalStepDone, setFinalStepDone] = React.useState(false);
     const [wasStreamingAborted, setWasStreamingAborted] = React.useState(false);
     const wasStreamingAbortedRef = React.useRef(false);
+    // Auto-retry state
+    const MAX_RETRY_COUNT = 1; // Number of auto-retries allowed
+    const RETRY_COUNTDOWN_SECONDS = 15; // Countdown duration before auto-retry
+    const [isRetrying, setIsRetrying] = React.useState(false);
+    const [retryCountdown, setRetryCountdown] = React.useState(0);
+    const retryCountRef = React.useRef(0); // How many retries have been attempted
+    const retryTimerRef = React.useRef(null); // Interval ref for countdown
+    const retryCountdownRef = React.useRef(0); // Non-state countdown for interval callback
     const thinkingContentRef = React.useRef("");
     reactRedux.useSelector((state) => {
         return state.smartBotReducer.thinkingContext;
@@ -8070,6 +8186,94 @@ const StreamedContent = ({ botData }) => {
             }));
         }
     }, [stepChange, questions, questionsStepsMap, stepsDone, isStreamingDone]);
+    /**
+     * Starts a countdown for auto-retry. Shows countdown in UI, then calls retryStream.
+     */
+    const startRetryCountdown = () => {
+        setIsRetrying(true);
+        retryCountdownRef.current = RETRY_COUNTDOWN_SECONDS;
+        setRetryCountdown(RETRY_COUNTDOWN_SECONDS);
+        retryTimerRef.current = setInterval(() => {
+            retryCountdownRef.current -= 1;
+            setRetryCountdown(retryCountdownRef.current);
+            if (retryCountdownRef.current <= 0) {
+                clearInterval(retryTimerRef.current);
+                retryTimerRef.current = null;
+                retryStream();
+            }
+        }, 1000);
+    };
+    /**
+     * Retries the stream by resetting state and calling processStream again.
+     */
+    const retryStream = () => {
+        // Clear countdown state
+        if (retryTimerRef.current) {
+            clearInterval(retryTimerRef.current);
+            retryTimerRef.current = null;
+        }
+        setIsRetrying(false);
+        setRetryCountdown(0);
+        retryCountRef.current += 1;
+        // Reset streaming state for a fresh start
+        setContent("");
+        setIsStreaming(true);
+        setIsStreamingDone(false);
+        setStepsDone(false);
+        setFinalStepDone(false);
+        setWasStreamingAborted(false);
+        wasStreamingAbortedRef.current = false;
+        setSteps([{ header: "Processing Request", sub_header: "Analyzing the current request", step_status: "not-completed" }]);
+        stepRef.current = [{ header: "Processing Request", sub_header: "Analyzing the current request", step_status: "not-completed" }];
+        setQuestions([]);
+        questionsRef.current = [];
+        setQuestionsStepsMap({});
+        questionsStepsMapRef.current = {};
+        setStepFormDataMap({});
+        stepFormDataMapRef.current = {};
+        setStreamingWidgetData([]);
+        streamingDoneProcessedRef.current = false;
+        // Reset messageToStoreRef for fresh accumulation
+        messageToStoreRef.current = {
+            status: "",
+            currentMode: currentMode,
+            chatData: {
+                response: "",
+                response_heading: "",
+                thinkingResponse: {
+                    thinkingContent: jsxRuntime.jsx(ThinkingIndicator, { thinkingContent: thinkingContent }),
+                    thinkingStream: "",
+                    thinkingTime: 0,
+                    thinkingHeading: null,
+                },
+            },
+            appendedData: {},
+            appendedDataFromLastChunk: {},
+            initValue: false,
+            sessionId: "",
+            navSessionId: "",
+            uniqueChatId: "",
+            additionalArgs: {},
+        };
+        // Reset stream state map entry and invalidate old listeners
+        const state = streamStateMap.get(streamKey);
+        if (state) {
+            state.messageStore = messageToStoreRef.current;
+            state.completed = false;
+            // Increment listenerGeneration so any in-flight events from the old source are ignored
+            state.listenerGeneration = (state.listenerGeneration || 0) + 1;
+            // Close the old source if it's still open
+            if (state.source && typeof state.source.close === "function") {
+                try {
+                    state.source.close();
+                }
+                catch (e) { /* ignore */ }
+            }
+            state.source = null;
+        }
+        // Re-initiate the stream
+        processStream();
+    };
     /**
      * Main effect to initialize and handle the streaming connection
      * Sets up the SSE connection and event listeners for message processing
@@ -8175,6 +8379,26 @@ const StreamedContent = ({ botData }) => {
                     }));
                     return;
                 }
+                // Skip is_error chunks — already handled in AxiosEventSource sseevent()
+                if (data?.is_error) {
+                    // Trigger completion if status is "completed"
+                    if (data?.status === "completed") {
+                        setStepsDone(true);
+                        setIsStreamingDone(true);
+                        const doneState = streamStateMap.get(streamKey);
+                        if (doneState)
+                            doneState.completed = true;
+                        dispatch(smartBotActions.setMinimizedStreamData({
+                            isStreaming: false,
+                            stepHeader: questionsRef.current[questionsRef.current.length - 1] || "Completed",
+                            stepSubHeader: "Done",
+                            stepStatus: "completed",
+                            streamStartTime: streamStartTimeRef.current,
+                            actionCount: questionsRef.current.length || 1,
+                        }));
+                    }
+                    return;
+                }
                 if (data?.message || data?.status === "step" || data?.status === "step_form" || data?.status === "thinking" || data?.status === "questions" || data?.status === "widget") {
                     if (data.status === "questions") {
                         const incomingQuestions = data.widget_data?.[0]?.questions || [];
@@ -8444,64 +8668,36 @@ const StreamedContent = ({ botData }) => {
             const errState = streamStateMap.get(streamKey);
             if (!errState || errState.listenerGeneration !== generation)
                 return;
-            console.error("Stream error:", event.reason);
+            console.error("Stream error:", event.reason, "statusCode:", event.statusCode);
             setIsStreaming(false);
             errState.completed = true;
+            // Check if this is a user-initiated abort (should not trigger retry)
+            const isUserAbort = event.reason === "Network request aborted";
+            const is503 = event.statusCode === 503;
             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
+                const finalThinkingTime = Math.max(duration, 1);
                 setThinkingTime(finalThinkingTime);
                 setShowThoughtDropdown(true);
                 thinkingStartTimeRef.current = finalThinkingTime;
-                // Store thinking time in messageToStoreRef for persistence
                 messageToStoreRef.current.chatData.thinkingResponse.thinkingTime = finalThinkingTime;
             }
-            // Mark as aborted so the completion effect skips the Submit button
-            setWasStreamingAborted(true);
-            wasStreamingAbortedRef.current = true;
-            // Mark the last in-progress step as completed
-            const currentSteps = stepRef.current;
-            if (currentSteps.length > 0) {
-                const lastStep = currentSteps[currentSteps.length - 1];
-                if (lastStep.step_status === "not-completed") {
-                    lastStep.step_status = "completed";
-                }
-                stepRef.current = [...currentSteps];
-                setSteps([...currentSteps]);
-            }
-            // Set the response message for the agent_response tab
-            const abruptCloseMessage = "The requested Task has ended unexpectedly, please retry again";
-            messageToStoreRef.current.chatData.response = abruptCloseMessage;
-            setContent(abruptCloseMessage);
-            // Dispatch minimized widget data
-            dispatch(smartBotActions.setMinimizedStreamData({
-                isStreaming: false,
-                stepHeader: questionsRef.current[questionsRef.current.length - 1] || "Ended unexpectedly",
-                stepSubHeader: "Connection closed",
-                stepStatus: "completed",
-                streamStartTime: streamStartTimeRef.current,
-                actionCount: questionsRef.current.length || 1,
-            }));
-            // Switch to agent_response tab and trigger completion flow
-            setStepsDone(true);
-            setIsStreamingDone(true);
-        });
-        // Handle stream closure
-        source.addEventListener("close", () => {
-            const closeState = streamStateMap.get(streamKey);
-            if (!closeState || closeState.listenerGeneration !== generation)
-                return;
-            setIsStreaming(false);
-            // If closeState.completed is already true, this is a normal close after [DONE].
-            // If it's still false, the backend closed the connection abruptly.
-            if (!closeState.completed) {
-                closeState.completed = true;
-                // Mark as aborted so the completion effect skips the Submit button
+            // Check if we can auto-retry (abrupt close or 503, but not user abort)
+            if (!isUserAbort && retryCountRef.current < MAX_RETRY_COUNT) {
+                // Still have retries left — start countdown instead of showing final error
+                setStepsDone(true); // Switch to agent_response tab to show countdown
+                const retryMessage = is503
+                    ? "Service temporarily unavailable (503), auto re-trying..."
+                    : "The service is temporarily unavailable because of an unusual load. Please wait a moment and try again.";
+                setContent(retryMessage);
+                startRetryCountdown();
+            }
+            else {
+                // Retries exhausted — show final message
                 setWasStreamingAborted(true);
                 wasStreamingAbortedRef.current = true;
-                // Mark the last in-progress step as completed
                 const currentSteps = stepRef.current;
                 if (currentSteps.length > 0) {
                     const lastStep = currentSteps[currentSteps.length - 1];
@@ -8511,21 +8707,9 @@ const StreamedContent = ({ botData }) => {
                     stepRef.current = [...currentSteps];
                     setSteps([...currentSteps]);
                 }
-                // Set the response message for the agent_response tab
-                const abruptCloseMessage = "The requested Task has ended unexpectedly, please retry again";
-                messageToStoreRef.current.chatData.response = abruptCloseMessage;
-                setContent(abruptCloseMessage);
-                // Stop thinking if in progress
-                if (isThinking) {
-                    setIsThinking(false);
-                    const endTime = Date.now();
-                    const duration = Math.round((endTime - thinkingStartTimeRef.current) / 1000);
-                    const finalThinkingTime = Math.max(duration, 1);
-                    setThinkingTime(finalThinkingTime);
-                    setShowThoughtDropdown(true);
-                    messageToStoreRef.current.chatData.thinkingResponse.thinkingTime = finalThinkingTime;
-                }
-                // Dispatch minimized widget data
+                const finalMessage = "Please reach out to IA for this, as this didn't work even after retry";
+                messageToStoreRef.current.chatData.response = finalMessage;
+                setContent(finalMessage);
                 dispatch(smartBotActions.setMinimizedStreamData({
                     isStreaming: false,
                     stepHeader: questionsRef.current[questionsRef.current.length - 1] || "Ended unexpectedly",
@@ -8534,10 +8718,65 @@ const StreamedContent = ({ botData }) => {
                     streamStartTime: streamStartTimeRef.current,
                     actionCount: questionsRef.current.length || 1,
                 }));
-                // Switch to agent_response tab and trigger completion flow
                 setStepsDone(true);
                 setIsStreamingDone(true);
             }
+        });
+        // Handle stream closure
+        source.addEventListener("close", () => {
+            const closeState = streamStateMap.get(streamKey);
+            if (!closeState || closeState.listenerGeneration !== generation)
+                return;
+            setIsStreaming(false);
+            // If closeState.completed is already true, this is a normal close after [DONE].
+            // If it's still false, the backend closed the connection abruptly.
+            if (!closeState.completed) {
+                closeState.completed = true;
+                // Stop thinking if in progress
+                if (isThinking) {
+                    setIsThinking(false);
+                    const endTime = Date.now();
+                    const duration = Math.round((endTime - thinkingStartTimeRef.current) / 1000);
+                    const finalThinkingTime = Math.max(duration, 1);
+                    setThinkingTime(finalThinkingTime);
+                    setShowThoughtDropdown(true);
+                    messageToStoreRef.current.chatData.thinkingResponse.thinkingTime = finalThinkingTime;
+                }
+                // Check if we can auto-retry
+                if (retryCountRef.current < MAX_RETRY_COUNT) {
+                    // Still have retries left — start countdown instead of showing final error
+                    setStepsDone(true); // Switch to agent_response tab to show countdown
+                    setContent("The service is temporarily unavailable because of an unusual load. Please wait a moment and try again.");
+                    startRetryCountdown();
+                }
+                else {
+                    // Retries exhausted — show final elegant message
+                    setWasStreamingAborted(true);
+                    wasStreamingAbortedRef.current = true;
+                    const currentSteps = stepRef.current;
+                    if (currentSteps.length > 0) {
+                        const lastStep = currentSteps[currentSteps.length - 1];
+                        if (lastStep.step_status === "not-completed") {
+                            lastStep.step_status = "completed";
+                        }
+                        stepRef.current = [...currentSteps];
+                        setSteps([...currentSteps]);
+                    }
+                    const finalMessage = "Please reach out to IA for this, as this didn't work even after retry";
+                    messageToStoreRef.current.chatData.response = finalMessage;
+                    setContent(finalMessage);
+                    dispatch(smartBotActions.setMinimizedStreamData({
+                        isStreaming: false,
+                        stepHeader: questionsRef.current[questionsRef.current.length - 1] || "Ended unexpectedly",
+                        stepSubHeader: "Connection closed",
+                        stepStatus: "completed",
+                        streamStartTime: streamStartTimeRef.current,
+                        actionCount: questionsRef.current.length || 1,
+                    }));
+                    setStepsDone(true);
+                    setIsStreamingDone(true);
+                }
+            }
             // else: closeState.completed is already true — normal close after [DONE], nothing to do.
         });
     };
@@ -8841,6 +9080,14 @@ const StreamedContent = ({ botData }) => {
      * Aborts the current streaming connection
      */
     const abortStreaming = () => {
+        // If a retry countdown is running, clear it and prevent further retries
+        if (retryTimerRef.current) {
+            clearInterval(retryTimerRef.current);
+            retryTimerRef.current = null;
+            setIsRetrying(false);
+            setRetryCountdown(0);
+        }
+        retryCountRef.current = MAX_RETRY_COUNT; // Exhaust retries so no further auto-retries happen
         if (sourceRef.current && isStreaming) {
             setWasStreamingAborted(true);
             wasStreamingAbortedRef.current = true;
@@ -8888,9 +9135,9 @@ const StreamedContent = ({ botData }) => {
             // If no content yet, show aborted message
             // if (isEmpty(messageToStoreRef.current.chatData?.response)) {
             messageToStoreRef.current.chatData.response =
-                messageToStoreRef.current.chatData.response + "\n\nStream was stopped by user.";
+                messageToStoreRef.current.chatData.response + "\n\nYou stopped this response. You can ask a new question whenever you're ready";
             setContent((prev) => {
-                return prev + "\n\nStream was stopped by user.";
+                return prev + "\n\nYou stopped this response. You can ask a new question whenever you're ready";
             });
             // }
         }
@@ -8912,10 +9159,16 @@ const StreamedContent = ({ botData }) => {
      * 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.
+     * Also clean up retry timer if running.
      */
     React.useEffect(() => {
         return () => {
             // Intentionally not closing the stream - it persists in streamStateMap
+            // Clean up retry timer
+            if (retryTimerRef.current) {
+                clearInterval(retryTimerRef.current);
+                retryTimerRef.current = null;
+            }
         };
     }, []);
     /**
@@ -8967,7 +9220,7 @@ const StreamedContent = ({ botData }) => {
      * @returns {JSX.Element} Rendered content with optional blinking cursor
      */
     const renderContent = () => {
-        return (jsxRuntime.jsx("div", { className: classes.streamContainer, children: jsxRuntime.jsx(StepsResponseTab, { steps: steps, stepChange: stepChange, setSteps: setSteps, stepsDone: stepsDone, setStepsDone: setStepsDone, finalStepDone: finalStepDone, setFinalStepDone: setFinalStepDone, content: content, isStreaming: isStreaming, currentMode: currentMode, questions: questions, questionsStepsMap: questionsStepsMap, stepFormDataMap: stepFormDataMap, isFormDisabled: botData?.isFormDisabled || false, streamingWidgetData: streamingWidgetData }) }));
+        return (jsxRuntime.jsxs("div", { className: classes.streamContainer, children: [jsxRuntime.jsx(StepsResponseTab, { steps: steps, stepChange: stepChange, setSteps: setSteps, stepsDone: stepsDone, setStepsDone: setStepsDone, finalStepDone: finalStepDone, setFinalStepDone: setFinalStepDone, content: content, isStreaming: isStreaming, currentMode: currentMode, questions: questions, questionsStepsMap: questionsStepsMap, stepFormDataMap: stepFormDataMap, isFormDisabled: botData?.isFormDisabled || false, streamingWidgetData: streamingWidgetData, isRetrying: isRetrying }), isRetrying && (jsxRuntime.jsx("div", { className: classes.retryContainer, children: jsxRuntime.jsxs("span", { className: classes.retryMessage, children: ["Auto re-trying in ", retryCountdown, "s"] }) }))] }));
     };
     if (currentMode === "agent") {
         return renderContent();
@@ -9259,6 +9512,7 @@ const TabularContent = ({ steps: initialSteps, currentTabValue, children, questi
     const [stepFormSubmitted, setStepFormSubmitted] = React.useState(false);
     const [hasNewStepFormFromRestream, setHasNewStepFormFromRestream] = React.useState(false);
     const [activeFormIntent, setActiveFormIntent] = React.useState(null);
+    const [retryCountdown, setRetryCountdown] = React.useState(0);
     // Stable unique instance ID for this TabularContent mount
     const instanceIdRef = React.useRef(null);
     if (instanceIdRef.current === null) {
@@ -9324,10 +9578,15 @@ const TabularContent = ({ steps: initialSteps, currentTabValue, children, questi
         const payload = stepFormStreamData;
         // Clear Redux immediately
         dispatch(smartBotActions.setStepFormStreamData(null));
+        if (payload.status === "retrying") {
+            setRetryCountdown(payload.countdown || 0);
+            return;
+        }
         if (payload.status === "streaming_start") {
             setIsRestreaming(true);
             setStepFormSubmitted(true);
             setHasNewStepFormFromRestream(false);
+            setRetryCountdown(0);
             setTabValue("steps");
             return;
         }
@@ -9467,6 +9726,8 @@ const TabularContent = ({ steps: initialSteps, currentTabValue, children, questi
             }
             return;
         }
+        // Clear retry countdown when final processing starts
+        setRetryCountdown(0);
         // Process all collected chunks at once (done or error)
         const chunks = payload.chunks || [];
         let newSteps = lodash.cloneDeep(stepsRef.current);
@@ -9615,7 +9876,7 @@ const TabularContent = ({ steps: initialSteps, currentTabValue, children, questi
                 },
             ], tabPanels: [
                 jsxRuntime.jsx(Steps, { steps: stepsState, questions: questionsState, questionsStepsMap: questionsStepsMapState, stepFormDataMap: stepFormDataMapState, isFormDisabled: (isFormDisabled && !isRestreaming) || stepFormSubmitted, activeFormIntent: hasNewStepFormFromRestream ? activeFormIntent : null, isRestreaming: isRestreaming }),
-                jsxRuntime.jsxs(AgentResponse, { children: [children, renderedWidgets.length > 0 && (jsxRuntime.jsx("div", { className: "restream-widget-content", children: renderedWidgets }))] }),
+                jsxRuntime.jsxs(AgentResponse, { children: [children, renderedWidgets.length > 0 && (jsxRuntime.jsx("div", { className: "restream-widget-content", children: renderedWidgets })), retryCountdown > 0 && (jsxRuntime.jsx("div", { style: { marginTop: "8px" }, children: jsxRuntime.jsxs("span", { style: { fontFamily: "Manrope", fontSize: "13px", fontWeight: 500, color: "#374151" }, children: ["Auto re-trying in ", retryCountdown, "s"] }) }))] }),
             ], value: tabValue }) }));
 };
 /** Reset the active instance tracker (call when a new conversation starts from the input field) */