@om_patel_26/chat-widget 1.0.1

package/dist/core/stateManager.esm.js

@@ -0,0 +1,907 @@
+import { createDialogflowSession, sendDialogflowMessage } from "../services/dialogflowClient.esm.js";
+import { createChatService, ChatResolvedError } from "../services/chatService.esm.js";
+import { safeLocalStorage } from "../utils/ssr.esm.js";
+class WidgetStateManager {
+  constructor(config) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.chatMode = "ai";
+    this.chatId = null;
+    this.supportSessionId = null;
+    this.chatService = null;
+    this.collectingUserInfo = false;
+    this.userInfoStep = null;
+    this.collectedUserName = "";
+    this.collectedUserEmail = "";
+    this.collectedUserMobile = "";
+    this.wsConnected = false;
+    this.agentTyping = false;
+    this.currentAgent = { name: "Agent" };
+    this.isConnectingToAgent = false;
+    this.agentAccepted = false;
+    this.chatResolved = false;
+    this.historyLoaded = null;
+    this.typingTimeout = null;
+    this.agentTypingTimeout = null;
+    this.config = config;
+    this.state = {
+      isOpen: false,
+      showWelcomePopup: false,
+      messages: [],
+      inputValue: "",
+      isLoading: false,
+      error: null,
+      sessionId: null,
+      chatMode: "ai"
+    };
+    this.chatService = createChatService({
+      baseUrl: this.config.backendBaseUrl || "http://localhost:8012",
+      wsUrl: this.config.backendWsUrl || "ws://localhost:8012",
+      debug: this.config.debug || false
+    });
+    const storage = safeLocalStorage();
+    const savedMode = storage.getItem("blockspark_chat_mode");
+    if (savedMode) {
+      this.chatMode = savedMode === "HUMAN" ? "human" : "ai";
+      this.state.chatMode = this.chatMode;
+    }
+    this.chatId = storage.getItem("blockspark_chat_id");
+    this.supportSessionId = storage.getItem("blockspark_session_id");
+  }
+  /**
+   * Subscribe to state changes
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Update state and notify listeners
+   */
+  setState(updates) {
+    this.state = { ...this.state, ...updates };
+    this.listeners.forEach((listener) => listener(this.getState()));
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Open chat
+   */
+  async openChat() {
+    this.setState({ isOpen: true });
+    if (this.state.showWelcomePopup) {
+      this.setState({ showWelcomePopup: false });
+    }
+    if (this.state.chatMode === "ai" && !this.state.sessionId && this.config.dfProjectId && this.config.dfAgentId) {
+      try {
+        this.setState({ isLoading: true });
+        const dialogflowConfig = {
+          dfProjectId: this.config.dfProjectId,
+          dfLocation: this.config.dfLocation || "us-central1",
+          dfAgentId: this.config.dfAgentId,
+          serviceAccountKey: this.config.serviceAccountKey,
+          accessToken: this.config.accessToken,
+          languageCode: this.config.languageCode || "en"
+        };
+        const session = await createDialogflowSession(dialogflowConfig);
+        this.setState({
+          sessionId: session.session_id,
+          isLoading: false
+        });
+        if (session.message) {
+          const welcomeMessage = {
+            id: `welcome-${Date.now()}`,
+            text: session.message,
+            sender: "bot",
+            timestamp: /* @__PURE__ */ new Date(),
+            richContent: session.richContent
+          };
+          this.setState({
+            messages: [welcomeMessage]
+          });
+        }
+      } catch (error) {
+        console.error("Error initializing Dialogflow session:", error);
+        this.setState({
+          isLoading: false,
+          error: error.message || "Failed to initialize chat"
+        });
+        const fallbackMessage = {
+          id: `fallback-${Date.now()}`,
+          text: this.config.fallbackWelcomeMessage || "Hello! How can I help you today?",
+          sender: "bot",
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        this.setState({
+          messages: [fallbackMessage]
+        });
+      }
+    }
+  }
+  /**
+   * Close chat
+   */
+  closeChat() {
+    this.setState({ isOpen: false });
+  }
+  /**
+   * Close welcome popup
+   */
+  closeWelcomePopup() {
+    this.setState({ showWelcomePopup: false });
+  }
+  /**
+   * Toggle chat
+   */
+  toggleChat() {
+    const willBeOpen = !this.state.isOpen;
+    this.setState({ isOpen: willBeOpen });
+    if (willBeOpen && this.state.showWelcomePopup) {
+      this.setState({ showWelcomePopup: false });
+    }
+  }
+  /**
+   * Set input value
+   */
+  setInputValue(value) {
+    this.setState({ inputValue: value });
+  }
+  /**
+   * Clear error
+   */
+  clearError() {
+    this.setState({ error: null });
+  }
+  /**
+   * Send message
+   */
+  async sendMessage(text, skipUserMessage = false) {
+    if (!text.trim() || this.state.isLoading) {
+      return;
+    }
+    if (this.collectingUserInfo) {
+      const userMessage = {
+        id: `user-${Date.now()}`,
+        text: text.trim(),
+        sender: "user",
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this.setState({
+        messages: [...this.state.messages, userMessage],
+        inputValue: "",
+        isLoading: false,
+        error: null
+      });
+      await this.handleUserInfoCollection(text);
+      return;
+    }
+    if (!skipUserMessage) {
+      const userMessage = {
+        id: `user-${Date.now()}`,
+        text: text.trim(),
+        sender: "user",
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this.setState({
+        messages: [...this.state.messages, userMessage],
+        inputValue: "",
+        isLoading: true,
+        error: null
+      });
+    } else {
+      this.setState({
+        inputValue: "",
+        isLoading: true,
+        error: null
+      });
+    }
+    try {
+      if (this.state.chatMode === "human") {
+        await this.sendHumanMessage(text);
+      } else {
+        await this.sendAIMessage(text);
+      }
+    } catch (error) {
+      console.error("Error sending message:", error);
+      if (error instanceof ChatResolvedError || error?.name === "ChatResolvedError" || error?.message === "chat_resolved") {
+        this.enterResolvedState(this.chatId);
+        return;
+      }
+      const errorMessage = {
+        id: `error-${Date.now()}`,
+        text: this.config.debug ? `Error: ${error.message || "Failed to send message"}` : error.message?.includes("CORS") || error.message?.includes("Failed to fetch") ? "Unable to connect to Dialogflow. Please check your configuration and network." : "Sorry, I'm having trouble processing your message. Please try again.",
+        sender: "bot",
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this.setState({
+        messages: [...this.state.messages, errorMessage],
+        error: error.message || "Failed to send message",
+        isLoading: false
+      });
+    }
+  }
+  /**
+   * Send message to Dialogflow
+   */
+  async sendAIMessage(text) {
+    if (!this.config.dfProjectId || !this.config.dfAgentId) {
+      throw new Error("Dialogflow configuration is missing");
+    }
+    const dialogflowConfig = {
+      dfProjectId: this.config.dfProjectId,
+      dfLocation: this.config.dfLocation || "us-central1",
+      dfAgentId: this.config.dfAgentId,
+      serviceAccountKey: this.config.serviceAccountKey,
+      accessToken: this.config.accessToken,
+      languageCode: this.config.languageCode || "en"
+    };
+    if (!this.state.sessionId) {
+      const session = await createDialogflowSession(dialogflowConfig);
+      this.setState({ sessionId: session.session_id });
+    }
+    if (this.config.debug) {
+      console.log("Sending message to Dialogflow:", {
+        message: text,
+        sessionId: this.state.sessionId,
+        hasConfig: !!dialogflowConfig
+      });
+    }
+    const response = await sendDialogflowMessage(
+      text,
+      this.state.sessionId,
+      dialogflowConfig
+    );
+    if (this.config.debug) {
+      console.log("Dialogflow response:", {
+        response: response.response,
+        hasRichContent: !!response.richContent,
+        richContent: response.richContent
+      });
+    }
+    if (response.handoff === true) {
+      const botMessage2 = {
+        id: `bot-${Date.now()}`,
+        text: response.response || this.config.fallbackWelcomeMessage || "No response",
+        sender: "bot",
+        timestamp: /* @__PURE__ */ new Date(),
+        richContent: response.richContent
+      };
+      this.setState({
+        messages: [...this.state.messages, botMessage2],
+        isLoading: false
+      });
+      this.startUserInfoCollection();
+      return;
+    }
+    const botMessage = {
+      id: `bot-${Date.now()}`,
+      text: response.response || this.config.fallbackWelcomeMessage || "No response",
+      sender: "bot",
+      timestamp: /* @__PURE__ */ new Date(),
+      richContent: response.richContent
+    };
+    this.setState({
+      messages: [...this.state.messages, botMessage],
+      isLoading: false
+    });
+  }
+  /**
+   * Send message to human support
+   */
+  async sendHumanMessage(text) {
+    if (!this.chatId || !this.supportSessionId) {
+      const errorMessage = {
+        id: `error-${Date.now()}`,
+        text: "Chat session not initialized. Please try again.",
+        sender: "bot",
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this.setState({
+        messages: [...this.state.messages, errorMessage],
+        isLoading: false
+      });
+      return;
+    }
+    if (!this.chatService) {
+      throw new Error("Chat service not initialized");
+    }
+    this.chatService.sendTypingIndicator("typing_stop");
+    if (this.typingTimeout) {
+      clearTimeout(this.typingTimeout);
+      this.typingTimeout = null;
+    }
+    try {
+      const sentViaWs = this.chatService.sendMessageViaWebSocket(text.trim());
+      if (!sentViaWs) {
+        await this.chatService.sendMessageToAgent(this.chatId, this.supportSessionId, text.trim());
+      }
+      this.setState({ isLoading: false });
+    } catch (error) {
+      if (error instanceof ChatResolvedError || error?.name === "ChatResolvedError" || error?.message === "chat_resolved") {
+        this.enterResolvedState(this.chatId);
+        return;
+      }
+      if (error.message?.includes("Chat not found") || error.message?.includes("unauthorized") || error.message?.includes("401") || error.message?.includes("404")) {
+        if (this.config.debug) {
+          console.log("⚠️ Chat expired. Re-initializing...");
+        }
+        this.chatId = null;
+        this.supportSessionId = null;
+        const storage = safeLocalStorage();
+        storage.removeItem("blockspark_chat_id");
+        storage.removeItem("blockspark_session_id");
+        try {
+          const newSession = await this.chatService.startSupportChat(
+            this.state.sessionId || null,
+            null,
+            null,
+            null
+          );
+          this.chatId = newSession.chat_id;
+          this.supportSessionId = newSession.session_id;
+          const storage1 = safeLocalStorage();
+          storage1.setItem("blockspark_chat_id", this.chatId);
+          storage1.setItem("blockspark_session_id", this.supportSessionId);
+          if (this.chatId && this.supportSessionId) {
+            await this.chatService.sendMessageToAgent(
+              this.chatId,
+              this.supportSessionId,
+              text.trim()
+            );
+          }
+          this.setState({ isLoading: false });
+          return;
+        } catch (retryError) {
+          if (retryError instanceof ChatResolvedError || retryError?.message === "chat_resolved") {
+            this.enterResolvedState(this.chatId);
+            return;
+          }
+          throw retryError;
+        }
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Switch to human mode
+   */
+  switchToHumanMode() {
+    this.chatMode = "human";
+    this.setState({ chatMode: "human" });
+    safeLocalStorage().setItem("blockspark_chat_mode", "HUMAN");
+  }
+  /**
+   * Switch to AI mode
+   */
+  switchToBotMode() {
+    this.chatMode = "ai";
+    this.setState({ chatMode: "ai" });
+    safeLocalStorage().setItem("blockspark_chat_mode", "BOT");
+  }
+  /**
+   * Initialize welcome popup
+   */
+  initializeWelcomePopup() {
+    if (this.config.showWelcomePopup !== false) {
+      const delay = this.config.welcomePopupDelay || 1500;
+      setTimeout(() => {
+        if (!this.state.isOpen) {
+          this.setState({ showWelcomePopup: true });
+        }
+      }, delay);
+    }
+  }
+  /**
+   * Start user info collection for handoff
+   */
+  startUserInfoCollection() {
+    this.collectingUserInfo = true;
+    this.userInfoStep = "name";
+    this.collectedUserName = "";
+    this.collectedUserEmail = "";
+    this.collectedUserMobile = "";
+    const namePrompt = {
+      id: `prompt-${Date.now()}`,
+      text: "To connect you with a human agent, I'll need some information. Please provide your name:",
+      sender: "bot",
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.setState({
+      messages: [...this.state.messages, namePrompt]
+    });
+  }
+  /**
+   * Handle user info collection
+   */
+  async handleUserInfoCollection(text) {
+    if (this.userInfoStep === "name") {
+      const name = text.trim();
+      this.collectedUserName = name;
+      this.userInfoStep = "email";
+      const emailPrompt = {
+        id: `prompt-${Date.now()}`,
+        text: "Thank you! Now please provide your email address:",
+        sender: "bot",
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this.setState({
+        messages: [...this.state.messages, emailPrompt],
+        inputValue: ""
+      });
+      return;
+    } else if (this.userInfoStep === "email") {
+      const email = text.trim();
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      if (!emailRegex.test(email)) {
+        const invalidEmailMessage = {
+          id: `prompt-${Date.now()}`,
+          text: "Please provide a valid email address:",
+          sender: "bot",
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        this.setState({
+          messages: [...this.state.messages, invalidEmailMessage],
+          inputValue: ""
+        });
+        return;
+      }
+      this.collectedUserEmail = email;
+      this.userInfoStep = "mobile";
+      const mobilePrompt = {
+        id: `prompt-${Date.now()}`,
+        text: "Thank you! Now please provide your mobile number:",
+        sender: "bot",
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this.setState({
+        messages: [...this.state.messages, mobilePrompt],
+        inputValue: ""
+      });
+      return;
+    } else if (this.userInfoStep === "mobile") {
+      const mobile = text.trim();
+      const mobileRegex = /^[\+]?[(]?[0-9]{1,4}[)]?[-\s\.]?[(]?[0-9]{1,4}[)]?[-\s\.]?[0-9]{1,9}$/;
+      if (!mobileRegex.test(mobile) || mobile.length < 10) {
+        const invalidMobileMessage = {
+          id: `prompt-${Date.now()}`,
+          text: "Please provide a valid mobile number (e.g., +1234567890):",
+          sender: "bot",
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        this.setState({
+          messages: [...this.state.messages, invalidMobileMessage],
+          inputValue: ""
+        });
+        return;
+      }
+      this.collectedUserMobile = mobile;
+      this.collectingUserInfo = false;
+      this.userInfoStep = null;
+      await this.handleHandoff(this.collectedUserName, this.collectedUserEmail, mobile);
+      this.setState({ inputValue: "" });
+    }
+  }
+  /**
+   * Handle handoff from Dialogflow to human support
+   */
+  async handleHandoff(customerName, customerEmail, customerMobile) {
+    if (!this.chatService) {
+      throw new Error("Chat service not initialized");
+    }
+    try {
+      this.isConnectingToAgent = true;
+      const dialogflowSessionId = this.state.sessionId;
+      const session = await this.chatService.ensureChatInitialized(
+        this.chatId,
+        this.supportSessionId,
+        dialogflowSessionId || null,
+        customerName || null,
+        customerEmail || null,
+        customerMobile || null
+      );
+      if (!session || !session.chat_id) {
+        throw new Error("Failed to initialize chat session");
+      }
+      const currentChatId = session.chat_id;
+      const currentSupportSessionId = session.session_id;
+      if (currentChatId !== this.chatId) {
+        this.chatId = currentChatId;
+        this.supportSessionId = currentSupportSessionId;
+        const storage = safeLocalStorage();
+        storage.setItem("blockspark_chat_id", this.chatId);
+        storage.setItem("blockspark_session_id", this.supportSessionId);
+        if (this.config.debug) {
+          console.log("✅ Chat initialized:", { chatId: currentChatId, sessionId: currentSupportSessionId });
+        }
+      }
+      try {
+        await this.chatService.requestHandoff(
+          currentChatId,
+          currentSupportSessionId,
+          "Customer requested human agent",
+          dialogflowSessionId || null,
+          customerName || null,
+          customerEmail || null,
+          customerMobile || null
+        );
+        if (this.config.debug) {
+          console.log("✅ Handoff requested successfully");
+        }
+      } catch (handoffError) {
+        if (handoffError.message?.includes("Invalid chat_id") || handoffError.message?.includes("Chat not found") || handoffError.message?.includes("unauthorized") || handoffError.message?.includes("400") || handoffError.message?.includes("401") || handoffError.message?.includes("404") || handoffError.message?.includes("expired")) {
+          if (this.config.debug) {
+            console.log("⚠️ Chat expired or not found. Re-initializing chat...");
+          }
+          this.chatId = null;
+          this.supportSessionId = null;
+          const storage2 = safeLocalStorage();
+          storage2.removeItem("blockspark_chat_id");
+          storage2.removeItem("blockspark_session_id");
+          const newSession = await this.chatService.startSupportChat(
+            dialogflowSessionId || null,
+            customerName || null,
+            customerEmail || null,
+            customerMobile || null
+          );
+          if (!newSession || !newSession.chat_id) {
+            throw new Error("Failed to re-initialize chat session");
+          }
+          this.chatId = newSession.chat_id;
+          this.supportSessionId = newSession.session_id;
+          const storage4 = safeLocalStorage();
+          storage4.setItem("blockspark_chat_id", this.chatId);
+          storage4.setItem("blockspark_session_id", this.supportSessionId);
+          await this.chatService.requestHandoff(
+            this.chatId,
+            this.supportSessionId,
+            "Customer requested human agent",
+            dialogflowSessionId || null,
+            customerName || null,
+            customerEmail || null,
+            customerMobile || null
+          );
+          if (this.config.debug) {
+            console.log("✅ Handoff requested successfully after retry");
+          }
+        } else {
+          throw handoffError;
+        }
+      }
+      this.switchToHumanMode();
+      this.chatResolved = false;
+      this.agentAccepted = false;
+      const connectingMessage = {
+        id: `connecting-${Date.now()}`,
+        text: "Connecting you to a human agent...",
+        sender: "bot",
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this.setState({
+        messages: [...this.state.messages, connectingMessage]
+      });
+      if (currentChatId && currentSupportSessionId) {
+        this.chatService.connectWebSocket(
+          currentChatId,
+          currentSupportSessionId,
+          (message) => {
+            this.handleWebSocketMessage(message);
+          },
+          (connected) => {
+            this.wsConnected = connected;
+          }
+        );
+      }
+      this.isConnectingToAgent = false;
+    } catch (error) {
+      console.error("Error handling handoff:", error);
+      const errorMessage = {
+        id: `error-${Date.now()}`,
+        text: this.config.debug ? `Handoff error: ${error.message}` : "Failed to connect to agent. Please try again.",
+        sender: "bot",
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this.setState({
+        messages: [...this.state.messages, errorMessage]
+      });
+      this.isConnectingToAgent = false;
+    }
+  }
+  /**
+   * Handle WebSocket messages
+   */
+  handleWebSocketMessage(message) {
+    switch (message.type) {
+      case "message":
+        if (message.content) {
+          if (message.sender_type === "agent" || !message.sender_type) {
+            const agentMessage = {
+              id: message.id || `agent-${Date.now()}`,
+              text: message.content,
+              sender: "agent",
+              timestamp: new Date(message.timestamp || Date.now())
+            };
+            const existingIds2 = new Set(this.state.messages.map((m) => m.id));
+            if (!existingIds2.has(agentMessage.id)) {
+              this.setState({
+                messages: [...this.state.messages, agentMessage]
+              });
+            }
+            this.agentTyping = false;
+            if (this.agentTypingTimeout) {
+              clearTimeout(this.agentTypingTimeout);
+              this.agentTypingTimeout = null;
+            }
+          }
+        }
+        break;
+      case "typing_start":
+        if (message.sender_type === "agent") {
+          this.agentTyping = true;
+          if (this.agentTypingTimeout) {
+            clearTimeout(this.agentTypingTimeout);
+          }
+          this.agentTypingTimeout = setTimeout(() => {
+            this.agentTyping = false;
+          }, 3e3);
+        }
+        break;
+      case "typing_stop":
+        if (message.sender_type === "agent") {
+          this.agentTyping = false;
+          if (this.agentTypingTimeout) {
+            clearTimeout(this.agentTypingTimeout);
+            this.agentTypingTimeout = null;
+          }
+        }
+        break;
+      case "agent_changed":
+        if (message.to_agent) {
+          this.currentAgent = {
+            id: message.to_agent_id,
+            name: message.to_agent
+          };
+          const systemMessage = {
+            id: `system-${Date.now()}`,
+            text: message.from_agent ? `Chat has been transferred from ${message.from_agent} to ${message.to_agent}` : `Chat has been transferred to ${message.to_agent}`,
+            sender: "bot",
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          this.setState({
+            messages: [...this.state.messages, systemMessage]
+          });
+        }
+        break;
+      case "agent_accepted":
+        this.agentAccepted = true;
+        this.isConnectingToAgent = false;
+        const acceptedMessage = {
+          id: message.id || `agent-accepted-${Date.now()}`,
+          text: "You can chat now, the agent has accepted your request.",
+          sender: "bot",
+          timestamp: message.timestamp ? new Date(message.timestamp) : /* @__PURE__ */ new Date()
+        };
+        const existingIds = new Set(this.state.messages.map((m) => m.id));
+        if (!existingIds.has(acceptedMessage.id)) {
+          this.setState({
+            messages: [...this.state.messages, acceptedMessage]
+          });
+        }
+        if (message.to_agent) {
+          this.currentAgent = {
+            name: message.to_agent,
+            id: message.to_agent_id
+          };
+        }
+        break;
+      case "chat_resolved":
+      case "chat_ended":
+        this.enterResolvedState(message.chat_id || null);
+        break;
+      case "chat_info":
+        if (message.status === "active") {
+          this.isConnectingToAgent = false;
+          this.agentAccepted = true;
+        } else if (message.status === "resolved" || message.status === "ended") {
+          this.enterResolvedState(message.chat_id || null);
+        }
+        if (message.agent_id) {
+          this.currentAgent = {
+            ...this.currentAgent,
+            id: message.agent_id
+          };
+        }
+        break;
+      case "error":
+        console.error("WebSocket error:", message.error);
+        const errorMessage = {
+          id: `error-${Date.now()}`,
+          text: message.error || "An error occurred. Please try again.",
+          sender: "bot",
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        this.setState({
+          messages: [...this.state.messages, errorMessage]
+        });
+        break;
+    }
+  }
+  /**
+   * Enter resolved state
+   */
+  enterResolvedState(resolvedChatId) {
+    this.chatResolved = true;
+    this.isConnectingToAgent = false;
+    this.agentAccepted = false;
+    this.agentTyping = false;
+    if (this.agentTypingTimeout) {
+      clearTimeout(this.agentTypingTimeout);
+      this.agentTypingTimeout = null;
+    }
+    if (this.chatService) {
+      this.chatService.disconnectWebSocket();
+    }
+    this.chatId = null;
+    this.supportSessionId = null;
+    const storage = safeLocalStorage();
+    storage.removeItem("blockspark_chat_id");
+    storage.removeItem("blockspark_session_id");
+    const thankYouMessage = {
+      id: `resolved-${Date.now()}`,
+      text: "Thank you for contacting us!",
+      sender: "bot",
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.setState({
+      messages: [...this.state.messages, thankYouMessage]
+    });
+    setTimeout(async () => {
+      this.switchToBotMode();
+      this.chatResolved = false;
+      this.setState({
+        messages: [],
+        sessionId: null
+        // Clear session ID to force recreation
+      });
+      this.collectingUserInfo = false;
+      this.userInfoStep = null;
+      this.collectedUserName = "";
+      this.collectedUserEmail = "";
+      this.collectedUserMobile = "";
+      if (this.config.dfProjectId && this.config.dfAgentId && this.state.isOpen) {
+        try {
+          this.setState({ isLoading: true });
+          const dialogflowConfig = {
+            dfProjectId: this.config.dfProjectId,
+            dfLocation: this.config.dfLocation || "us-central1",
+            dfAgentId: this.config.dfAgentId,
+            serviceAccountKey: this.config.serviceAccountKey,
+            accessToken: this.config.accessToken,
+            languageCode: this.config.languageCode || "en"
+          };
+          const session = await createDialogflowSession(dialogflowConfig);
+          this.setState({
+            sessionId: session.session_id,
+            isLoading: false
+          });
+          if (session.message) {
+            const welcomeMessage = {
+              id: `welcome-${Date.now()}`,
+              text: session.message,
+              sender: "bot",
+              timestamp: /* @__PURE__ */ new Date(),
+              richContent: session.richContent
+            };
+            this.setState({
+              messages: [welcomeMessage]
+            });
+          }
+        } catch (error) {
+          console.error("Error recreating Dialogflow session after handoff:", error);
+          this.setState({
+            isLoading: false,
+            error: error.message || "Failed to initialize chat"
+          });
+          const fallbackMessage = {
+            id: `fallback-${Date.now()}`,
+            text: this.config.fallbackWelcomeMessage || "Hello! How can I help you today?",
+            sender: "bot",
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          this.setState({
+            messages: [fallbackMessage]
+          });
+        }
+      }
+    }, 2e3);
+  }
+  /**
+   * Load message history
+   */
+  async loadMessageHistory(preserveExisting = false) {
+    if (!this.chatService || !this.chatId || !this.supportSessionId) {
+      return;
+    }
+    try {
+      if (this.chatId && this.supportSessionId) {
+        const history = await this.chatService.loadMessageHistory(this.chatId, this.supportSessionId);
+        const historyMessages = history.map((msg) => ({
+          id: msg.id || `history-${Date.now()}-${Math.random()}`,
+          text: msg.content,
+          sender: msg.sender_type === "agent" ? "agent" : "user",
+          timestamp: new Date(msg.timestamp)
+        }));
+        if (preserveExisting) {
+          const existingIds = new Set(this.state.messages.map((m) => m.id));
+          const newMessages = historyMessages.filter((m) => !existingIds.has(m.id));
+          const combined = [...this.state.messages, ...newMessages].sort(
+            (a, b) => a.timestamp.getTime() - b.timestamp.getTime()
+          );
+          this.setState({
+            messages: combined
+          });
+        } else {
+          this.setState({
+            messages: historyMessages
+          });
+        }
+      }
+    } catch (error) {
+      console.error("Error loading message history:", error);
+      if (this.config.debug) {
+        const errorMessage = {
+          id: `error-${Date.now()}`,
+          text: `Failed to load chat history: ${error.message}`,
+          sender: "bot",
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        this.setState({
+          messages: [...this.state.messages, errorMessage]
+        });
+      }
+    }
+  }
+  /**
+   * Get additional state for UI (not in WidgetState but needed by components)
+   */
+  getAdditionalState() {
+    return {
+      wsConnected: this.wsConnected,
+      agentTyping: this.agentTyping,
+      currentAgent: this.currentAgent,
+      isConnectingToAgent: this.isConnectingToAgent,
+      agentAccepted: this.agentAccepted,
+      chatResolved: this.chatResolved
+    };
+  }
+  /**
+   * Cleanup
+   */
+  destroy() {
+    if (this.typingTimeout) {
+      clearTimeout(this.typingTimeout);
+    }
+    if (this.agentTypingTimeout) {
+      clearTimeout(this.agentTypingTimeout);
+    }
+    if (this.chatService) {
+      this.chatService.disconnectWebSocket();
+    }
+    this.listeners.clear();
+  }
+}
+export {
+  WidgetStateManager
+};
+//# sourceMappingURL=stateManager.esm.js.map