@elqnt/chat 1.0.1 → 1.0.2

package/dist/index.mjs

@@ -1,3 +1,186 @@
+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";
+
 // components/admin/admin-chat-input.tsx
 import { useUserContext } from "@elqnt/auth";
 import KSUID from "ksuid";
@@ -200,1058 +383,10 @@ var __iconNode14 = [
 var User = createLucideIcon("User", __iconNode14);
 
 // components/admin/admin-chat-input.tsx
-import { useRef as useRef2, useState as useState4 } from "react";
+import { useRef, useState } 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) {
@@ -1281,10 +416,10 @@ var AdminChatInput = ({
 }) => {
   const { sendMessage } = useWebSocketChatAdminContext();
   const { user, selectedOrgId } = useUserContext();
-  const [input, setInput] = useState4("");
-  const [isUploading, setIsUploading] = useState4(false);
-  const [isSending, setIsSending] = useState4(false);
-  const fileInputRef = useRef2(null);
+  const [input, setInput] = useState("");
+  const [isUploading, setIsUploading] = useState(false);
+  const [isSending, setIsSending] = useState(false);
+  const fileInputRef = useRef(null);
   const MAX_FILE_SIZE = 5 * 1024 * 1024;
   const handleSend = async () => {
     if (!input.trim() && !isUploading || isSending) return;
@@ -1664,15 +799,15 @@ var ChatHeader = () => {
 // components/customer/chat-input.tsx
 import { useUserContext as useUserContext3 } from "@elqnt/auth";
 import KSUID2 from "ksuid";
-import { useRef as useRef3, useState as useState5 } from "react";
+import { useRef as useRef2, useState as useState2 } 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] = useState5("");
-  const [isUploading, setIsUploading] = useState5(false);
-  const [isSending, setIsSending] = useState5(false);
-  const fileInputRef = useRef3(null);
+  const [input, setInput] = useState2("");
+  const [isUploading, setIsUploading] = useState2(false);
+  const [isSending, setIsSending] = useState2(false);
+  const fileInputRef = useRef2(null);
   const MAX_FILE_SIZE = 5 * 1024 * 1024;
   const handleSend = async () => {
     if (!input.trim() && !isUploading || isSending) return;
@@ -1797,7 +932,7 @@ var ChatInput = ({ onFileUpload }) => {
 };
 
 // components/customer/chat-messages.tsx
-import { useEffect as useEffect2, useRef as useRef4 } from "react";
+import { useEffect, useRef as useRef3 } from "react";
 
 // ../../node_modules/date-fns/constants.js
 var daysInYear = 365.2425;
@@ -3494,11 +2629,11 @@ var ChatMessages = ({
   onRetry,
   messages
 }) => {
-  const messageEndRef = useRef4(null);
+  const messageEndRef = useRef3(null);
   const scrollToBottom = () => {
     messageEndRef.current?.scrollIntoView({ behavior: "smooth" });
   };
-  useEffect2(() => {
+  useEffect(() => {
     scrollToBottom();
   }, [messages]);
   return /* @__PURE__ */ jsxs9(
@@ -3542,12 +2677,12 @@ var ChatTypingIndicator = ({
 
 // components/customer/generic-chat-widget.tsx
 import { Alert } from "@elqnt/react";
-import { useState as useState6 } from "react";
+import { useState as useState3 } from "react";
 import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
 var GenericChatWidget = ({
   onFileUpload
 }) => {
-  const [typingUsers] = useState6(/* @__PURE__ */ new Set());
+  const [typingUsers] = useState3(/* @__PURE__ */ new Set());
   const { error, messages } = useWebSocketChatCustomerContext();
   const handleRetry = (messageId) => {
   };