@eshal-bot/chat-widget 0.1.21 → 0.1.22

package/dist/chat-widget.js

@@ -1292,6 +1292,197 @@
     return (_ONBOARDING_FIELD_ORD = ONBOARDING_FIELD_ORDER[key]) !== null && _ONBOARDING_FIELD_ORD !== void 0 ? _ONBOARDING_FIELD_ORD : 99;
   };
 
+  const createSession = async config => {
+    // Initialize chat session if needed
+    if (config.sessionUrl) {
+      try {
+        const response = await fetch(config.sessionUrl, {
+          method: "POST",
+          headers: _objectSpread2({
+            "Content-Type": "application/json"
+          }, config.apiKey && {
+            Authorization: "Bearer ".concat(config.apiKey)
+          }),
+          body: JSON.stringify({
+            userId: config.userId,
+            userName: config.userName,
+            userEmail: config.userEmail
+          }),
+          credentials: "include"
+        });
+        const data = await response.json();
+        return data.sessionId;
+      } catch (error) {
+        console.error("Session creation error:", error);
+        return null;
+      }
+    }
+    return null;
+  };
+
+  /**
+   * Fetches conversation history for a given org and conversation
+   * @param {string} apiBaseUrl - Base URL for the API
+   * @param {string} orgId - Organization ID
+   * @param {string} conversationId - Conversation ID
+   * @returns {Promise<Array>} Array of messages
+   */
+  const fetchConversationHistory = async (apiBaseUrl, orgId, conversationId) => {
+    if (!apiBaseUrl || !orgId || !conversationId) {
+      throw new Error("apiBaseUrl, orgId, and conversationId are required");
+    }
+    const url = "".concat(apiBaseUrl.replace(/\/$/, ''), "/api/v1/conversations/").concat(orgId, "/").concat(conversationId);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      credentials: "include"
+    });
+    if (response.status === 404) {
+      return []; // No history for this conversation yet
+    }
+    if (!response.ok) {
+      throw new Error("HTTP error! status: ".concat(response.status));
+    }
+    const data = await response.json();
+    return data.messages || [];
+  };
+
+  /**
+   * Fetches agent configuration from the deploy-agent endpoint
+   * @param {string} apiBaseUrl - Base URL for the API
+   * @param {string} orgId - Organization ID
+   * @returns {Promise<object>} Agent configuration object
+   */
+  const fetchAgentConfig = async (apiBaseUrl, orgId) => {
+    if (!apiBaseUrl || !orgId) {
+      throw new Error("apiBaseUrl and orgId are required");
+    }
+    try {
+      const url = "".concat(apiBaseUrl.replace(/\/$/, ''), "/api/v1/deploy-agent/").concat(orgId);
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        credentials: "include"
+      });
+      if (!response.ok) {
+        throw new Error("HTTP error! status: ".concat(response.status));
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      console.error("Failed to fetch agent configuration:", error);
+      throw error;
+    }
+  };
+
+  const SESSION_KEY = 'eshal_chat_session';
+  const getTimeoutMs = (value, unit) => {
+    if (value === undefined || value === null || !unit) return null;
+    const multipliers = {
+      MINUTES: 60 * 1000,
+      HOURS: 60 * 60 * 1000,
+      DAYS: 24 * 60 * 60 * 1000
+    };
+    const upperUnit = unit.toUpperCase();
+    const multiplier = multipliers[upperUnit];
+    if (multiplier === undefined) {
+      console.warn("[Session] Unknown timeout unit: ".concat(unit));
+      return null;
+    }
+    return Number(value) * multiplier;
+  };
+  const getSession = orgId => {
+    try {
+      const raw = localStorage.getItem("".concat(SESSION_KEY, "_").concat(orgId));
+      if (!raw) return null;
+      return JSON.parse(raw);
+    } catch (_unused) {
+      return null;
+    }
+  };
+  const isSessionValid = (session, timeoutValue, timeoutUnit) => {
+    if (!session || !session.lastActivity) return false;
+
+    // If no timeout is configured, session is always valid
+    if (timeoutValue === undefined || timeoutValue === null || timeoutValue === 0) {
+      return true;
+    }
+    const timeoutMs = getTimeoutMs(timeoutValue, timeoutUnit);
+    if (!timeoutMs) return true; // Default to valid if unit is missing but value was provided (to avoid accidental wipes)
+
+    const lastActivity = new Date(session.lastActivity).getTime();
+    const elapsed = Date.now() - lastActivity;
+    const isValid = elapsed < timeoutMs;
+    if (!isValid) {
+      console.log("[Session] Session expired. Elapsed: ".concat(Math.floor(elapsed / 1000), "s, Timeout: ").concat(Math.floor(timeoutMs / 1000), "s"));
+    }
+    return isValid;
+  };
+  const saveSession = function (orgId, conversationId) {
+    let extra = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    try {
+      const now = new Date().toISOString();
+      console.log("[Session] Saving new session: ".concat(conversationId, " for org: ").concat(orgId));
+      localStorage.setItem("".concat(SESSION_KEY, "_").concat(orgId), JSON.stringify(_objectSpread2({
+        conversationId,
+        lastActivity: now,
+        createdAt: now
+      }, extra)));
+    } catch (_unused2) {}
+  };
+  const updateActivity = orgId => {
+    try {
+      const session = getSession(orgId);
+      if (!session) return;
+      session.lastActivity = new Date().toISOString();
+      localStorage.setItem("".concat(SESSION_KEY, "_").concat(orgId), JSON.stringify(session));
+    } catch (_unused3) {}
+  };
+  const markOnboardingCompleted = orgId => {
+    try {
+      const session = getSession(orgId);
+      if (!session) return;
+      session.onboardingCompleted = true;
+      localStorage.setItem("".concat(SESSION_KEY, "_").concat(orgId), JSON.stringify(session));
+    } catch (_unused4) {}
+  };
+  const markCsatSubmitted = orgId => {
+    try {
+      const session = getSession(orgId);
+      if (!session) return;
+      session.csatSubmitted = true;
+      localStorage.setItem("".concat(SESSION_KEY, "_").concat(orgId), JSON.stringify(session));
+    } catch (_unused5) {}
+  };
+  const clearSession = orgId => {
+    try {
+      localStorage.removeItem("".concat(SESSION_KEY, "_").concat(orgId));
+    } catch (_unused6) {}
+  };
+  const savePromptSuggestions = (orgId, prompts) => {
+    try {
+      if (!orgId) return;
+      if (!Array.isArray(prompts) || prompts.length === 0) {
+        localStorage.removeItem("".concat(SESSION_KEY, "_prompts_").concat(orgId));
+        return;
+      }
+      localStorage.setItem("".concat(SESSION_KEY, "_prompts_").concat(orgId), JSON.stringify(prompts));
+    } catch (_unused7) {}
+  };
+  const getPromptSuggestions = orgId => {
+    try {
+      const raw = localStorage.getItem("".concat(SESSION_KEY, "_prompts_").concat(orgId));
+      if (!raw) return [];
+      return JSON.parse(raw) || [];
+    } catch (_unused8) {
+      return [];
+    }
+  };
+
   const createMessage = _ref => {
     let {
       id,
@@ -1317,51 +1508,6 @@
     }
     return [];
   };
