impact-chatbot 2.3.62 → 2.3.64

package/dist/index.esm.js

@@ -5406,6 +5406,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)) {
@@ -5414,8 +5415,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 = () => {
@@ -5456,10 +5464,15 @@ const useStyles$6 = 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 = useDispatch();
     const sourceRef = useRef(null);
+    const retryCountRef = useRef(0);
+    const retryTimerRef = useRef(null);
+    const retryPayloadRef = useRef(null);
     const messageStoreRef = useRef({
         currentMode: "agent",
         chatData: {
@@ -5503,6 +5516,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.
@@ -5702,33 +5717,64 @@ 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(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(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(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(setStepFormStreamData({ status: "error", chunks: [...chunksRef], sessionId }));
+            }
         });
-        // Handle stream closure — fires when the HTTP request completes successfully.
-        // If [DONE] was received, the "message" handler already dispatched status:"done"
-        // and set stepFormStreamControl.isStreaming = false.
-        // If [DONE] was NOT received, the connection closed abruptly mid-processing.
         sourceRef.current.addEventListener("close", () => {
             if (stepFormStreamControl.isStreaming) {
                 stepFormStreamControl.isStreaming = false;
                 stepFormStreamControl.abort = null;
                 window.dispatchEvent(new CustomEvent("stepFormStreamEnd"));
-                // Append the abrupt close message as a content chunk so TabularContent
-                // renders it at the bottom (after any already-received widgets/steps)
-                chunksRef.push({
-                    status: "content",
-                    message: "The requested Task has ended unexpectedly, please retry again",
-                });
-                dispatch(setStepFormStreamData({
-                    status: "error",
-                    chunks: [...chunksRef],
-                    sessionId,
-                }));
+                if (retryCountRef.current < MAX_RETRY_COUNT_BUTTON) {
+                    dispatch(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(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(setStepFormStreamData({ status: "error", chunks: [...chunksRef], sessionId }));
+                }
             }
         });
     };
@@ -6035,6 +6081,15 @@ const useStyles$5 = 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;
@@ -7739,8 +7794,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] = 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.
+    useEffect(() => {
+        if (isRetrying) {
+            setTabValue("agent_response");
+        }
+    }, [isRetrying]);
+    useEffect(() => {
+        if (isStreaming && !isRetrying) {
+            setTabValue("steps");
+        }
+    }, [isStreaming, isRetrying]);
     const handleChangeTabValue = (_event, newValue) => {
         setTabValue(newValue);
     };
@@ -7970,6 +8037,14 @@ const StreamedContent = ({ botData }) => {
     const [finalStepDone, setFinalStepDone] = useState(false);
     const [wasStreamingAborted, setWasStreamingAborted] = useState(false);
     const wasStreamingAbortedRef = 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] = useState(false);
+    const [retryCountdown, setRetryCountdown] = useState(0);
+    const retryCountRef = useRef(0); // How many retries have been attempted
+    const retryTimerRef = useRef(null); // Interval ref for countdown
+    const retryCountdownRef = useRef(0); // Non-state countdown for interval callback
     const thinkingContentRef = useRef("");
     useSelector((state) => {
         return state.smartBotReducer.thinkingContext;
@@ -8089,6 +8164,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: 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
@@ -8483,66 +8646,57 @@ 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";
+            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]);
-            }
-            // Show the abrupt close message at the bottom of any existing content.
-            // If widgets already exist in appendedData, append the error as the last widget
-            // so it renders AFTER the already-received content (not at the top).
-            const abruptCloseMessage = "The requested Task has ended unexpectedly, please retry again";
-            const hasExistingWidgetsOnErr = messageToStoreRef.current.appendedData &&
-                (isArray(messageToStoreRef.current.appendedData)
-                    ? messageToStoreRef.current.appendedData.length > 0
-                    : Object.keys(messageToStoreRef.current.appendedData).length > 0);
-            if (hasExistingWidgetsOnErr) {
-                const errorWidget = { type: "text", response: abruptCloseMessage };
-                if (isArray(messageToStoreRef.current.appendedData)) {
-                    messageToStoreRef.current.appendedData.push(errorWidget);
-                }
-                else {
-                    messageToStoreRef.current.appendedData = [messageToStoreRef.current.appendedData, errorWidget];
-                }
+            // 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 = "The service is temporarily unavailable because of an unusual load. Please wait a moment and try again.";
+                setContent(retryMessage);
+                startRetryCountdown();
             }
             else {
-                messageToStoreRef.current.chatData.response = abruptCloseMessage;
+                // Retries exhausted — show final 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(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);
             }
-            setContent(abruptCloseMessage);
-            // Dispatch minimized widget data
-            dispatch(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", () => {
@@ -8554,44 +8708,6 @@ const StreamedContent = ({ botData }) => {
             // 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
-                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]);
-                }
-                // Show the abrupt close message. The final response array is structured as:
-                // [textResponseTobeParsed, ...appendedData] — so chatData.response renders FIRST,
-                // then widget items from appendedData render below it.
-                // To ensure the error message appears AFTER already-rendered widgets, we append it
-                // as a text widget item to appendedData instead of setting it on chatData.response.
-                const abruptCloseMessage = "The requested Task has ended unexpectedly, please retry again";
-                const hasExistingWidgets = messageToStoreRef.current.appendedData &&
-                    (isArray(messageToStoreRef.current.appendedData)
-                        ? messageToStoreRef.current.appendedData.length > 0
-                        : Object.keys(messageToStoreRef.current.appendedData).length > 0);
-                if (hasExistingWidgets) {
-                    // Widgets already exist — append error as the last widget so it renders at the bottom
-                    const errorWidget = { type: "text", response: abruptCloseMessage };
-                    if (isArray(messageToStoreRef.current.appendedData)) {
-                        messageToStoreRef.current.appendedData.push(errorWidget);
-                    }
-                    else {
-                        messageToStoreRef.current.appendedData = [messageToStoreRef.current.appendedData, errorWidget];
-                    }
-                }
-                else {
-                    // No widgets — set on chatData.response (will be the only rendered text)
-                    messageToStoreRef.current.chatData.response = abruptCloseMessage;
-                }
-                setContent(abruptCloseMessage);
                 // Stop thinking if in progress
                 if (isThinking) {
                     setIsThinking(false);
@@ -8602,18 +8718,40 @@ const StreamedContent = ({ botData }) => {
                     setShowThoughtDropdown(true);
                     messageToStoreRef.current.chatData.thinkingResponse.thinkingTime = finalThinkingTime;
                 }
-                // Dispatch minimized widget data
-                dispatch(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);
+                // 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(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.
         });
@@ -8918,6 +9056,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;
@@ -8965,9 +9111,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";
             });
             // }
         }
