@elqnt/chat 1.0.2 → 1.0.3

package/dist/index.mjs

@@ -1,185 +1,4 @@
-import {
-  AgentStatusAway,
-  AgentStatusBusy,
-  AgentStatusOffline,
-  AgentStatusOnline,
-  AssignChatToAgentSubject,
-  AttachmentTypeActions,
-  AttachmentTypeArticles,
-  AttachmentTypeAudio,
-  AttachmentTypeBullets,
-  AttachmentTypeData,
-  AttachmentTypeDocument,
-  AttachmentTypeDocumentAnalysis,
-  AttachmentTypeDocumentSources,
-  AttachmentTypeImage,
-  AttachmentTypeKGNodes,
-  AttachmentTypeLocation,
-  AttachmentTypeRecords,
-  AttachmentTypeReferences,
-  AttachmentTypeSticker,
-  AttachmentTypeSubsections,
-  AttachmentTypeVideo,
-  ChatArchiveSubjectPattern,
-  ChatEventTypeAgentActivityPing,
-  ChatEventTypeAgentChatAssigned,
-  ChatEventTypeAgentChatCompleted,
-  ChatEventTypeAgentContextUpdate,
-  ChatEventTypeAgentExecutionEnded,
-  ChatEventTypeAgentExecutionStarted,
-  ChatEventTypeAgentSessionEnd,
-  ChatEventTypeAgentSessionStart,
-  ChatEventTypeAgentStatusChange,
-  ChatEventTypeBlockUser,
-  ChatEventTypeCSATRequest,
-  ChatEventTypeCSATResponse,
-  ChatEventTypeCSATSurvey,
-  ChatEventTypeChatEnded,
-  ChatEventTypeChatRemoved,
-  ChatEventTypeChatUpdated,
-  ChatEventTypeClientAction,
-  ChatEventTypeClientActionCallback,
-  ChatEventTypeCreateRoom,
-  ChatEventTypeDeleteRoom,
-  ChatEventTypeDelivered,
-  ChatEventTypeEndChat,
-  ChatEventTypeError,
-  ChatEventTypeGetAgents,
-  ChatEventTypeGetAgentsResponse,
-  ChatEventTypeGetOnlineUsers,
-  ChatEventTypeHumanAgentJoined,
-  ChatEventTypeHumanAgentLeft,
-  ChatEventTypeInviteUser,
-  ChatEventTypeJoinRoom,
-  ChatEventTypeLeaveRoom,
-  ChatEventTypeListChats,
-  ChatEventTypeListRooms,
-  ChatEventTypeLoadAgentContext,
-  ChatEventTypeLoadAgentContextResponse,
-  ChatEventTypeLoadChat,
-  ChatEventTypeLoadChatResponse,
-  ChatEventTypeMentionUser,
-  ChatEventTypeMessage,
-  ChatEventTypeMessageDeleted,
-  ChatEventTypeMessageDeletedResponse,
-  ChatEventTypeMessageEdited,
-  ChatEventTypeMessageEditedResponse,
-  ChatEventTypeMessageReaction,
-  ChatEventTypeMessageReactionResponse,
-  ChatEventTypeMessageReply,
-  ChatEventTypeMessageStatusUpdate,
-  ChatEventTypeNewChat,
-  ChatEventTypeNewChatCreated,
-  ChatEventTypeObserverJoined,
-  ChatEventTypeObserverLeft,
-  ChatEventTypeOnlineUsersResponse,
-  ChatEventTypePing,
-  ChatEventTypePlanApproved,
-  ChatEventTypePlanCompleted,
-  ChatEventTypePlanPendingApproval,
-  ChatEventTypePlanRejected,
-  ChatEventTypePong,
-  ChatEventTypeRead,
-  ChatEventTypeReconnected,
-  ChatEventTypeRoomCreated,
-  ChatEventTypeRoomDeleted,
-  ChatEventTypeRoomUpdated,
-  ChatEventTypeRoomUserJoined,
-  ChatEventTypeRoomUserLeft,
-  ChatEventTypeRoomsResponse,
-  ChatEventTypeStepCompleted,
-  ChatEventTypeStepFailed,
-  ChatEventTypeStepStarted,
-  ChatEventTypeStoppedTyping,
-  ChatEventTypeSummaryUpdate,
-  ChatEventTypeSyncMetadata,
-  ChatEventTypeSyncMetadataResponse,
-  ChatEventTypeSyncUserSession,
-  ChatEventTypeSyncUserSessionResponse,
-  ChatEventTypeTyping,
-  ChatEventTypeUpdateRoom,
-  ChatEventTypeUserActivity,
-  ChatEventTypeUserActivityUpdate,
-  ChatEventTypeUserInvited,
-  ChatEventTypeUserJoined,
-  ChatEventTypeUserLeft,
-  ChatEventTypeUserPresenceChanged,
-  ChatEventTypeUserPresenceEnd,
-  ChatEventTypeUserPresenceStart,
-  ChatEventTypeUserRemoved,
-  ChatEventTypeUserStatusChange,
-  ChatEventTypeUserSuggestedActionSelected,
-  ChatEventTypeUserSuggestedActions,
-  ChatEventTypeWaiting,
-  ChatEventTypeWaitingForAgent,
-  ChatRoleAI,
-  ChatRoleDataQuery,
-  ChatRoleEvent,
-  ChatRoleHumanAgent,
-  ChatRoleObserver,
-  ChatRoleSystem,
-  ChatRoleTool,
-  ChatRoleUser,
-  ChatSessionStatusActive,
-  ChatSessionStatusExpired,
-  ChatSessionStatusIdle,
-  ChatStatusAbandoned,
-  ChatStatusActive,
-  ChatStatusArchived,
-  ChatStatusClosed,
-  ChatStatusDisconnected,
-  ChatTypeCustomerSupport,
-  ChatTypeDirect,
-  ChatTypeGroup,
-  ChatTypePrivateRoom,
-  ChatTypePublicRoom,
-  CompleteChatByAgentSubject,
-  CreateAgentQueueSubject,
-  DeleteAgentQueueSubject,
-  EndAgentSessionSubject,
-  GetActiveChatCountSubject,
-  GetActiveChatsSubject,
-  GetAgentQueuesSubject,
-  GetAgentSessionSubject,
-  GetChatSubject,
-  GetDailyChatCountSubject,
-  GetOnlineAgentCountSubject,
-  GetOnlineAgentsSubject,
-  GetOnlineUsersSubject,
-  GetQueueChatCountSubject,
-  GetQueueChatsSubject,
-  GetUserChatsSubject,
-  GetWaitingForAgentChatCountSubject,
-  GetWaitingForAgentChatsSubject,
-  MessageStatusDelivered,
-  MessageStatusFailed,
-  MessageStatusRead,
-  MessageStatusSending,
-  MessageStatusSent,
-  QueueTypeComplexity,
-  QueueTypeDepartment,
-  QueueTypePriority,
-  QueueTypeSkill,
-  QueueTypes,
-  SetupOrgSubject,
-  StartAgentSessionSubject,
-  TriggerAnalyticsScanSubject,
-  UpdateAgentLastActivitySubject,
-  UpdateAgentQueueSubject,
-  UpdateAgentStatusSubject,
-  UpdateUserStatusSubject,
-  UserStatusAway,
-  UserStatusBusy,
-  UserStatusOffline,
-  UserStatusOnline,
-  useWebSocketChatAdmin
-} from "./chunk-AC5J5LX5.mjs";
-import {
-  useWebSocketChatCustomer
-} from "./chunk-XVYABY2Z.mjs";
-import {
-  useWebSocketChatBase
-} from "./chunk-F6OOS4ZM.mjs";
+"use client";
 
 // components/admin/admin-chat-input.tsx
 import { useUserContext } from "@elqnt/auth";