-  const validateOnboardingAnswer = (question, answer) => {
-    var _question$fieldType;
-    if (!answer.trim()) {
-      return {
-        isValid: false,
-        errorMessage: "This field is required."
-      };
-    }
-    const fieldType = (_question$fieldType = question.fieldType) === null || _question$fieldType === void 0 ? void 0 : _question$fieldType.toLowerCase();
-
-    // Email validation
-    if (fieldType === "email") {
-      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-      if (!emailRegex.test(answer)) {
-        return {
-          isValid: false,
-          errorMessage: "Please enter a valid email address."
-        };
-      }
-    }
-
-    // Phone validation
-    if (fieldType === "phone") {
-      const phoneRegex = /^[+]?[\d\s-]{10,15}$/;
-      if (!phoneRegex.test(answer.replace(/\s/g, ""))) {
-        return {
-          isValid: false,
-          errorMessage: "Please enter a valid phone number."
-        };
-      }
-    }
-
-    // Name validation
-    if (fieldType === "fullname") {
-      if (answer.length > 50) {
-        return {
-          isValid: false,
-          errorMessage: "Name must be less than 50 characters."
-        };
-      }
-    }
-    return {
-      isValid: true
-    };
-  };
   const useChatState = _ref2 => {
     let {
       welcomeMessage,
@@ -1375,12 +1521,22 @@
       enableVoiceInteraction = false,
       onboardingQuestions = [],
       onboardingEnabled = false,
-      collectionPrompt
+      collectionPrompt,
+      inactivityTimeoutValue,
+      inactivityTimeoutUnit
     } = _ref2;
     const [isOpen, setIsOpen] = reactExports.useState(autoOpen);
     const [isMinimized, setIsMinimized] = reactExports.useState(false);
     const [isDark, setIsDark] = reactExports.useState(darkMode);
     const [messages, setMessages] = reactExports.useState(() => {
+      // If a valid session exists, start empty — history will be loaded by the session effect
+      try {
+        const existing = getSession(organizationId);
+        // Only start empty if we explicitly know there's a valid session to restore
+        if (inactivityTimeoutValue !== undefined && existing && isSessionValid(existing, inactivityTimeoutValue, inactivityTimeoutUnit)) {
+          return [];
+        }
+      } catch (_unused) {}
       if (!welcomeMessage) {
         return [];
       }
@@ -1397,23 +1553,37 @@
     const widgetRef = reactExports.useRef(null);
     const messageIdRef = reactExports.useRef(1);
 
-    // Onboarding state: show form first when onboarding is enabled (no message required)
+    // Onboarding state: restore from session so it survives page refresh
     const [onboardingActive, setOnboardingActive] = reactExports.useState(false);
-    const [onboardingCompleted, setOnboardingCompleted] = reactExports.useState(false);
-    const [currentQuestionIndex, setCurrentQuestionIndex] = reactExports.useState(0);
+    const [onboardingCompleted, setOnboardingCompleted] = reactExports.useState(() => {
+      try {
+        const existing = getSession(organizationId);
+        if (existing && existing.onboardingCompleted) return true;
+      } catch (_unused2) {}
+      return false;
+    });
     const [pendingUserIntent, setPendingUserIntent] = reactExports.useState(null);
     const [onboardingAnswers, setOnboardingAnswers] = reactExports.useState({});
-    const [hasUserInteracted, setHasUserInteracted] = reactExports.useState(false);
-    const [isProcessingAnswer, setIsProcessingAnswer] = reactExports.useState(false);
     const pendingIntentProcessedRef = reactExports.useRef(false);
 
     // Bidi/Voice state
+    const [isConversationLoading, setIsConversationLoading] = reactExports.useState(false);
     const [isVoiceSessionActive, setIsVoiceSessionActive] = reactExports.useState(false);
     const [bidiMessages, setBidiMessages] = reactExports.useState([]);
     const [voiceStatus, setVoiceStatus] = reactExports.useState("idle"); // 'idle' | 'connecting' | 'connected' | 'error'
     const [voiceError, setVoiceError] = reactExports.useState(null);
-    const [voiceConclusionForCsat, setVoiceConclusionForCsat] = reactExports.useState(false); // set when backend sends conclusion_detected in voice so ChatWindow can show CSAT
-    const [bidiSessionId] = reactExports.useState(() => "widget-session-".concat(Math.random().toString(36).slice(2, 9)));
+    const [voiceConclusionForCsat, setVoiceConclusionForCsat] = reactExports.useState(false);
+    const [bidiSessionId, setBidiSessionId] = reactExports.useState(() => {
+      try {
+        const existing = getSession(organizationId);
+        // Only restore if config is loaded and verified valid
+        if (inactivityTimeoutValue !== undefined && existing && isSessionValid(existing, inactivityTimeoutValue, inactivityTimeoutUnit)) {
+          return existing.conversationId;
+        }
+      } catch (_unused3) {}
+      // Otherwise start with a fresh ID (which may be reverted to restored ID in effect if found valid later)
+      return "widget-session-".concat(Math.random().toString(36).slice(2, 9));
+    });
 
     // Bidi refs
     const websocketRef = reactExports.useRef(null);
@@ -1460,7 +1630,106 @@
       setIsDark(darkMode);
     }, [darkMode]);
 
-    // When onboarding is enabled, show the form as the first screen (no message required)
+    // Session manager: on mount, either restore existing session or create a new one
+    const historyLoadedRef = reactExports.useRef(false); // true once fetch is initiated
+    const historyHasMessagesRef = reactExports.useRef(false); // true once history with messages is loaded
+    const inactivityInitializedRef = reactExports.useRef(false); // true after first inactivity effect run
+    reactExports.useEffect(() => {
+      // Wait for all configuration to be ready
+      if (!organizationId || !bidiSessionId || inactivityTimeoutValue === undefined) return;
+      const existing = getSession(organizationId);
+
+      // Check validity ONLY if an existing session was found
+      const hasValidSession = existing && isSessionValid(existing, inactivityTimeoutValue, inactivityTimeoutUnit);
+      if (hasValidSession) {
+        // Ensure the stateful session ID matches the persisted valid session
+        if (bidiSessionId !== existing.conversationId) {
+          setBidiSessionId(existing.conversationId);
+          return;
+        }
+
+        // Restore session — fetch conversation history once
+        if (!historyLoadedRef.current && apiBaseUrl) {
+          historyLoadedRef.current = true;
+          setIsConversationLoading(true);
+          fetchConversationHistory(apiBaseUrl, organizationId, bidiSessionId).then(msgs => {
+            // Filter out onboarding field messages (name/email/phone) so they don't appear as chat bubbles
+            const ONBOARDING_TYPES = ['userName', 'email', 'phone', 'fullname', 'mobileno', 'name'];
+            const chatMsgs = msgs.filter(msg => {
+              const msgType = msg.type || msg.messageType;
+              if (msgType && ONBOARDING_TYPES.includes(msgType)) return false;
+              return true;
+            });
+            if (chatMsgs.length > 0) {
+              historyHasMessagesRef.current = true;
+              const historyMessages = chatMsgs.map((msg, index) => _objectSpread2(_objectSpread2({}, createMessage({
+                id: msg.id || "history-".concat(index, "-").concat(Date.now()),
+                role: msg.role || (msg.sender === 'user' ? 'user' : 'assistant'),
+                content: msg.message || msg.content || ''
+              })), {}, {
+                timestamp: msg.time ? new Date(msg.time) : new Date()
+              }, Array.isArray(msg.prompts) && msg.prompts.length > 0 ? {
+                prompts: msg.prompts
+              } : {}));
+
+              // If the API didn't return prompts on any message, restore from localStorage
+              const hasAnyPrompts = historyMessages.some(m => m.role === 'assistant' && Array.isArray(m.prompts) && m.prompts.length > 0);
+              if (!hasAnyPrompts) {
+                const savedPrompts = getPromptSuggestions(organizationId);
+                if (savedPrompts.length > 0) {
+                  // Attach saved prompts to the last assistant message
+                  for (let i = historyMessages.length - 1; i >= 0; i -= 1) {
+                    if (historyMessages[i].role === 'assistant') {
+                      historyMessages[i] = _objectSpread2(_objectSpread2({}, historyMessages[i]), {}, {
+                        prompts: savedPrompts
+                      });
+                      break;
+                    }
+                  }
+                }
+              }
+              setMessages(historyMessages);
+            }
+          }).catch(err => {
+            console.error('[Session] History fetch failed:', err);
+          }).finally(() => {
+            setIsConversationLoading(false);
+          });
+        }
+      } else {
+        // Session is expired, invalid, or non-existent
+        if (!historyLoadedRef.current) {
+          historyLoadedRef.current = true;
+        }
+
+        // If we are currently holding an EXPIRED ID, rotate it
+        if (existing && bidiSessionId === existing.conversationId) {
+          const newId = "widget-session-".concat(Math.random().toString(36).slice(2, 9));
+          console.warn("[Session] Rotating expired ID ".concat(bidiSessionId, " -> ").concat(newId));
+          setBidiSessionId(newId);
+          // Note: saveSession will be called on the next run with the newId
+        } else {
+          // We have a fresh ID (either from initializer or rotation), persist it if not already there
+          if (!existing || existing.conversationId !== bidiSessionId) {
+            saveSession(organizationId, bidiSessionId);
+          }
+        }
+      }
+    }, [organizationId, bidiSessionId, apiBaseUrl, inactivityTimeoutValue, inactivityTimeoutUnit]);
+
+    // Persist prompt suggestions to localStorage so they survive page refresh
+    reactExports.useEffect(() => {
+      if (!organizationId || !messages || messages.length === 0) return;
+      for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const msg = messages[i];
+        if ((msg === null || msg === void 0 ? void 0 : msg.role) === 'assistant' && Array.isArray(msg.prompts) && msg.prompts.length > 0) {
+          savePromptSuggestions(organizationId, msg.prompts);
+          return;
+        }
+      }
+    }, [messages, organizationId]);
+
+    // Show the onboarding form on first load; bypass it if already completed (persisted in session)
     reactExports.useEffect(() => {
       if (!onboardingEnabled || onboardingCompleted) return;
       const questions = getOnboardingQuestions(onboardingQuestions);
@@ -1469,9 +1738,9 @@
       }
     }, [onboardingEnabled, onboardingCompleted, onboardingQuestions]);
 