@@ -8989,10 +9135,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.
      */
     useEffect(() => {
         return () => {
             // Intentionally not closing the stream - it persists in streamStateMap
+            // Clean up retry timer
+            if (retryTimerRef.current) {
+                clearInterval(retryTimerRef.current);
+                retryTimerRef.current = null;
+            }
         };
     }, []);
     /**
@@ -9044,7 +9196,7 @@ const StreamedContent = ({ botData }) => {
      * @returns {JSX.Element} Rendered content with optional blinking cursor
      */
     const renderContent = () => {
-        return (jsx("div", { className: classes.streamContainer, children: 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 (jsxs("div", { className: classes.streamContainer, children: [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 && (jsx("div", { className: classes.retryContainer, children: jsxs("span", { className: classes.retryMessage, children: ["Auto re-trying in ", retryCountdown, "s"] }) }))] }));
     };
     if (currentMode === "agent") {
         return renderContent();
@@ -9336,6 +9488,7 @@ const TabularContent = ({ steps: initialSteps, currentTabValue, children, questi
     const [stepFormSubmitted, setStepFormSubmitted] = useState(false);
     const [hasNewStepFormFromRestream, setHasNewStepFormFromRestream] = useState(false);
     const [activeFormIntent, setActiveFormIntent] = useState(null);
+    const [retryCountdown, setRetryCountdown] = useState(0);
     // Stable unique instance ID for this TabularContent mount
     const instanceIdRef = useRef(null);
     if (instanceIdRef.current === null) {
@@ -9401,10 +9554,15 @@ const TabularContent = ({ steps: initialSteps, currentTabValue, children, questi
         const payload = stepFormStreamData;
         // Clear Redux immediately
         dispatch(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;
         }
@@ -9544,6 +9702,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 = cloneDeep(stepsRef.current);
@@ -9692,7 +9852,7 @@ const TabularContent = ({ steps: initialSteps, currentTabValue, children, questi
                 },
             ], tabPanels: [
                 jsx(Steps, { steps: stepsState, questions: questionsState, questionsStepsMap: questionsStepsMapState, stepFormDataMap: stepFormDataMapState, isFormDisabled: (isFormDisabled && !isRestreaming) || stepFormSubmitted, activeFormIntent: hasNewStepFormFromRestream ? activeFormIntent : null, isRestreaming: isRestreaming }),
-                jsxs(AgentResponse, { children: [children, renderedWidgets.length > 0 && (jsx("div", { className: "restream-widget-content", children: renderedWidgets }))] }),
+                jsxs(AgentResponse, { children: [children, renderedWidgets.length > 0 && (jsx("div", { className: "restream-widget-content", children: renderedWidgets })), retryCountdown > 0 && (jsx("div", { style: { marginTop: "8px" }, children: 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) */