@@ -383,10 +202,1058 @@ var __iconNode14 = [
 var User = createLucideIcon("User", __iconNode14);
 
 // components/admin/admin-chat-input.tsx
-import { useRef, useState } from "react";
+import { useRef as useRef2, useState as useState4 } from "react";
 
 // context/websocket-chat-admin-context.tsx
 import { createContext, useContext } from "react";
+
+// hooks/use-websocket-chat-admin.ts
+import { useCallback as useCallback2, useState as useState2 } from "react";
+
+// models/chat-models.ts
+var ChatStatusActive = "active";
+var ChatStatusDisconnected = "disconnected";
+var ChatStatusAbandoned = "abandoned";
+var ChatStatusClosed = "closed";
+var ChatStatusArchived = "archived";
+var ChatTypeCustomerSupport = "customer_support";
+var ChatTypePublicRoom = "public_room";
+var ChatTypePrivateRoom = "private_room";
+var ChatTypeDirect = "direct";
+var ChatTypeGroup = "group";
+var ChatRoleUser = "user";
+var ChatRoleAI = "ai";
+var ChatRoleEvent = "event";
+var ChatRoleHumanAgent = "humanAgent";
+var ChatRoleObserver = "observer";
+var ChatRoleDataQuery = "dataQuery";
+var ChatRoleSystem = "system";
+var ChatRoleTool = "tool";
+var AgentStatusOnline = "online";
+var AgentStatusAway = "away";
+var AgentStatusBusy = "busy";
+var AgentStatusOffline = "offline";
+var ChatEventTypeUserJoined = "user_joined";
+var ChatEventTypeUserLeft = "user_left";
+var ChatEventTypeTyping = "typing";
+var ChatEventTypeStoppedTyping = "stopped_typing";
+var ChatEventTypeRead = "read";
+var ChatEventTypeDelivered = "delivered";
+var ChatEventTypeReconnected = "reconnected";
+var ChatEventTypeError = "error";
+var ChatEventTypeWaiting = "waiting";
+var ChatEventTypeLoadChat = "load_chat";
+var ChatEventTypeLoadChatResponse = "load_chat_response";
+var ChatEventTypeMessage = "message";
+var ChatEventTypeWaitingForAgent = "waiting_for_agent";
+var ChatEventTypeMessageStatusUpdate = "message_status_update";
+var ChatEventTypeHumanAgentJoined = "human_agent_joined";
+var ChatEventTypeHumanAgentLeft = "human_agent_left";
+var ChatEventTypeObserverJoined = "observer_joined";
+var ChatEventTypeObserverLeft = "observer_left";
+var ChatEventTypeListChats = "list_chats";
+var ChatEventTypeChatUpdated = "chat_updated";
+var ChatEventTypeChatRemoved = "chat_removed";
+var ChatEventTypeSyncMetadata = "sync_metadata";
+var ChatEventTypeSyncMetadataResponse = "sync_metadata_response";
+var ChatEventTypeSyncUserSession = "sync_user_session";
+var ChatEventTypeSyncUserSessionResponse = "sync_user_session_response";
+var ChatEventTypeClientAction = "client_action";
+var ChatEventTypeClientActionCallback = "client_action_callback";
+var ChatEventTypeBlockUser = "block_user";
+var ChatEventTypeCreateRoom = "create_room";
+var ChatEventTypeRoomCreated = "room_created";
+var ChatEventTypeJoinRoom = "join_room";
+var ChatEventTypeLeaveRoom = "leave_room";
+var ChatEventTypeDeleteRoom = "delete_room";
+var ChatEventTypeRoomDeleted = "room_deleted";
+var ChatEventTypeUpdateRoom = "update_room";
+var ChatEventTypeRoomUpdated = "room_updated";
+var ChatEventTypeInviteUser = "invite_user";
+var ChatEventTypeUserInvited = "user_invited";
+var ChatEventTypeRoomUserJoined = "room_user_joined";
+var ChatEventTypeRoomUserLeft = "room_user_left";
+var ChatEventTypeUserRemoved = "user_removed";
+var ChatEventTypeListRooms = "list_rooms";
+var ChatEventTypeRoomsResponse = "rooms_response";
+var ChatEventTypeMessageEdited = "message_edited";
+var ChatEventTypeMessageDeleted = "message_deleted";
+var ChatEventTypeMessageReaction = "message_reaction";
+var ChatEventTypeMessageReply = "message_reply";
+var ChatEventTypeMentionUser = "mention_user";
+var ChatEventTypeMessageEditedResponse = "message_edited_response";
+var ChatEventTypeMessageDeletedResponse = "message_deleted_response";
+var ChatEventTypeMessageReactionResponse = "message_reaction_response";
+var ChatEventTypeUserPresenceStart = "user_presence_start";
+var ChatEventTypeUserPresenceEnd = "user_presence_end";
+var ChatEventTypeUserStatusChange = "user_status_change";
+var ChatEventTypeUserActivity = "user_activity";
+var ChatEventTypeUserPresenceChanged = "user_presence_changed";
+var ChatEventTypeUserActivityUpdate = "user_activity_update";
+var ChatEventTypeGetOnlineUsers = "get_online_users";
+var ChatEventTypeOnlineUsersResponse = "online_users";
+var ChatEventTypeEndChat = "end_chat";
+var ChatEventTypeChatEnded = "chat_ended";
+var ChatEventTypeAgentSessionStart = "agent_session_start";
+var ChatEventTypeAgentSessionEnd = "agent_session_end";
+var ChatEventTypeAgentStatusChange = "agent_status_change";
+var ChatEventTypeAgentActivityPing = "agent_activity_ping";
+var ChatEventTypeAgentChatAssigned = "agent_chat_assigned";
+var ChatEventTypeAgentChatCompleted = "agent_chat_completed";
+var ChatEventTypeGetAgents = "get_agents";
+var ChatEventTypeGetAgentsResponse = "get_agents_response";
+var ChatEventTypeCSATRequest = "csat_request";
+var ChatEventTypeCSATSurvey = "show_csat_survey";
+var ChatEventTypeCSATResponse = "csat_response";
+var ChatEventTypeUserSuggestedActions = "user_suggested_actions";
+var ChatEventTypeUserSuggestedActionSelected = "user_suggested_action_selected";
+var ChatEventTypeSummaryUpdate = "summary_update";
+var ChatEventTypeAgentContextUpdate = "agent_context_update";
+var ChatEventTypeAgentExecutionStarted = "agent_execution_started";
+var ChatEventTypeAgentExecutionEnded = "agent_execution_ended";
+var ChatEventTypeLoadAgentContext = "load_agent_context";
+var ChatEventTypeLoadAgentContextResponse = "load_agent_context_response";
+var ChatEventTypePlanPendingApproval = "plan_pending_approval";
+var ChatEventTypePlanApproved = "plan_approved";
+var ChatEventTypePlanRejected = "plan_rejected";
+var ChatEventTypePlanCompleted = "plan_completed";
+var ChatEventTypeStepStarted = "step_started";
+var ChatEventTypeStepCompleted = "step_completed";
+var ChatEventTypeStepFailed = "step_failed";
+var ChatEventTypeNewChat = "new_chat";
+var ChatEventTypeNewChatCreated = "new_chat_created";
+var ChatEventTypePing = "ping";
+var ChatEventTypePong = "pong";
+var MessageStatusSending = "sending";
+var MessageStatusSent = "sent";
+var MessageStatusDelivered = "delivered";
+var MessageStatusRead = "read";
+var MessageStatusFailed = "failed";
+var AttachmentTypeDocument = "document";
+var AttachmentTypeDocumentAnalysis = "document_analysis";
+var AttachmentTypeImage = "image";
+var AttachmentTypeAudio = "audio";
+var AttachmentTypeVideo = "video";
+var AttachmentTypeLocation = "location";
+var AttachmentTypeReferences = "references";
+var AttachmentTypeSubsections = "subsections";
+var AttachmentTypeArticles = "articles";
+var AttachmentTypeRecords = "records";
+var AttachmentTypeActions = "actions";
+var AttachmentTypeBullets = "bullets";
+var AttachmentTypeSticker = "sticker";
+var AttachmentTypeData = "data";
+var AttachmentTypeKGNodes = "kgNodes";
+var AttachmentTypeDocumentSources = "document_sources";
+var ChatSessionStatusActive = "active";
+var ChatSessionStatusIdle = "idle";
+var ChatSessionStatusExpired = "expired";
+var UserStatusOnline = "online";
+var UserStatusAway = "away";
+var UserStatusBusy = "busy";
+var UserStatusOffline = "offline";
+var QueueTypes = {
+  skill: { value: "skill", label: "Skill-based", description: "Route by agent expertise and skills" },
+  priority: { value: "priority", label: "Priority-based", description: "Route by customer tier and urgency level" },
+  department: { value: "department", label: "Department-based", description: "Route by business function alignment" },
+  complexity: { value: "complexity", label: "Complexity-based", description: "Route by issue difficulty assessment" }
+};
+var QueueTypeSkill = "skill";
+var QueueTypePriority = "priority";
+var QueueTypeDepartment = "department";
+var QueueTypeComplexity = "complexity";
+var GetWaitingForAgentChatCountSubject = "chat.get_waiting_for_agent_chat_count";
+var GetActiveChatCountSubject = "chat.get_active_chat_count";
+var GetWaitingForAgentChatsSubject = "chat.get_waiting_for_agent_chats";
+var GetActiveChatsSubject = "chat.get_active_chats";
+var GetUserChatsSubject = "chat.get_user_chats";
+var GetChatSubject = "chat.get_chat";
+var ChatArchiveSubjectPattern = "chat.archive.%s.server";
+var StartAgentSessionSubject = "chat.agent_session.start";
+var EndAgentSessionSubject = "chat.agent_session.end";
+var UpdateAgentStatusSubject = "chat.agent_session.update_status";
+var UpdateAgentLastActivitySubject = "chat.agent_session.update_last_activity";
+var AssignChatToAgentSubject = "chat.agent_session.assign_chat";
+var CompleteChatByAgentSubject = "chat.agent_session.complete_chat";
+var GetAgentSessionSubject = "chat.agent_session.get";
+var GetOnlineAgentsSubject = "chat.agent_session.get_online_agents";
+var GetOnlineAgentCountSubject = "chat.agent_session.get_online_agent_count";
+var CreateAgentQueueSubject = "chat.agent_queue.create";
+var GetAgentQueuesSubject = "chat.agent_queue.get";
+var UpdateAgentQueueSubject = "chat.agent_queue.update";
+var DeleteAgentQueueSubject = "chat.agent_queue.delete";
+var GetQueueChatsSubject = "chat.queue.get_chats";
+var GetQueueChatCountSubject = "chat.queue.get_chat_count";
+var GetDailyChatCountSubject = "chat.get_daily_chat_count";
+var UpdateUserStatusSubject = "chat.user.status.update";
+var GetOnlineUsersSubject = "chat.users.online.get";
+var TriggerAnalyticsScanSubject = "chat.analytics.trigger-scan";
+var SetupOrgSubject = "chat.org.setup";
+
+// hooks/use-websocket-chat-base.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+var createDefaultLogger = (debug) => ({
+  debug: debug ? console.log : () => {
+  },
+  info: console.info,
+  warn: console.warn,
+  error: console.error
+});
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 10,
+  intervals: [1e3, 2e3, 5e3],
+  backoffMultiplier: 1.5,
+  maxBackoffTime: 3e4
+};
+var DEFAULT_QUEUE_CONFIG = {
+  maxSize: 100,
+  dropStrategy: "oldest"
+};
+var DEFAULT_HEARTBEAT_INTERVAL = 3e4;
+var DEFAULT_HEARTBEAT_TIMEOUT = 5e3;
+function isChatEvent(data) {
+  return data && typeof data === "object" && (typeof data.type === "string" || data.message);
+}
+var useWebSocketChatBase = ({
+  serverBaseUrl,
+  orgId,
+  clientType,
+  product,
+  onMessage,
+  retryConfig = DEFAULT_RETRY_CONFIG,
+  queueConfig = DEFAULT_QUEUE_CONFIG,
+  debug = false,
+  logger = createDefaultLogger(debug),
+  heartbeatInterval = DEFAULT_HEARTBEAT_INTERVAL,
+  heartbeatTimeout = DEFAULT_HEARTBEAT_TIMEOUT
+}) => {
+  const [connectionState, setConnectionState] = useState("disconnected");
+  const [error, setError] = useState(void 0);
+  const [startTime, setStartTime] = useState(void 0);
+  const [metrics, setMetrics] = useState({
+    latency: 0,
+    messagesSent: 0,
+    messagesReceived: 0,
+    messagesQueued: 0,
+    reconnectCount: 0
+  });
+  const wsRef = useRef(void 0);
+  const reconnectTimeoutRef = useRef(void 0);
+  const retryCountRef = useRef(0);
+  const messageQueueRef = useRef([]);
+  const mountedRef = useRef(false);
+  const currentChatKeyRef = useRef(void 0);
+  const currentUserIdRef = useRef(void 0);
+  const intentionalDisconnectRef = useRef(false);
+  const eventHandlersRef = useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const onMessageRef = useRef(onMessage);
+  const pendingMessagesRef = useRef(/* @__PURE__ */ new Map());
+  const heartbeatIntervalRef = useRef(void 0);
+  const heartbeatTimeoutRef = useRef(void 0);
+  const lastPongRef = useRef(Date.now());
+  const chatCreationPromiseRef = useRef(null);
+  const loadChatRetryMapRef = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    onMessageRef.current = onMessage;
+  }, [onMessage]);
+  const isConnected = connectionState === "connected";
+  const on = useCallback((eventType, handler) => {
+    if (!eventHandlersRef.current.has(eventType)) {
+      eventHandlersRef.current.set(eventType, /* @__PURE__ */ new Set());
+    }
+    eventHandlersRef.current.get(eventType).add(handler);
+    return () => off(eventType, handler);
+  }, []);
+  const off = useCallback((eventType, handler) => {
+    const handlers = eventHandlersRef.current.get(eventType);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        eventHandlersRef.current.delete(eventType);
+      }
+    }
+  }, []);
+  const emit = useCallback(
+    (eventType, data) => {
+      const handlers = eventHandlersRef.current.get(eventType);
+      if (handlers) {
+        handlers.forEach((handler) => {
+          try {
+            handler(data);
+          } catch (error2) {
+            logger.error(`Error in event handler for ${eventType}:`, error2);
+          }
+        });
+      }
+    },
+    [logger]
+  );
+  const updateMetrics = useCallback((updates) => {
+    setMetrics((prev) => ({ ...prev, ...updates }));
+  }, []);
+  const addToQueue = useCallback(
+    (event) => {
+      const currentQueueSize = messageQueueRef.current.length;
+      const maxSize = queueConfig.maxSize || DEFAULT_QUEUE_CONFIG.maxSize;
+      if (currentQueueSize >= maxSize) {
+        if (queueConfig.dropStrategy === "newest") {
+          logger.warn("Message queue full, dropping new message");
+          return false;
+        } else {
+          const dropped = messageQueueRef.current.shift();
+          logger.warn("Message queue full, dropped oldest message", dropped);
+        }
+      }
+      messageQueueRef.current.push(event);
+      updateMetrics({ messagesQueued: messageQueueRef.current.length });
+      return true;
+    },
+    [queueConfig, logger, updateMetrics]
+  );
+  const calculateRetryInterval = useCallback(
+    (retryCount) => {
+      const config = { ...DEFAULT_RETRY_CONFIG, ...retryConfig };
+      const {
+        intervals = [],
+        backoffMultiplier = 1.5,
+        maxBackoffTime = 3e4
+      } = config;
+      if (retryCount < intervals.length) {
+        return intervals[retryCount];
+      }
+      const baseInterval = intervals[intervals.length - 1] || 5e3;
+      const backoffTime = baseInterval * Math.pow(backoffMultiplier, retryCount - intervals.length + 1);
+      return Math.min(backoffTime, maxBackoffTime);
+    },
+    [retryConfig]
+  );
+  const startHeartbeat = useCallback(() => {
+    if (!heartbeatInterval || heartbeatInterval <= 0) return;
+    const sendPing = () => {
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        const pingTime = Date.now();
+        wsRef.current.send(
+          JSON.stringify({ type: "ping", timestamp: pingTime })
+        );
+        heartbeatTimeoutRef.current = setTimeout(() => {
+          logger.warn("Heartbeat timeout - no pong received");
+          if (wsRef.current) {
+            wsRef.current.close(4e3, "Heartbeat timeout");
+          }
+        }, heartbeatTimeout);
+      }
+    };
+    if (heartbeatIntervalRef.current) {
+      clearInterval(heartbeatIntervalRef.current);
+    }
+    heartbeatIntervalRef.current = setInterval(sendPing, heartbeatInterval);
+    logger.debug("Heartbeat started");
+  }, [heartbeatInterval, heartbeatTimeout, logger]);
+  const stopHeartbeat = useCallback(() => {
+    if (heartbeatIntervalRef.current) {
+      clearInterval(heartbeatIntervalRef.current);
+      heartbeatIntervalRef.current = void 0;
+    }
+    if (heartbeatTimeoutRef.current) {
+      clearTimeout(heartbeatTimeoutRef.current);
+      heartbeatTimeoutRef.current = void 0;
+    }
+    logger.debug("Heartbeat stopped");
+  }, [logger]);
+  const cleanup = useCallback(() => {
+    if (wsRef.current && wsRef.current.readyState === WebSocket.OPEN) {
+      wsRef.current.close(1e3, "Cleanup");
+    }
+    wsRef.current = void 0;
+    if (reconnectTimeoutRef.current) {
+      clearTimeout(reconnectTimeoutRef.current);
+      reconnectTimeoutRef.current = void 0;
+    }
+    stopHeartbeat();
+    pendingMessagesRef.current.forEach(({ reject, timeout }) => {
+      clearTimeout(timeout);
+      reject(new Error("Connection closed"));
+    });
+    pendingMessagesRef.current.clear();
+    loadChatRetryMapRef.current.forEach((retryState) => {
+      if (retryState.timeoutId) {
+        clearTimeout(retryState.timeoutId);
+      }
+    });
+    loadChatRetryMapRef.current.clear();
+  }, [stopHeartbeat]);
+  const connect = useCallback(
+    async (userId) => {
+      if (!mountedRef.current) {
+        mountedRef.current = true;
+      }
+      if (!orgId) {
+        const error2 = {
+          code: "CONNECTION_FAILED",
+          message: "Cannot connect: orgId is undefined",
+          retryable: false,
+          timestamp: Date.now()
+        };
+        logger.error("Cannot connect: orgId is undefined");
+        setError(error2);
+        return Promise.reject(error2);
+      }
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        logger.debug("Already connected");
+        return Promise.resolve();
+      }
+      if (connectionState === "connecting" || connectionState === "reconnecting") {
+        logger.debug("Connection already in progress");
+        return Promise.resolve();
+      }
+      const maxRetries = retryConfig.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries;
+      if (retryCountRef.current >= maxRetries && !intentionalDisconnectRef.current) {
+        const error2 = {
+          code: "CONNECTION_FAILED",
+          message: `Max retries (${maxRetries}) exceeded`,
+          retryable: false,
+          timestamp: Date.now()
+        };
+        setError(error2);
+        updateMetrics({ lastError: error2 });
+        return Promise.reject(error2);
+      }
+      cleanup();
+      setConnectionState(
+        retryCountRef.current > 0 ? "reconnecting" : "connecting"
+      );
+      intentionalDisconnectRef.current = false;
+      return new Promise((resolve, reject) => {
+        try {
+          const wsUrl = `${serverBaseUrl}?orgId=${orgId}&userId=${userId}&clientType=${clientType}&product=${product}`;
+          const connectionStartTime = Date.now();
+          logger.debug("Connecting to WebSocket:", wsUrl);
+          console.log(`\u23F3 Initiating WebSocket connection to ${serverBaseUrl}...`);
+          const ws = new WebSocket(wsUrl);
+          ws.onopen = () => {
+            if (!mountedRef.current) {
+              ws.close(1e3, "Component unmounted");
+              reject(new Error("Component unmounted"));
+              return;
+            }
+            const connectionTimeMs = Date.now() - connectionStartTime;
+            const connectionTimeSec = (connectionTimeMs / 1e3).toFixed(2);
+            logger.info("\u2705 WebSocket connected", {
+              userId,
+              retryCount: retryCountRef.current,
+              connectionTime: `${connectionTimeSec}s (${connectionTimeMs}ms)`
+            });
+            console.log(`\u{1F50C} WebSocket connection established in ${connectionTimeSec} seconds`);
+            setConnectionState("connected");
+            setError(void 0);
+            const wasReconnecting = retryCountRef.current > 0;
+            retryCountRef.current = 0;
+            updateMetrics({
+              connectedAt: Date.now(),
+              latency: connectionTimeMs,
+              reconnectCount: wasReconnecting ? metrics.reconnectCount + 1 : metrics.reconnectCount
+            });
+            while (messageQueueRef.current.length > 0 && ws.readyState === WebSocket.OPEN) {
+              const event = messageQueueRef.current.shift();
+              if (event) {
+                ws.send(JSON.stringify({ ...event, timestamp: Date.now() }));
+                updateMetrics({
+                  messagesSent: metrics.messagesSent + 1,
+                  messagesQueued: messageQueueRef.current.length
+                });
+              }
+            }
+            currentUserIdRef.current = userId;
+            if (currentChatKeyRef.current) {
+              if (!orgId) {
+                logger.error("Cannot resubscribe to chat: orgId is undefined");
+              } else {
+                logger.info(
+                  "Resubscribing to chat after reconnection:",
+                  currentChatKeyRef.current
+                );
+                const resubscribeEvent = {
+                  type: "load_chat",
+                  orgId,
+                  chatKey: currentChatKeyRef.current,
+                  userId,
+                  timestamp: Date.now(),
+                  data: {}
+                };
+                ws.send(JSON.stringify(resubscribeEvent));
+              }
+            }
+            startHeartbeat();
+            emit("connected", { userId, wasReconnecting });
+            resolve();
+          };
+          ws.onmessage = (event) => {
+            if (!mountedRef.current) return;
+            try {
+              const data = JSON.parse(event.data);
+              if (!isChatEvent(data)) {
+                logger.warn("Received invalid message format:", data);
+                return;
+              }
+              const chatEvent = data;
+              logger.debug("Message received:", chatEvent.type);
+              updateMetrics({
+                messagesReceived: metrics.messagesReceived + 1,
+                lastMessageAt: Date.now()
+              });
+              if (chatEvent.type === "pong") {
+                if (heartbeatTimeoutRef.current) {
+                  clearTimeout(heartbeatTimeoutRef.current);
+                  heartbeatTimeoutRef.current = void 0;
+                }
+                const latency = Date.now() - (chatEvent.timestamp || Date.now());
+                lastPongRef.current = Date.now();
+                updateMetrics({ latency });
+                return;
+              }
+              switch (chatEvent.type) {
+                case "new_chat_created":
+                  const newChatKey = chatEvent.data?.chatKey;
+                  if (newChatKey) {
+                    logger.info("New chat created with key:", newChatKey);
+                    currentChatKeyRef.current = newChatKey;
+                    if (chatCreationPromiseRef.current) {
+                      chatCreationPromiseRef.current.resolve(newChatKey);
+                      chatCreationPromiseRef.current = null;
+                    }
+                    if (!orgId) {
+                      logger.error("Cannot send load_chat: orgId is undefined");
+                      return;
+                    }
+                    const loadChatEvent = {
+                      type: "load_chat",
+                      orgId,
+                      chatKey: newChatKey,
+                      userId: currentUserIdRef.current || userId,
+                      timestamp: Date.now(),
+                      data: {}
+                    };
+                    ws.send(JSON.stringify(loadChatEvent));
+                  }
+                  break;
+                case "load_chat_response":
+                  const chat = chatEvent.data?.chat;
+                  if (chat && chat.key) {
+                    logger.info("Chat loaded with key:", chat.key);
+                    currentChatKeyRef.current = chat.key;
+                    const retryState = loadChatRetryMapRef.current.get(chat.key);
+                    if (retryState) {
+                      if (retryState.timeoutId) {
+                        clearTimeout(retryState.timeoutId);
+                      }
+                      loadChatRetryMapRef.current.delete(chat.key);
+                    }
+                  } else if (!chat) {
+                    logger.warn("Chat load failed, clearing key");
+                    currentChatKeyRef.current = void 0;
+                  }
+                  break;
+                case "chat_ended":
+                  logger.info("Chat ended, clearing key");
+                  currentChatKeyRef.current = void 0;
+                  break;
+                case "error":
+                  const errorMessage = chatEvent.data?.message || "Unknown error";
+                  logger.error("Received error from server:", errorMessage);
+                  if (errorMessage.includes("nats: key not found") || errorMessage.includes("Failed to load chat")) {
+                    const chatKeyFromError = currentChatKeyRef.current;
+                    if (chatKeyFromError) {
+                      const maxRetries2 = 5;
+                      let retryState = loadChatRetryMapRef.current.get(chatKeyFromError);
+                      if (!retryState) {
+                        retryState = { retryCount: 0, timeoutId: null };
+                        loadChatRetryMapRef.current.set(chatKeyFromError, retryState);
+                      }
+                      if (retryState.retryCount < maxRetries2) {
+                        const delay = 200 * Math.pow(2, retryState.retryCount);
+                        retryState.retryCount++;
+                        logger.info(
+                          `Chat load failed, retrying (${retryState.retryCount}/${maxRetries2}) in ${delay}ms...`,
+                          chatKeyFromError
+                        );
+                        retryState.timeoutId = setTimeout(() => {
+                          if (!wsRef.current || !mountedRef.current) return;
+                          if (!orgId) {
+                            logger.error("Cannot retry load_chat: orgId is undefined", chatKeyFromError);
+                            loadChatRetryMapRef.current.delete(chatKeyFromError);
+                            return;
+                          }
+                          logger.debug("Retrying load_chat:", chatKeyFromError);
+                          const retryLoadEvent = {
+                            type: "load_chat",
+                            orgId,
+                            chatKey: chatKeyFromError,
+                            userId: currentUserIdRef.current || "",
+                            timestamp: Date.now(),
+                            data: {}
+                          };
+                          ws.send(JSON.stringify(retryLoadEvent));
+                        }, delay);
+                      } else {
+                        logger.error("Max retries reached for loading chat:", chatKeyFromError);
+                        loadChatRetryMapRef.current.delete(chatKeyFromError);
+                      }
+                    }
+                  }
+                  const wsError = {
+                    code: "NETWORK_ERROR",
+                    message: errorMessage,
+                    retryable: true,
+                    timestamp: Date.now()
+                  };
+                  setError(wsError);
+                  updateMetrics({ lastError: wsError });
+                  break;
+              }
+              emit(chatEvent.type || "message", chatEvent);
+              if (onMessageRef.current) {
+                onMessageRef.current(chatEvent);
+              }
+            } catch (error2) {
+              logger.error("Failed to parse WebSocket message:", error2);
+              const parseError = {
+                code: "PARSE_ERROR",
+                message: "Failed to parse message",
+                retryable: false,
+                timestamp: Date.now()
+              };
+              setError(parseError);
+              updateMetrics({ lastError: parseError });
+            }
+          };
+          ws.onclose = (event) => {
+            if (!mountedRef.current) return;
+            logger.info("WebSocket closed", {
+              code: event.code,
+              reason: event.reason
+            });
+            setConnectionState("disconnected");
+            wsRef.current = void 0;
+            stopHeartbeat();
+            emit("disconnected", { code: event.code, reason: event.reason });
+            if (event.code !== 1e3 && !intentionalDisconnectRef.current && mountedRef.current) {
+              const retryInterval = calculateRetryInterval(
+                retryCountRef.current
+              );
+              retryCountRef.current++;
+              logger.info(
+                `Reconnecting in ${retryInterval}ms (attempt ${retryCountRef.current})`
+              );
+              if (reconnectTimeoutRef.current) {
+                clearTimeout(reconnectTimeoutRef.current);
+              }
+              reconnectTimeoutRef.current = setTimeout(() => {
+                connect(userId);
+              }, retryInterval);
+            }
+          };
+          ws.onerror = (error2) => {
+            logger.error("WebSocket error:", error2);
+            if (!mountedRef.current) return;
+            const wsError = {
+              code: "CONNECTION_FAILED",
+              message: "WebSocket connection failed",
+              retryable: true,
+              timestamp: Date.now()
+            };
+            setError(wsError);
+            updateMetrics({ lastError: wsError });
+            reject(wsError);
+          };
+          wsRef.current = ws;
+        } catch (error2) {
+          logger.error("Failed to create WebSocket:", error2);
+          const wsError = {
+            code: "CONNECTION_FAILED",
+            message: error2 instanceof Error ? error2.message : "Failed to create connection",
+            retryable: true,
+            timestamp: Date.now()
+          };
+          setError(wsError);
+          updateMetrics({ lastError: wsError });
+          reject(wsError);
+        }
+      });
+    },
+    [
+      serverBaseUrl,
+      orgId,
+      clientType,
+      product,
+      connectionState,
+      logger,
+      retryConfig,
+      metrics,
+      updateMetrics,
+      cleanup,
+      calculateRetryInterval,
+      startHeartbeat,
+      emit
+    ]
+  );
+  const sendMessage = useCallback(
+    (event, overrideUserId) => {
+      return new Promise((resolve, reject) => {
+        if (!mountedRef.current) {
+          reject(new Error("Component not mounted"));
+          return;
+        }
+        const fullEvent = {
+          ...event,
+          timestamp: Date.now()
+        };
+        const messageId = `${fullEvent.type}_${fullEvent.timestamp}_${Math.random()}`;
+        logger.debug("Sending message:", fullEvent.type);
+        if (!wsRef.current || wsRef.current.readyState !== WebSocket.OPEN) {
+          if (addToQueue(fullEvent)) {
+            logger.debug("Message queued, attempting to connect");
+            if (connectionState === "disconnected" && overrideUserId) {
+              connect(overrideUserId).then(() => resolve()).catch(reject);
+            } else {
+              resolve();
+            }
+          } else {
+            reject(new Error("Message queue full"));
+          }
+          return;
+        }
+        try {
+          wsRef.current.send(JSON.stringify(fullEvent));
+          updateMetrics({ messagesSent: metrics.messagesSent + 1 });
+          logger.debug("Message sent successfully");
+          resolve();
+        } catch (error2) {
+          logger.error("Failed to send message:", error2);
+          if (addToQueue(fullEvent)) {
+            resolve();
+          } else {
+            const sendError = {
+              code: "SEND_FAILED",
+              message: error2 instanceof Error ? error2.message : "Failed to send message",
+              retryable: true,
+              timestamp: Date.now()
+            };
+            setError(sendError);
+            updateMetrics({ lastError: sendError });
+            reject(sendError);
+          }
+        }
+      });
+    },
+    [connectionState, connect, addToQueue, logger, metrics, updateMetrics]
+  );
+  const startNewChat = useCallback(
+    (userId, data) => {
+      return new Promise((resolve, reject) => {
+        if (!userId) {
+          reject(new Error("User ID is required"));
+          return;
+        }
+        logger.info("Requesting new chat from server with userId:", userId);
+        setStartTime(/* @__PURE__ */ new Date());
+        chatCreationPromiseRef.current = { resolve, reject };
+        sendMessage(
+          {
+            type: "new_chat",
+            orgId,
+            chatKey: "",
+            // Server will generate
+            userId,
+            data: data ?? {}
+          },
+          userId
+        ).catch((error2) => {
+          chatCreationPromiseRef.current = null;
+          reject(error2);
+        });
+        setTimeout(() => {
+          if (chatCreationPromiseRef.current) {
+            chatCreationPromiseRef.current = null;
+            reject(new Error("Chat creation timed out"));
+          }
+        }, 3e4);
+      });
+    },
+    [sendMessage, orgId, logger]
+  );
+  const disconnect = useCallback(
+    (intentional = true) => {
+      logger.info("Disconnecting WebSocket", { intentional });
+      intentionalDisconnectRef.current = intentional;
+      cleanup();
+      setConnectionState("disconnected");
+      messageQueueRef.current = [];
+      retryCountRef.current = 0;
+      mountedRef.current = false;
+      currentChatKeyRef.current = void 0;
+      currentUserIdRef.current = void 0;
+    },
+    [cleanup, logger]
+  );
+  const clearError = useCallback(() => {
+    setError(void 0);
+  }, []);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      disconnect(true);
+    };
+  }, []);
+  return {
+    connectionState,
+    isConnected,
+    sendMessage,
+    error,
+    connect,
+    startNewChat,
+    startTime,
+    disconnect,
+    metrics,
+    on,
+    off,
+    clearError
+  };
+};
+
+// hooks/use-websocket-chat-admin.ts
+var useWebSocketChatAdmin = ({
+  serverBaseUrl,
+  orgId,
+  product
+}) => {
+  const [chats, setChats] = useState2(/* @__PURE__ */ new Map());
+  const [selectedChat, setSelectedChat] = useState2(void 0);
+  const handleMessage = useCallback2(
+    (chatEvent) => {
+      switch (chatEvent.type) {
+        case "message":
+          if (!selectedChat || !chatEvent.message) return;
+          setChats((prev) => {
+            const newMap = new Map(prev);
+            newMap.set(selectedChat.key, {
+              ...selectedChat,
+              messages: [...selectedChat.messages, chatEvent.message]
+            });
+            return newMap;
+          });
+          setSelectedChat((prev) => {
+            if (!prev) return prev;
+            return {
+              ...prev,
+              messages: [...prev.messages, chatEvent.message]
+            };
+          });
+          break;
+        case "list_chats":
+          const chatList = chatEvent.data?.chats;
+          if (!chatList) return;
+          setChats(new Map(chatList.map((chat) => [chat.key, chat])));
+          break;
+        case "chat_updated":
+          const updatedChat = chatEvent.data?.chat?.value;
+          if (updatedChat) {
+            setChats((prev) => new Map(prev).set(updatedChat.key, updatedChat));
+          }
+          break;
+        case "chat_removed":
+          const chatKey = chatEvent.data?.chatKey?.value;
+          if (chatKey) {
+            setChats((prev) => {
+              const newMap = new Map(prev);
+              newMap.delete(chatKey);
+              return newMap;
+            });
+          }
+          break;
+        case "load_chat":
+          const history = chatEvent.data?.chat?.value;
+          if (history) {
+            setChats((prev) => {
+              const existingChat = prev.get(history.key);
+              if (!existingChat) return prev;
+              return new Map(prev).set(history.key, {
+                ...existingChat,
+                messages: history.messages
+              });
+            });
+          }
+          break;
+      }
+    },
+    [selectedChat]
+  );
+  const base = useWebSocketChatBase({
+    serverBaseUrl,
+    orgId,
+    clientType: "humanAgent",
+    onMessage: handleMessage,
+    product
+  });
+  const selectChat = useCallback2(
+    (chatKey) => {
+      const chat = chats.get(chatKey);
+      if (!chat) {
+        console.error("Unable to select chat", chatKey);
+        return;
+      }
+      setSelectedChat(chat);
+    },
+    [chats, orgId, base.sendMessage]
+  );
+  const addUserToChat = useCallback2(
+    (orgId2, chatKey, user) => {
+      base.sendMessage({
+        type: "human_agent_joined",
+        orgId: orgId2,
+        chatKey,
+        userId: user.email,
+        data: { user }
+      });
+      setChats((prev) => {
+        const newMap = new Map(prev);
+        const chat = newMap.get(chatKey);
+        if (!chat) return prev;
+        newMap.set(chatKey, {
+          ...chat,
+          humanAgentEngaged: user.role === ChatRoleHumanAgent,
+          users: [...chat?.users ?? [], user]
+        });
+        return newMap;
+      });
+      setSelectedChat((prev) => {
+        if (!prev) return prev;
+        return {
+          ...prev,
+          humanAgentEngaged: user.role === ChatRoleHumanAgent,
+          users: [...prev.users ?? [], user]
+        };
+      });
+    },
+    [base.sendMessage]
+  );
+  const removeUserFromChat = useCallback2(
+    (orgId2, chatKey, userId) => {
+      const chat = chats.get(chatKey);
+      if (!chat) return;
+      const user = chat.users?.find((u) => u.id === userId);
+      if (!user) return;
+      base.sendMessage({
+        type: "human_agent_left",
+        orgId: orgId2,
+        chatKey,
+        userId,
+        data: { user }
+      });
+      setChats((prev) => {
+        const newMap = new Map(prev);
+        const chat2 = newMap.get(chatKey);
+        if (!chat2) return prev;
+        newMap.set(chatKey, {
+          ...chat2,
+          humanAgentEngaged: false,
+          users: chat2.users?.filter((u) => u.id !== userId)
+        });
+        return newMap;
+      });
+    },
+    [chats, base.sendMessage]
+  );
+  const blockUser = useCallback2(
+    (orgId2, chatKey, userId) => {
+      base.sendMessage({
+        type: "block_user",
+        orgId: orgId2,
+        chatKey,
+        userId
+      });
+    },
+    [base.sendMessage]
+  );
+  return {
+    ...base,
+    chats,
+    selectedChat,
+    selectChat,
+    addUserToChat,
+    removeUserFromChat,
+    blockUser
+  };
+};
+
+// hooks/use-websocket-chat-customer.ts
+import { useCallback as useCallback3, useState as useState3 } from "react";
+var useWebSocketChatCustomer = ({
+  serverBaseUrl,
+  orgId,
+  chatKey,
+  product
+}) => {
+  const [currentChat, setCurrentChat] = useState3(void 0);
+  const handleMessage = useCallback3((chatEvent) => {
+    console.log("Received event:", chatEvent.type);
+    switch (chatEvent.type) {
+      case "message":
+        if (!chatEvent.message) return;
+        console.log(
+          "got message:",
+          chatEvent.message.role,
+          ":",
+          chatEvent.message.content
+        );
+        setCurrentChat((prev) => {
+          if (!prev) return prev;
+          return {
+            ...prev,
+            messages: [...prev.messages, chatEvent.message]
+          };
+        });
+        break;
+      case "chat_updated":
+        const chat = chatEvent.data?.chat?.value;
+        if (chat) {
+          setCurrentChat(chat);
+        }
+        break;
+      case "load_chat":
+        const history = chatEvent.data?.chat;
+        if (!history) return;
+        setCurrentChat(history);
+        break;
+      default:
+        break;
+    }
+  }, []);
+  const base = useWebSocketChatBase({
+    serverBaseUrl,
+    orgId,
+    clientType: "customer",
+    onMessage: handleMessage,
+    product
+  });
+  return {
+    ...base,
+    chatKey,
+    title: currentChat?.title,
+    messages: currentChat?.messages ?? [],
+    users: currentChat?.users ?? [],
+    isWaiting: currentChat?.isWaiting ?? false,
+    isWaitingForAgent: currentChat?.isWaitingForAgent ?? false,
+    aiEngaged: currentChat?.aiEngaged ?? false,
+    humanAgentEngaged: currentChat?.humanAgentEngaged ?? false,
+    metadata: currentChat?.metadata ?? {},
+    status: currentChat?.status
+  };
+};
+
+// context/websocket-chat-admin-context.tsx
 import { jsx } from "react/jsx-runtime";
 var WebSocketChatAdminContext = createContext(void 0);
 function WebSocketChatAdminProvider(props) {
@@ -416,10 +1283,10 @@ var AdminChatInput = ({
 }) => {
   const { sendMessage } = useWebSocketChatAdminContext();
   const { user, selectedOrgId } = useUserContext();
-  const [input, setInput] = useState("");
-  const [isUploading, setIsUploading] = useState(false);
-  const [isSending, setIsSending] = useState(false);
-  const fileInputRef = useRef(null);
+  const [input, setInput] = useState4("");
+  const [isUploading, setIsUploading] = useState4(false);
+  const [isSending, setIsSending] = useState4(false);
+  const fileInputRef = useRef2(null);
   const MAX_FILE_SIZE = 5 * 1024 * 1024;
   const handleSend = async () => {
     if (!input.trim() && !isUploading || isSending) return;
@@ -799,15 +1666,15 @@ var ChatHeader = () => {
 // components/customer/chat-input.tsx
 import { useUserContext as useUserContext3 } from "@elqnt/auth";
 import KSUID2 from "ksuid";
-import { useRef as useRef2, useState as useState2 } from "react";
+import { useRef as useRef3, useState as useState5 } from "react";
 import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 var ChatInput = ({ onFileUpload }) => {
   const { sendMessage, chatKey } = useWebSocketChatCustomerContext();
   const { user, selectedOrgId } = useUserContext3();
-  const [input, setInput] = useState2("");
-  const [isUploading, setIsUploading] = useState2(false);
-  const [isSending, setIsSending] = useState2(false);
-  const fileInputRef = useRef2(null);
+  const [input, setInput] = useState5("");
+  const [isUploading, setIsUploading] = useState5(false);
+  const [isSending, setIsSending] = useState5(false);
+  const fileInputRef = useRef3(null);
   const MAX_FILE_SIZE = 5 * 1024 * 1024;
   const handleSend = async () => {
     if (!input.trim() && !isUploading || isSending) return;
@@ -932,7 +1799,7 @@ var ChatInput = ({ onFileUpload }) => {
 };
 
 // components/customer/chat-messages.tsx
-import { useEffect, useRef as useRef3 } from "react";
+import { useEffect as useEffect2, useRef as useRef4 } from "react";
 
 // ../../node_modules/date-fns/constants.js
 var daysInYear = 365.2425;
@@ -2629,11 +3496,11 @@ var ChatMessages = ({
   onRetry,
   messages
 }) => {
-  const messageEndRef = useRef3(null);
+  const messageEndRef = useRef4(null);
   const scrollToBottom = () => {
     messageEndRef.current?.scrollIntoView({ behavior: "smooth" });
   };
-  useEffect(() => {
+  useEffect2(() => {
     scrollToBottom();
   }, [messages]);
   return /* @__PURE__ */ jsxs9(
@@ -2677,12 +3544,12 @@ var ChatTypingIndicator = ({
 
 // components/customer/generic-chat-widget.tsx
 import { Alert } from "@elqnt/react";
-import { useState as useState3 } from "react";
+import { useState as useState6 } from "react";
 import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
 var GenericChatWidget = ({
   onFileUpload
 }) => {
-  const [typingUsers] = useState3(/* @__PURE__ */ new Set());
+  const [typingUsers] = useState6(/* @__PURE__ */ new Set());
   const { error, messages } = useWebSocketChatCustomerContext();
   const handleRetry = (messageId) => {
   };