-    // Sync welcome message updates
+    // Sync welcome message updates — skip entirely when history has been loaded
     reactExports.useEffect(() => {
-      if (!welcomeMessage) {
+      if (!welcomeMessage || historyHasMessagesRef.current) {
         return;
       }
       setMessages(prev => {
@@ -1486,7 +1755,6 @@
         }
         const [first, ...rest] = prev;
         if (first.isWelcome) {
-          // Keep the same ID when updating welcome message content
           return [_objectSpread2(_objectSpread2({}, first), {}, {
             content: welcomeMessage
           }), ...rest];
@@ -1620,10 +1888,12 @@
         // For regular messages, process the stream
         if (apiType === 'inquiry' || apiType === 'complaint' || apiType === 'technical') {
           await processStream(stream, setMessages);
+          updateActivity(organizationId);
           return {
             success: true
           };
         }
+        updateActivity(organizationId);
         return {
           success: true
         };
@@ -1652,15 +1922,6 @@
         }
       }
     }, [apiBaseUrl, apiKey, getNextMessageId, organizationId, messages, bidiSessionId]);
-    const startOnboarding = reactExports.useCallback(() => {
-      const questions = getOnboardingQuestions(onboardingQuestions);
-      if (questions.length === 0) {
-        return;
-      }
-      setOnboardingActive(true);
-      setCurrentQuestionIndex(0);
-      // Form UI shows all questions at once; no intro/first-question messages
-    }, [onboardingQuestions]);
     const handleOnboardingFormSubmit = reactExports.useCallback(async answers => {
       const questions = getOnboardingQuestions(onboardingQuestions);
       if (questions.length === 0) return;
@@ -1684,17 +1945,8 @@
       }
       setOnboardingActive(false);
       setOnboardingCompleted(true);
+      markOnboardingCompleted(organizationId);
       setOnboardingAnswers(prev => _objectSpread2(_objectSpread2({}, prev), answers));
-
-      // Confirmation message disabled - no need to show after onboarding
-      // const successMessage = createMessage({
-      //   id: getNextMessageId(),
-      //   role: "assistant",
-      //   content: "Thank you! I've received your information.",
-      //   isProcessing: false,
-      // });
-      // setMessages((prev) => [...prev, successMessage]);
-
       if (pendingUserIntent && !pendingIntentProcessedRef.current) {
         pendingIntentProcessedRef.current = true;
         setTimeout(() => {
@@ -1702,157 +1954,16 @@
           setPendingUserIntent(null);
         }, 500);
       }
-    }, [onboardingQuestions, sendMessage, getNextMessageId, pendingUserIntent]);
-    const handleOnboardingAnswer = reactExports.useCallback(async answer => {
-      if (isProcessingAnswer) {
-        return;
-      }
-      const questions = getOnboardingQuestions(onboardingQuestions);
-      const currentQuestion = questions[currentQuestionIndex];
-      if (!currentQuestion) {
-        console.error("No question found at index", currentQuestionIndex);
-        return;
-      }
-
-      // Validate answer first
-      const validation = validateOnboardingAnswer(currentQuestion, answer);
-      if (!validation.isValid) {
-        const errorMessage = createMessage({
-          id: getNextMessageId(),
-          role: "assistant",
-          content: validation.errorMessage || "Invalid input. Please try again.",
-          isProcessing: false
-        });
-        setMessages(prev => [...prev, errorMessage]);
-        return;
-      }
-      setIsProcessingAnswer(true);
-      const fieldType = currentQuestion.fieldType || "question_".concat(currentQuestionIndex);
-
-      // Add user message to UI
-      const userAnswer = createMessage({
-        id: getNextMessageId(),
-        role: "user",
-        content: answer,
-        timestamp: new Date(),
-        isProcessing: false
-      });
-      setMessages(prev => [...prev, userAnswer]);
-
-      // Save answer locally
-      setOnboardingAnswers(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
-        [fieldType]: answer
-      }));
-      try {
-        // Send to API
-        const response = await sendMessage(answer, fieldType);
-        if (!response || !response.success) {
-          const errorMsg = createMessage({
-            id: getNextMessageId(),
-            role: "assistant",
-            content: (response === null || response === void 0 ? void 0 : response.error) || "Failed to save your answer. Please try again.",
-            isProcessing: false
-          });
-          setMessages(prev => [...prev, errorMsg]);
-          setIsProcessingAnswer(false);
-          return;
-        }
-        const nextIndex = currentQuestionIndex + 1;
-        if (nextIndex < questions.length) {
-          setCurrentQuestionIndex(nextIndex);
-          setIsProcessingAnswer(false);
-          setTimeout(() => {
-            var _nextQuestion$askToTy;
-            const nextQuestion = questions[nextIndex];
-            const questionMessage = createMessage({
-              id: getNextMessageId(),
-              role: "assistant",
-              content: (_nextQuestion$askToTy = nextQuestion.askToType) !== null && _nextQuestion$askToTy !== void 0 ? _nextQuestion$askToTy : nextQuestion,
-              isProcessing: false
-            });
-            setMessages(prev => [...prev, questionMessage]);
-          }, 300);
-        } else {
-          // Onboarding completed
-          setOnboardingActive(false);
-          setOnboardingCompleted(true);
-          setIsProcessingAnswer(false);
-          setTimeout(() => {
-            // Confirmation message disabled - no need to show after onboarding
-            // const successMessage = createMessage({
-            //   id: getNextMessageId(),
-            //   role: "assistant",
-            //   content: "Thank you! I've received your information.",
-            //   isProcessing: false,
-            // });
-            // setMessages((prev) => [...prev, successMessage]);
-
-            // If there's a pending user intent, pre-fill input
-            if (pendingUserIntent && !pendingIntentProcessedRef.current) {
-              pendingIntentProcessedRef.current = true;
-              setTimeout(() => {
-                setInputValue(pendingUserIntent);
-                setPendingUserIntent(null);
-              }, 500);
-            }
-          }, 300);
-        }
-      } catch (error) {
-        const errorMsg = createMessage({
-          id: getNextMessageId(),
-          role: "assistant",
-          content: "An error occurred. Please try again.",
-          isProcessing: false
-        });
-        setMessages(prev => [...prev, errorMsg]);
-        setIsProcessingAnswer(false);
-      }
-    }, [onboardingQuestions, currentQuestionIndex, pendingUserIntent, sendMessage, isProcessingAnswer, getNextMessageId]);
+    }, [onboardingQuestions, sendMessage, getNextMessageId, pendingUserIntent, organizationId]);
     const handleSmartSubmit = reactExports.useCallback(async () => {
-      const questions = getOnboardingQuestions(onboardingQuestions);
       const trimmedInput = inputValue.trim();
-      if (!trimmedInput) {
-        return;
-      }
-
-      // Case 1: No onboarding questions OR onboarding already completed OR onboarding disabled
-      if (questions.length === 0 || onboardingCompleted || !onboardingEnabled) {
-        await sendMessage(trimmedInput);
-        return;
-      }
-
-      // Case 2: User's FIRST interaction - start onboarding
-      if (!hasUserInteracted && !onboardingActive) {
-        setHasUserInteracted(true);
-        pendingIntentProcessedRef.current = false;
-
-        // Add user message to chat immediately
-        const userMessage = createMessage({
-          id: getNextMessageId(),
-          role: "user",
-          content: trimmedInput,
-          timestamp: new Date(),
-          isProcessing: false
-        });
-        setMessages(prev => [...prev, userMessage]);
-
-        // Store the user's intent
-        setPendingUserIntent(trimmedInput);
-        setInputValue("");
-        startOnboarding();
-        return;
-      }
-
-      // Case 3: Onboarding is ACTIVE - handle answer
-      if (onboardingActive) {
-        await handleOnboardingAnswer(trimmedInput);
-        setInputValue("");
-        return;
-      }
+      if (!trimmedInput) return;
 
-      // Default: send as regular message
+      // Onboarding is handled entirely by the OnboardingForm component.
+      // The text input is hidden while onboarding is active, so any message
+      // arriving here is a normal chat message.
       await sendMessage(trimmedInput);
-    }, [onboardingQuestions, inputValue, onboardingActive, onboardingCompleted, hasUserInteracted, startOnboarding, handleOnboardingAnswer, sendMessage, getNextMessageId]);
+    }, [inputValue, sendMessage]);
     const handleSend = reactExports.useCallback(async () => {
       await handleSmartSubmit();
     }, [handleSmartSubmit]);
@@ -1871,47 +1982,11 @@
     };
     const handleQuickQuestion = reactExports.useCallback(async question => {
       const trimmedQuestion = question === null || question === void 0 ? void 0 : question.trim();
-      if (!trimmedQuestion) {
-        return;
-      }
-      const questions = getOnboardingQuestions(onboardingQuestions);
-
-      // Case 1: No onboarding questions OR onboarding already completed OR onboarding disabled
-      if (questions.length === 0 || onboardingCompleted || !onboardingEnabled) {
-        await sendMessage(trimmedQuestion);
-        return;
-      }
-
-      // Case 2: User's FIRST interaction - start onboarding
-      if (!hasUserInteracted && !onboardingActive) {
-        setHasUserInteracted(true);
-        pendingIntentProcessedRef.current = false;
-
-        // Add user message to chat immediately
-        const userMessage = createMessage({
-          id: getNextMessageId(),
-          role: "user",
-          content: trimmedQuestion,
-          timestamp: new Date(),
-          isProcessing: false
-        });
-        setMessages(prev => [...prev, userMessage]);
-
-        // Store the user's intent
-        setPendingUserIntent(trimmedQuestion);
-        startOnboarding();
-        return;
-      }
-
-      // Case 3: Onboarding is ACTIVE - handle answer
-      if (onboardingActive) {
-        await handleOnboardingAnswer(trimmedQuestion);
-        return;
-      }
+      if (!trimmedQuestion) return;
 
-      // Default: send as regular message
+      // Quick questions are only visible after onboarding is complete (input is hidden during onboarding)
       await sendMessage(trimmedQuestion);
-    }, [onboardingQuestions, onboardingActive, onboardingCompleted, hasUserInteracted, startOnboarding, handleOnboardingAnswer, sendMessage, getNextMessageId]);
+    }, [sendMessage]);
 
     /**
      * Handle user decision for HITL (Human-in-the-Loop)
@@ -1948,35 +2023,19 @@
       if (!currentInputMessageIdRef.current) {
         return;
       }
-      console.log("[BIDI] finalizePendingInputMessage called", {
-        messageId: currentInputMessageIdRef.current
-      });
       setBidiMessages(prev => {
         const updated = prev.map(message => message.id === currentInputMessageIdRef.current ? _objectSpread2(_objectSpread2({}, message), {}, {
           isProcessing: false
         }) : message);
-        console.log("[BIDI] finalizePendingInputMessage: updated state", {
-          messageId: currentInputMessageIdRef.current,
-          found: prev.some(m => m.id === currentInputMessageIdRef.current),
-          prevLength: prev.length,
-          newLength: updated.length
-        });
         return updated;
       });
       currentInputMessageIdRef.current = null;
     }, []);
     const appendUserTranscription = reactExports.useCallback(function (text) {
       let finished = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      console.log("[BIDI] appendUserTranscription called", {
-        text: text === null || text === void 0 ? void 0 : text.substring(0, 50),
-        finished,
-        currentInputId: currentInputMessageIdRef.current
-      });
-
       // Mark that user has spoken - now we can process assistant responses
       userHasSpokenRef.current = true;
       if (!text || typeof text === 'string' && !text.trim()) {
-        console.log("[BIDI] appendUserTranscription: skipping empty text");
         if (finished && currentInputMessageIdRef.current) {
           setBidiMessages(prev => prev.map(message => message.id === currentInputMessageIdRef.current ? _objectSpread2(_objectSpread2({}, message), {}, {
             isProcessing: false
@@ -2008,17 +2067,9 @@
             const assistantTime = latestAssistantMessage.timestamp instanceof Date ? latestAssistantMessage.timestamp.getTime() : new Date(latestAssistantMessage.timestamp).getTime();
             // Use timestamp 1ms before the assistant message to ensure user appears first
             userTimestamp = new Date(assistantTime - 1);
-            console.log("[BIDI] appendUserTranscription: using timestamp before assistant message", {
-              assistantTime: new Date(assistantTime).toISOString(),
-              userTime: userTimestamp.toISOString(),
-              assistantId: latestAssistantMessage.id
-            });
           } else {
             // No assistant message yet, use current time
             userTimestamp = new Date(now);
-            console.log("[BIDI] appendUserTranscription: no assistant message, using current time", {
-              userTime: userTimestamp.toISOString()
-            });
           }
           const userMessage = createMessage({
             id: newId,
@@ -2039,13 +2090,6 @@
             result = [...result, userMessage];
             // Set ref AFTER adding message to result array
             currentInputMessageIdRef.current = newId;
-            console.log("[BIDI] appendUserTranscription: created new user message", {
-              messageId: newId,
-              content: chunk.substring(0, 50),
-              prevLength,
-              newLength: result.length,
-              allMessageIds: result.map(m => m.id)
-            });
           } else {
             console.warn("[BIDI] appendUserTranscription: message already exists, updating instead", {
               messageId: newId
@@ -2061,18 +2105,10 @@
           const userMessageExists = result.some(m => m.id === currentInputMessageIdRef.current);
           if (userMessageExists) {
             result = result.map(message => {
-              var _message$content, _message$content2;
               if (message.id !== currentInputMessageIdRef.current) {
                 return message;
               }
               const combined = cleanCJKSpaces("".concat(message.content || "").concat(chunk));
-              console.log("[BIDI] appendUserTranscription: updating existing message", {
-                messageId: message.id,
-                oldContent: (_message$content = message.content) === null || _message$content === void 0 ? void 0 : _message$content.substring(0, 30),
-                newContent: combined.substring(0, 50),
-                oldLength: ((_message$content2 = message.content) === null || _message$content2 === void 0 ? void 0 : _message$content2.length) || 0,
-                newLength: combined.length
-              });
               return _objectSpread2(_objectSpread2({}, message), {}, {
                 content: combined,
                 // CRITICAL: Don't update timestamp when appending content - preserve original timestamp for ordering
@@ -2107,12 +2143,6 @@
             });
           }
         }
-        console.log("[BIDI] appendUserTranscription: state update complete", {
-          prevLength,
-          newLength: result.length,
-          messageIds: result.map(m => m.id),
-          messageRoles: result.map(m => m.role)
-        });
 
         // CRITICAL: Safety check - never return fewer messages than we started with
         if (result.length < prevLength) {
@@ -2141,9 +2171,6 @@
         return result;
       });
       if (finished) {
-        console.log("[BIDI] appendUserTranscription: finalizing message", {
-          messageId: currentInputMessageIdRef.current
-        });
         currentInputMessageIdRef.current = null;
         setIsLoading(true);
       }
@@ -2182,9 +2209,6 @@
       if (isProcessingAssistantUpdateRef.current) {
         // Check if this is the exact same content we're already processing
         if (lastProcessedAssistantContentRef.current === contentKey) {
-          console.log("[BIDI] appendAssistantContent: skipping duplicate - already processing", {
-            contentKey
-          });
           return;
         }
         // If it's different content, we need to wait - but for now, let it through
@@ -2220,9 +2244,6 @@
             result = result.map(message => message.id === inputMessageIdToFinalize ? _objectSpread2(_objectSpread2({}, message), {}, {
               isProcessing: false
             }) : message);
-            console.log("[BIDI] appendAssistantContent: finalized input message atomically", {
-              inputMessageId: inputMessageIdToFinalize
-            });
           } else {
             console.warn("[BIDI] appendAssistantContent: input message not found for finalization", {
               inputMessageId: inputMessageIdToFinalize,
@@ -2258,13 +2279,6 @@
             result = [...result, assistantMessage];
             // Set ref AFTER adding message to result array to ensure consistency
             currentAssistantMessageIdRef.current = newId;
-            console.log("[BIDI] appendAssistantContent: created new assistant message", {
-              messageId: newId,
-              content: text.substring(0, 100),
-              prevLength,
-              newLength: result.length,
-              allMessageIds: result.map(m => m.id)
-            });
           } else {
             console.error("[BIDI] appendAssistantContent: ERROR - message ID collision!", {
               messageId: newId,
@@ -2283,14 +2297,14 @@
           const assistantMessageExists = result.some(m => m.id === currentAssistantMessageIdRef.current);
           if (assistantMessageExists) {
             result = result.map(message => {
-              var _message$content3;
+              var _message$content;
               if (message.id !== currentAssistantMessageIdRef.current) {
                 return message;
               }
               const newContent = "".concat(message.content || "").concat(text);
               console.log("[BIDI] appendAssistantContent: updating existing message", {
                 messageId: message.id,
-                oldContentLength: ((_message$content3 = message.content) === null || _message$content3 === void 0 ? void 0 : _message$content3.length) || 0,
+                oldContentLength: ((_message$content = message.content) === null || _message$content === void 0 ? void 0 : _message$content.length) || 0,
                 newContentLength: newContent.length,
                 textLength: text.length
               });
@@ -2469,8 +2483,34 @@
         }) : message;
       }));
     }, []);
+    const stopVoiceSession = reactExports.useCallback(() => {
+      var _audioPlayerNodeRef$c, _audioPlayerContextRe, _audioRecorderNodeRef, _audioRecorderContext;
+      setIsVoiceSessionActive(false);
+      setIsLoading(false);
+      isVoiceSessionActiveRef.current = false;
+      setVoiceStatus("idle");
+      setVoiceError(null);
+
+      // Reset userHasSpoken flag when stopping session
+      userHasSpokenRef.current = false;
+      if (websocketRef.current && websocketRef.current.readyState === WebSocket.OPEN) {
+        websocketRef.current.close();
+      }
+      websocketRef.current = null;
+      (_audioPlayerNodeRef$c = audioPlayerNodeRef.current) === null || _audioPlayerNodeRef$c === void 0 || _audioPlayerNodeRef$c.disconnect();
+      (_audioPlayerContextRe = audioPlayerContextRef.current) === null || _audioPlayerContextRe === void 0 || _audioPlayerContextRe.close();
+      audioPlayerNodeRef.current = null;
+      audioPlayerContextRef.current = null;
+      (_audioRecorderNodeRef = audioRecorderNodeRef.current) === null || _audioRecorderNodeRef === void 0 || _audioRecorderNodeRef.disconnect();
+      (_audioRecorderContext = audioRecorderContextRef.current) === null || _audioRecorderContext === void 0 || _audioRecorderContext.close();
+      audioRecorderNodeRef.current = null;
+      audioRecorderContextRef.current = null;
+      stopMicrophone(micStreamRef.current);
+      micStreamRef.current = null;
+      isAudioReadyRef.current = false;
+    }, []);
     const handleBidiEvent = reactExports.useCallback(event => {
-      var _event$content, _event$conclusion_det, _event$outputTranscri3, _event$content4;
+      var _event$content, _event$conclusion_det, _event$outputTranscri2, _event$content3;
       console.log("[BIDI] handleBidiEvent called", {
         event,
         isVoiceSessionActive: isVoiceSessionActiveRef.current,
@@ -2495,10 +2535,28 @@
         setVoiceConclusionForCsat(true);
       }
       if (event.turnComplete) {
-        console.log("[BIDI] handleBidiEvent: processing turnComplete");
         handleTurnComplete();
         return;
       }
+
+      // Handle conversation conclusion detection from bidi/voice
+      if (typeof conclusionDetected === "boolean" && conclusionDetected) {
+        stopVoiceSession();
+        // Mark the last bidi assistant message with conclusionDetected so ChatWindow picks it up
+        setBidiMessages(prev => {
+          const updated = [...prev];
+          for (let i = updated.length - 1; i >= 0; i--) {
+            if (updated[i].role === "assistant") {
+              updated[i] = _objectSpread2(_objectSpread2({}, updated[i]), {}, {
+                conclusionDetected: true
+              });
+              break;
+            }
+          }
+          return updated;
+        });
+        return;
+      }
       if (event.interrupted) {
         console.log("[BIDI] handleBidiEvent: processing interrupted");
         handleInterrupted();
@@ -2517,6 +2575,7 @@
 
         // Only call appendUserTranscription if there's actual text or if it's finished
         if (transcriptionText || transcriptionFinished) {
+          updateActivity(organizationId);
           appendUserTranscription(transcriptionText, transcriptionFinished);
         } else {
           console.warn("[BIDI] handleBidiEvent: inputTranscription event has no text and not finished", event.inputTranscription);
@@ -2529,30 +2588,16 @@
         var _event$outputTranscri, _event$content2;
         // Silently ignore assistant responses before user speaks
         if ((_event$outputTranscri = event.outputTranscription) !== null && _event$outputTranscri !== void 0 && _event$outputTranscri.text || (_event$content2 = event.content) !== null && _event$content2 !== void 0 && _event$content2.parts) {
-          var _event$outputTranscri2, _event$content3;
-          console.log("[BIDI] handleBidiEvent: ignoring assistant response - user hasn't spoken yet", {
-            hasOutputTranscription: !!((_event$outputTranscri2 = event.outputTranscription) !== null && _event$outputTranscri2 !== void 0 && _event$outputTranscri2.text),
-            hasContentParts: !!((_event$content3 = event.content) !== null && _event$content3 !== void 0 && _event$content3.parts)
-          });
           return;
         }
       }
-      if ((_event$outputTranscri3 = event.outputTranscription) !== null && _event$outputTranscri3 !== void 0 && _event$outputTranscri3.text) {
-        console.log("[BIDI] handleBidiEvent: processing outputTranscription", {
-          text: event.outputTranscription.text.substring(0, 50),
-          finished: event.outputTranscription.finished
-        });
+      if ((_event$outputTranscri2 = event.outputTranscription) !== null && _event$outputTranscri2 !== void 0 && _event$outputTranscri2.text) {
         appendAssistantContent(event.outputTranscription.text, Boolean(event.outputTranscription.finished));
       }
-      if ((_event$content4 = event.content) !== null && _event$content4 !== void 0 && _event$content4.parts) {
-        var _event$content5;
+      if ((_event$content3 = event.content) !== null && _event$content3 !== void 0 && _event$content3.parts) {
+        var _event$content4;
         // Check if the content has a finished flag, or if the event itself indicates completion
-        const contentFinished = ((_event$content5 = event.content) === null || _event$content5 === void 0 ? void 0 : _event$content5.finished) || event.finished || false;
-        console.log("[BIDI] handleBidiEvent: processing content parts", {
-          partsCount: event.content.parts.length,
-          contentFinished,
-          eventFinished: event.finished
-        });
+        const contentFinished = ((_event$content4 = event.content) === null || _event$content4 === void 0 ? void 0 : _event$content4.finished) || event.finished || false;
         handleContentParts(event.content.parts, contentFinished);
       }
 
@@ -2560,7 +2605,7 @@
       if (!event.turnComplete && !event.interrupted && !event.inputTranscription && !event.outputTranscription && !event.content) {
         console.warn("[BIDI] handleBidiEvent: event had no recognized fields", event);
       }
-    }, [appendAssistantContent, appendUserTranscription, handleContentParts, handleInterrupted, handleTurnComplete]);
+    }, [appendAssistantContent, appendUserTranscription, handleContentParts, handleInterrupted, handleTurnComplete, stopVoiceSession]);
     const handleRecorderAudio = reactExports.useCallback(pcmData => {
       const ws = websocketRef.current;
       if (!isVoiceSessionActiveRef.current || !ws || ws.readyState !== WebSocket.OPEN) {
@@ -2692,37 +2737,6 @@
         setVoiceStatus("error");
       }
     }, [enableVoiceInteraction, organizationId, welcomeMessage, connectWebsocket, initializeAudioPipeline, messages]);
-    const stopVoiceSession = reactExports.useCallback(() => {
-      var _audioPlayerNodeRef$c, _audioPlayerContextRe, _audioRecorderNodeRef, _audioRecorderContext;
-      setIsVoiceSessionActive(false);
-      setIsLoading(false);
-      isVoiceSessionActiveRef.current = false;
-      setVoiceStatus("idle");
-      setVoiceError(null);
-
-      // Reset userHasSpoken flag when stopping session
-      userHasSpokenRef.current = false;
-      if (websocketRef.current && websocketRef.current.readyState === WebSocket.OPEN) {
-        websocketRef.current.close();
-      }
-      websocketRef.current = null;
-      (_audioPlayerNodeRef$c = audioPlayerNodeRef.current) === null || _audioPlayerNodeRef$c === void 0 || _audioPlayerNodeRef$c.disconnect();
-      (_audioPlayerContextRe = audioPlayerContextRef.current) === null || _audioPlayerContextRe === void 0 || _audioPlayerContextRe.close();
-      audioPlayerNodeRef.current = null;
-      audioPlayerContextRef.current = null;
-      (_audioRecorderNodeRef = audioRecorderNodeRef.current) === null || _audioRecorderNodeRef === void 0 || _audioRecorderNodeRef.disconnect();
-      (_audioRecorderContext = audioRecorderContextRef.current) === null || _audioRecorderContext === void 0 || _audioRecorderContext.close();
-      audioRecorderNodeRef.current = null;
-      audioRecorderContextRef.current = null;
-      stopMicrophone(micStreamRef.current);
-      micStreamRef.current = null;
-      isAudioReadyRef.current = false;
-    }, []);
-
-    // Keep ref updated so handleBidiEvent (defined earlier) can call stopVoiceSession without TDZ
-    reactExports.useEffect(() => {
-      stopVoiceSessionRef.current = stopVoiceSession;
-    }, [stopVoiceSession]);
     const handleVoiceToggle = reactExports.useCallback(() => {
       if (isVoiceSessionActive) {
         stopVoiceSession();
@@ -2750,6 +2764,7 @@
         type: "text",
         text: trimmed
       }));
+      updateActivity(organizationId);
       setIsLoading(true);
       const userMessage = createMessage({
         id: "bidi-user-".concat(Date.now()),
@@ -2782,6 +2797,116 @@
         isAudioReadyRef.current = false;
       };
     }, []);
+
+    // Reset entire conversation state after CSAT / closing — mirrors preview behaviour
+    const resetConversation = reactExports.useCallback(() => {
+      // Clear persisted session and prompt suggestions so the next mount starts fresh
+      clearSession(organizationId);
+      savePromptSuggestions(organizationId, []);
+
+      // Reset messages
+      setMessages([]);
+      setBidiMessages([]);
+
+      // Reset onboarding
+      setOnboardingActive(false);
+      setOnboardingCompleted(false);
+      setOnboardingAnswers({});
+      setPendingUserIntent(null);
+      pendingIntentProcessedRef.current = false;
+      userHasSpokenRef.current = false;
+      historyLoadedRef.current = false;
+      historyHasMessagesRef.current = false;
+
+      // Create a new session id and persist it
+      const newSessionId = "widget-session-".concat(Math.random().toString(36).slice(2, 9));
+      saveSession(organizationId, newSessionId);
+      setBidiSessionId(newSessionId);
+
+      // Re-show the welcome message
+      if (welcomeMessage && welcomeMessage.trim() !== "") {
+        setMessages([_objectSpread2(_objectSpread2({}, createMessage({
+          id: Date.now().toString(),
+          role: "assistant",
+          content: welcomeMessage
+        })), {}, {
+          isWelcome: true
+        })]);
+      }
+
+      // Re-trigger onboarding if enabled
+      if (onboardingEnabled) {
+        const questions = getOnboardingQuestions(onboardingQuestions);
+        if (questions.length > 0) {
+          setOnboardingActive(true);
+        }
+      }
+    }, [organizationId, welcomeMessage, onboardingEnabled, onboardingQuestions]);
+
+    // Keep a stable ref to resetConversation so the timer effect does not need to
+    // list it as a dependency (avoids spurious re-runs — and spurious updateActivity
+    // calls — whenever resetConversation's identity changes due to parent re-renders).
+    const resetConversationRef = reactExports.useRef(resetConversation);
+    reactExports.useEffect(() => {
+      resetConversationRef.current = resetConversation;
+    }, [resetConversation]);
+
+    // Precise inactivity timeout: schedules a setTimeout for exact remaining time,
+    // then reschedules itself after each check (handles activity updates in localStorage).
+    //
+    // Corner cases handled:
+    //  - Initial mount / page refresh: reads stored lastActivity and checks if already
+    //    expired → resets immediately, otherwise schedules for the remaining time.
+    //  - Config change (value/unit updated): refreshes lastActivity to NOW so the new
+    //    timeout starts fresh WITHOUT resetting the conversation or creating a new session ID.
+    //  - orgId change: resets the initialized flag so the next run is treated as initial mount.
+    reactExports.useEffect(() => {
+      // Reset initialized flag when org changes so we do an immediate expiry check for the new org
+      inactivityInitializedRef.current = false;
+    }, [organizationId]);
+    reactExports.useEffect(() => {
+      if (!organizationId || !inactivityTimeoutValue) return;
+      const timeoutMs = getTimeoutMs(inactivityTimeoutValue, inactivityTimeoutUnit);
+      if (!timeoutMs) return;
+      const isConfigChange = inactivityInitializedRef.current;
+      inactivityInitializedRef.current = true;
+      if (isConfigChange) {
+        // The actual timeout config (value/unit) changed at runtime — refresh lastActivity
+        // to now so the new timeout period starts from this moment, preserving the session.
+        const existing = getSession(organizationId);
+        if (existing) {
+          updateActivity(organizationId);
+        }
+      }
+      // On page refresh or initial mount, isConfigChange is false so we do NOT touch
+      // lastActivity — the stored timestamp is used as-is to calculate remaining time.
+
+      let timerId = null;
+      const scheduleCheck = () => {
+        const session = getSession(organizationId);
+        if (!session) return;
+        const lastActivityTime = new Date(session.lastActivity).getTime();
+        const elapsed = Date.now() - lastActivityTime;
+        const remaining = timeoutMs - elapsed;
+        if (remaining <= 0) {
+          console.warn("[Session] Inactivity timeout reached! Resetting conversation immediately.");
+          resetConversationRef.current();
+          return;
+        }
+        timerId = setTimeout(scheduleCheck, remaining);
+      };
+
+      // On initial mount: check immediately (session may already be expired).
+      // On config change: lastActivity was just set to now, so remaining ≈ timeoutMs.
+      scheduleCheck();
+      return () => {
+        if (timerId) clearTimeout(timerId);
+      };
+      // resetConversation intentionally omitted — accessed via resetConversationRef to
+      // prevent the effect from re-running (and resetting lastActivity) on identity changes.
+      // bidiSessionId IS included so the timer restarts after a session reset.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [organizationId, inactivityTimeoutValue, inactivityTimeoutUnit, bidiSessionId]);
     const memoizedQuickQuestions = reactExports.useMemo(() => quickQuestions, [quickQuestions]);
 
     // Merge and sort messages from both sources (text and voice) by timestamp
@@ -2838,6 +2963,7 @@
       messages: activeMessages,
       inputValue,
       isLoading,
+      isConversationLoading,
       widgetRef,
       quickQuestions: memoizedQuickQuestions,
       // Bidi/Voice state
@@ -2862,7 +2988,9 @@
       handleDecision,
       // Bidi/Voice actions
       handleVoiceToggle,
-      sendBidiTextMessage
+      sendBidiTextMessage,
+      // Session lifecycle
+      resetConversation
     };
   };
 
@@ -58491,10 +58619,12 @@
       companyName,
       apiBaseUrl,
       organizationId,
-      onPromptSuggestionClick
+      onPromptSuggestionClick,
+      conversationResetKey
     } = _ref;
     const messagesEndRef = reactExports.useRef(null);
     const shouldAutoScrollRef = reactExports.useRef(true);
+    const hasInitialScrolledRef = reactExports.useRef(false);
     const autoScrollKey = reactExports.useMemo(() => messages.map(message => {
       var _message$content$leng, _message$content;
       return "".concat(message.id, ":").concat((_message$content$leng = (_message$content = message.content) === null || _message$content === void 0 ? void 0 : _message$content.length) !== null && _message$content$leng !== void 0 ? _message$content$leng : 0, ":").concat(message.isProcessing ? 1 : 0);
@@ -58520,6 +58650,38 @@
         container.removeEventListener("scroll", updateAutoScrollIntent);
       };
     }, [updateAutoScrollIntent, messagesContainerRef]);
+
+    // When the conversation resets (new session ID), unlock initial scroll so we
+    // jump to the bottom when the welcome message appears.
+    reactExports.useEffect(() => {
+      if (!conversationResetKey) return;
+      shouldAutoScrollRef.current = true;
+      hasInitialScrolledRef.current = false;
+    }, [conversationResetKey]);
+
+    // Force instant scroll to bottom on first message load (covers history restore + post-reset)
+    reactExports.useEffect(() => {
+      if (hasInitialScrolledRef.current || messages.length === 0 || typeof window === "undefined") {
+        return undefined;
+      }
+      hasInitialScrolledRef.current = true;
+      let frame2;
+      const frame1 = window.requestAnimationFrame(() => {
+        frame2 = window.requestAnimationFrame(() => {
+          var _messagesEndRef$curre;
+          (_messagesEndRef$curre = messagesEndRef.current) === null || _messagesEndRef$curre === void 0 || _messagesEndRef$curre.scrollIntoView({
+            behavior: "instant",
+            block: "end"
+          });
+          shouldAutoScrollRef.current = true;
+        });
+      });
+      return () => {
+        window.cancelAnimationFrame(frame1);
+        window.cancelAnimationFrame(frame2);
+      };
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [messages.length === 0]);
     reactExports.useEffect(() => {
       if (!shouldAutoScrollRef.current) {
         return undefined;
@@ -58528,8 +58690,8 @@
         return undefined;
       }
       const frame = window.requestAnimationFrame(() => {
-        var _messagesEndRef$curre;
-        (_messagesEndRef$curre = messagesEndRef.current) === null || _messagesEndRef$curre === void 0 || _messagesEndRef$curre.scrollIntoView({
+        var _messagesEndRef$curre2;
+        (_messagesEndRef$curre2 = messagesEndRef.current) === null || _messagesEndRef$curre2 === void 0 || _messagesEndRef$curre2.scrollIntoView({
           behavior: "smooth",
           block: "end"
         });
@@ -58681,6 +58843,7 @@
       isOpen,
       isMinimized,
       isLoading,
+      isConversationLoading = false,
       placeholder,
       textColor,
       fontFamily,
@@ -58756,13 +58919,13 @@
     const handleChange = event => {
       setInputValue(event.target.value);
     };
-    const isDisabled = !inputValue.trim() || isLoading;
+    const isDisabled = !inputValue.trim() || isLoading || isConversationLoading;
     const separatorColor = isDark ? "#374151" : "#e5e7eb";
 
     // Check if onboarding flow exists and is not completed
     const hasOnboardingQuestions = onboardingQuestions && onboardingQuestions.length > 0;
     const isOnboardingIncomplete = hasOnboardingQuestions && !onboardingCompleted;
-    const isVoiceButtonDisabled = csatVisible || onboardingEnabled && isOnboardingIncomplete || voiceStatus === "connecting";
+    const isVoiceButtonDisabled = csatVisible || isConversationLoading || onboardingEnabled && isOnboardingIncomplete || voiceStatus === "connecting";
 
     // Determine tooltip message
     const getTooltipMessage = () => {
@@ -58943,9 +59106,9 @@
             onFocus: () => setIsFocused(true),
             onBlur: () => setIsFocused(false),
             onKeyDown: handleKeyPress,
-            placeholder: placeholder || "Type your message...",
+            placeholder: isConversationLoading ? "Agent is loading..." : placeholder || "Type your message...",
             rows: 1,
-            disabled: csatVisible || isLoading || isVoiceSessionActive && voiceStatus !== "connected",
+            disabled: csatVisible || isConversationLoading || isLoading || isVoiceSessionActive && voiceStatus !== "connected",
             dir: isRtl ? "rtl" : "ltr",
             className: "w-full px-4 bg-transparent rounded-xl leading-normal ".concat(isDark ? "text-gray-100" : "text-gray-900", " placeholder-gray-400 resize-none outline-none scrollbar-hide"),
             style: {
@@ -59700,6 +59863,7 @@
       companyLogo,
       messages,
       isLoading,
+      isConversationLoading = false,
       inputValue,
       setInputValue,
       onSend,
@@ -59752,12 +59916,30 @@
       csatTriggerType = "ON_END",
       csatIdleTimeoutMins = 30,
       onPromptSuggestionClick,
-      onboardingEnabled = false
+      onboardingEnabled = false,
+      onResetConversation
     } = _ref;
     useGoogleFont(fontFamily);
     const messagesContainerRef = reactExports.useRef(null);
     const [showCsat, setShowCsat] = reactExports.useState(false);
-    const [csatSubmitted, setCsatSubmitted] = reactExports.useState(false);
+    const [csatSubmitted, setCsatSubmitted] = reactExports.useState(() => {
+      try {
+        var _getSession$csatSubmi, _getSession;
+        return (_getSession$csatSubmi = (_getSession = getSession(organizationId)) === null || _getSession === void 0 ? void 0 : _getSession.csatSubmitted) !== null && _getSession$csatSubmi !== void 0 ? _getSession$csatSubmi : false;
+      } catch (_unused) {
+        return false;
+      }
+    });
+
+    // Sync csatSubmitted from session whenever the conversation changes
+    reactExports.useEffect(() => {
+      try {
+        var _getSession$csatSubmi2, _getSession2;
+        const submitted = (_getSession$csatSubmi2 = (_getSession2 = getSession(organizationId)) === null || _getSession2 === void 0 ? void 0 : _getSession2.csatSubmitted) !== null && _getSession$csatSubmi2 !== void 0 ? _getSession$csatSubmi2 : false;
+        setCsatSubmitted(submitted);
+        if (submitted) setShowCsat(false);
+      } catch (_unused2) {}
+    }, [conversationId, organizationId]);
     // const [lastUserMessageTime, setLastUserMessageTime] = useState(null);
 
     // Auto-scroll hook
@@ -59846,6 +60028,8 @@
     const handleCsatRating = async (rating, format) => {
       setCsatSubmitted(true); // optimistic UI
       setShowCsat(false);
+      markCsatSubmitted(organizationId); // persist so page refresh doesn't re-show CSAT
+
       try {
         const headers = {
           "Content-Type": "application/json"
@@ -59868,6 +60052,8 @@
         if (!response.ok) {
           console.error("CSAT submission failed:", await response.text());
         }
+
+        // Session continues after CSAT submission — no reset
       } catch (error) {
         console.error("CSAT submission error:", error);
       }
@@ -59966,7 +60152,8 @@
             conciergeName: conciergeName,
             companyName: companyName,
             apiBaseUrl: apiBaseUrl,
-            organizationId: organizationId
+            organizationId: organizationId,
+            conversationResetKey: conversationId
           }), showCsat && csatEnabled && !csatSubmitted && /*#__PURE__*/jsxRuntimeExports.jsx("div", {
             className: "",
             children: /*#__PURE__*/jsxRuntimeExports.jsx(CSATWidget, {
@@ -59996,6 +60183,7 @@
           isOpen: isOpen,
           isMinimized: isMinimized,
           isLoading: isLoading,
+          isConversationLoading: isConversationLoading,
           placeholder: placeholder,
           textColor: resolvedTextColor,
           fontFamily: fontFamily,
@@ -60061,64 +60249,6 @@
     });
   };
 
-  const createSession = async config => {
-    // Initialize chat session if needed
-    if (config.sessionUrl) {
-      try {
-        const response = await fetch(config.sessionUrl, {
-          method: "POST",
-          headers: _objectSpread2({
-            "Content-Type": "application/json"
-          }, config.apiKey && {
-            Authorization: "Bearer ".concat(config.apiKey)
-          }),
-          body: JSON.stringify({
-            userId: config.userId,
-            userName: config.userName,
-            userEmail: config.userEmail
-          }),
-          credentials: "include"
-        });
-        const data = await response.json();
-        return data.sessionId;
-      } catch (error) {
-        console.error("Session creation error:", error);
-        return null;
-      }
-    }
-    return null;
-  };
-
-  /**
-   * Fetches agent configuration from the deploy-agent endpoint
-   * @param {string} apiBaseUrl - Base URL for the API
-   * @param {string} orgId - Organization ID
-   * @returns {Promise<object>} Agent configuration object
-   */
-  const fetchAgentConfig = async (apiBaseUrl, orgId) => {
-    if (!apiBaseUrl || !orgId) {
-      throw new Error("apiBaseUrl and orgId are required");
-    }
-    try {
-      const url = "".concat(apiBaseUrl.replace(/\/$/, ''), "/api/v1/deploy-agent/").concat(orgId);
-      const response = await fetch(url, {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        credentials: "include"
-      });
-      if (!response.ok) {
-        throw new Error("HTTP error! status: ".concat(response.status));
-      }
-      const data = await response.json();
-      return data;
-    } catch (error) {
-      console.error("Failed to fetch agent configuration:", error);
-      throw error;
-    }
-  };
-
   const ChatWidget = _ref => {
     var _agentConfig$concierg;
     let {
@@ -60193,7 +60323,7 @@
 
     // Map API response to widget props (use props as overrides if provided)
     const widgetConfig = reactExports.useMemo(() => {
-      var _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9, _ref0, _ref1, _ref10, _ref11, _ref12, _ref13, _ref14, _ref15, _ref16, _ref17, _ref18, _ref19, _ref20, _ref21, _ref22, _ref23, _ref24, _ref25, _ref26, _ref27, _ref28, _ref29, _ref30, _ref31, _ref32, _ref33, _ref34, _ref35, _ref36, _agentConfig$csatEnab, _agentConfig$csatForm, _agentConfig$csatProm, _agentConfig$csatTrig, _agentConfig$csatIdle, _agentConfig$csatFoll, _agentConfig$csatFoll2;
+      var _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9, _ref0, _ref1, _ref10, _ref11, _ref12, _ref13, _ref14, _ref15, _ref16, _ref17, _ref18, _ref19, _ref20, _ref21, _ref22, _ref23, _ref24, _agentConfig$inactivi, _agentConfig$inactivi2, _ref25, _ref26, _ref27, _ref28, _ref29, _ref30, _ref31, _ref32, _ref33, _ref34, _ref35, _ref36, _agentConfig$csatEnab, _agentConfig$csatForm, _agentConfig$csatProm, _agentConfig$csatTrig, _agentConfig$csatIdle, _agentConfig$csatFoll, _agentConfig$csatFoll2;
       if (!agentConfig) {
         return null;
       }
@@ -60227,6 +60357,8 @@
         allowedDomains: finalAllowedDomains,
         launcherPosition: (_ref23 = position !== null && position !== void 0 ? position : agentConfig.launcherPosition) !== null && _ref23 !== void 0 ? _ref23 : "bottom-right",
         onboardingEnabled: (_ref24 = onboardingEnabled !== null && onboardingEnabled !== void 0 ? onboardingEnabled : agentConfig.onboardingEnabled) !== null && _ref24 !== void 0 ? _ref24 : false,
+        inactivityTimeoutValue: (_agentConfig$inactivi = agentConfig.inactivityTimeoutValue) !== null && _agentConfig$inactivi !== void 0 ? _agentConfig$inactivi : null,
+        inactivityTimeoutUnit: (_agentConfig$inactivi2 = agentConfig.inactivityTimeoutUnit) !== null && _agentConfig$inactivi2 !== void 0 ? _agentConfig$inactivi2 : null,
         agentMessageBubbleFontFamily: (_ref25 = (_ref26 = (_ref27 = agentMessageBubbleFontFamily !== null && agentMessageBubbleFontFamily !== void 0 ? agentMessageBubbleFontFamily : agentConfig.agentMessageBubbleFontFamily) !== null && _ref27 !== void 0 ? _ref27 : fontFamily) !== null && _ref26 !== void 0 ? _ref26 : agentConfig.fontFamily) !== null && _ref25 !== void 0 ? _ref25 : "Inter",
         agentMessageBubbleFontSize: (_ref28 = (_ref29 = (_ref30 = agentMessageBubbleFontSize !== null && agentMessageBubbleFontSize !== void 0 ? agentMessageBubbleFontSize : agentConfig.agentMessageBubbleFontSize) !== null && _ref30 !== void 0 ? _ref30 : fontSize) !== null && _ref29 !== void 0 ? _ref29 : agentConfig.fontSize) !== null && _ref28 !== void 0 ? _ref28 : "14px",
         userMessageBubbleFontFamily: (_ref31 = (_ref32 = (_ref33 = userMessageBubbleFontFamily !== null && userMessageBubbleFontFamily !== void 0 ? userMessageBubbleFontFamily : agentConfig.userMessageBubbleFontFamily) !== null && _ref33 !== void 0 ? _ref33 : fontFamily) !== null && _ref32 !== void 0 ? _ref32 : agentConfig.fontFamily) !== null && _ref31 !== void 0 ? _ref31 : "Inter",
@@ -60277,6 +60409,7 @@
       messages,
       inputValue,
       isLoading,
+      isConversationLoading,
       widgetRef,
       setInputValue,
       handleSend,
@@ -60296,7 +60429,8 @@
       onboardingActive,
       onboardingCompleted,
       handleOnboardingFormSubmit,
-      conversationId
+      conversationId,
+      resetConversation
     } = useChatState(widgetConfig ? {
       welcomeMessage: widgetConfig.welcomeMessage,
       quickQuestions: widgetConfig.quickQuestions,
@@ -60309,7 +60443,9 @@
       enableVoiceInteraction: widgetConfig.enableVoiceInteraction,
       onboardingQuestions: widgetConfig.onboardingQuestions,
       onboardingEnabled: widgetConfig.onboardingEnabled,
-      collectionPrompt: widgetConfig.collectionPrompt
+      collectionPrompt: widgetConfig.collectionPrompt,
+      inactivityTimeoutValue: widgetConfig.inactivityTimeoutValue,
+      inactivityTimeoutUnit: widgetConfig.inactivityTimeoutUnit
     } : defaultConfig);
 
     // Set CSS variables for theming (must be called before early returns)
@@ -60408,7 +60544,8 @@
           csatPrompt: widgetConfig.csatPrompt,
           csatTriggerType: widgetConfig.csatTriggerType,
           csatIdleTimeoutMins: widgetConfig.csatIdleTimeoutMins,
-          onboardingEnabled: widgetConfig.onboardingEnabled
+          onboardingEnabled: widgetConfig.onboardingEnabled,
+          onResetConversation: resetConversation
         }), !isOpen && /*#__PURE__*/jsxRuntimeExports.jsx(ToggleButton, {
           isOpen: isOpen,
           isDark: isDark,