@elqnt/chat 1.0.9 → 1.0.12

package/dist/hooks/use-websocket-chat-admin.js

@@ -51,6 +51,7 @@ var DEFAULT_QUEUE_CONFIG = {
 };
 var DEFAULT_HEARTBEAT_INTERVAL = 3e4;
 var DEFAULT_HEARTBEAT_TIMEOUT = 5e3;
+var DEFAULT_TRANSPORT = "websocket";
 function isChatEvent(data) {
   return data && typeof data === "object" && (typeof data.type === "string" || data.message);
 }
@@ -65,7 +66,8 @@ var useWebSocketChatBase = ({
   debug = false,
   logger = createDefaultLogger(debug),
   heartbeatInterval = DEFAULT_HEARTBEAT_INTERVAL,
-  heartbeatTimeout = DEFAULT_HEARTBEAT_TIMEOUT
+  heartbeatTimeout = DEFAULT_HEARTBEAT_TIMEOUT,
+  transport = DEFAULT_TRANSPORT
 }) => {
   const [connectionState, setConnectionState] = (0, import_react.useState)("disconnected");
   const [error, setError] = (0, import_react.useState)(void 0);
@@ -75,9 +77,15 @@ var useWebSocketChatBase = ({
     messagesSent: 0,
     messagesReceived: 0,
     messagesQueued: 0,
-    reconnectCount: 0
+    reconnectCount: 0,
+    transportType: transport
   });
   const wsRef = (0, import_react.useRef)(void 0);
+  const sseRef = (0, import_react.useRef)(void 0);
+  const transportRef = (0, import_react.useRef)(transport);
+  (0, import_react.useEffect)(() => {
+    transportRef.current = transport;
+  }, [transport]);
   const reconnectTimeoutRef = (0, import_react.useRef)(void 0);
   const retryCountRef = (0, import_react.useRef)(0);
   const messageQueueRef = (0, import_react.useRef)([]);
@@ -207,6 +215,10 @@ var useWebSocketChatBase = ({
       wsRef.current.close(1e3, "Cleanup");
     }
     wsRef.current = void 0;
+    if (sseRef.current) {
+      sseRef.current.close();
+      sseRef.current = void 0;
+    }
     if (reconnectTimeoutRef.current) {
       clearTimeout(reconnectTimeoutRef.current);
       reconnectTimeoutRef.current = void 0;
@@ -224,6 +236,35 @@ var useWebSocketChatBase = ({
     });
     loadChatRetryMapRef.current.clear();
   }, [stopHeartbeat]);
+  const getRestApiUrl = (0, import_react.useCallback)((endpoint) => {
+    const httpUrl = serverBaseUrl.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
+    return `${httpUrl}/${endpoint}`;
+  }, [serverBaseUrl]);
+  const sendRestMessage = (0, import_react.useCallback)(
+    async (endpoint, body) => {
+      const url = getRestApiUrl(endpoint);
+      logger.debug(`SSE REST API call: POST ${endpoint}`, body);
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`REST API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        return data;
+      } catch (error2) {
+        logger.error(`SSE REST API error for ${endpoint}:`, error2);
+        throw error2;
+      }
+    },
+    [getRestApiUrl, logger]
+  );
   const connect = (0, import_react.useCallback)(
     async (userId) => {
       if (!mountedRef.current) {
@@ -241,7 +282,11 @@ var useWebSocketChatBase = ({
         return Promise.reject(error2);
       }
       if (wsRef.current?.readyState === WebSocket.OPEN) {
-        logger.debug("Already connected");
+        logger.debug("Already connected (WebSocket)");
+        return Promise.resolve();
+      }
+      if (sseRef.current?.readyState === EventSource.OPEN) {
+        logger.debug("Already connected (SSE)");
         return Promise.resolve();
       }
       if (connectionState === "connecting" || connectionState === "reconnecting") {
@@ -267,8 +312,169 @@ var useWebSocketChatBase = ({
       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.info(`\u{1F504} Connecting with transport: ${transportRef.current}`);
+          if (transportRef.current === "sse") {
+            const sseUrl = getRestApiUrl(`stream?orgId=${orgId}&userId=${userId}&clientType=${clientType}&chatId=${currentChatKeyRef.current || ""}`);
+            logger.debug("Connecting to SSE:", sseUrl);
+            console.log(`\u23F3 Initiating SSE connection to ${sseUrl}...`);
+            const eventSource = new EventSource(sseUrl);
+            eventSource.onopen = () => {
+              if (!mountedRef.current) {
+                eventSource.close();
+                reject(new Error("Component unmounted"));
+                return;
+              }
+              const connectionTimeMs = Date.now() - connectionStartTime;
+              const connectionTimeSec = (connectionTimeMs / 1e3).toFixed(2);
+              logger.info("\u2705 SSE connected", {
+                userId,
+                retryCount: retryCountRef.current,
+                connectionTime: `${connectionTimeSec}s (${connectionTimeMs}ms)`
+              });
+              console.log(`\u{1F50C} SSE connection established in ${connectionTimeSec} seconds`);
+              setConnectionState("connected");
+              setError(void 0);
+              const wasReconnecting = retryCountRef.current > 0;
+              retryCountRef.current = 0;
+              updateMetrics({
+                connectedAt: Date.now(),
+                latency: connectionTimeMs,
+                transportType: "sse",
+                reconnectCount: wasReconnecting ? metrics.reconnectCount + 1 : metrics.reconnectCount
+              });
+              currentUserIdRef.current = userId;
+              if (currentChatKeyRef.current) {
+                logger.info("Loading chat after SSE reconnection:", currentChatKeyRef.current);
+                sendRestMessage("load", {
+                  orgId,
+                  chatKey: currentChatKeyRef.current,
+                  userId
+                }).then((response) => {
+                  if (response.success && response.data?.chat) {
+                    const chatEvent = {
+                      type: "load_chat_response",
+                      orgId,
+                      chatKey: currentChatKeyRef.current,
+                      userId,
+                      timestamp: Date.now(),
+                      data: response.data
+                    };
+                    emit("load_chat_response", chatEvent);
+                    if (onMessageRef.current) {
+                      onMessageRef.current(chatEvent);
+                    }
+                  }
+                }).catch((err) => {
+                  logger.error("Failed to load chat after SSE reconnection:", err);
+                });
+              }
+              emit("connected", { userId, wasReconnecting, transport: "sse" });
+              resolve();
+            };
+            const handleSSEMessage = (event) => {
+              if (!mountedRef.current) return;
+              try {
+                const data = JSON.parse(event.data);
+                if (!isChatEvent(data)) {
+                  logger.warn("Received invalid SSE message format:", data);
+                  return;
+                }
+                const chatEvent = data;
+                logger.debug("SSE message received:", chatEvent.type);
+                updateMetrics({
+                  messagesReceived: metrics.messagesReceived + 1,
+                  lastMessageAt: Date.now()
+                });
+                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;
+                      }
+                    }
+                    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;
+                    }
+                    break;
+                  case "chat_ended":
+                    logger.info("Chat ended, clearing key");
+                    currentChatKeyRef.current = void 0;
+                    break;
+                }
+                emit(chatEvent.type || "message", chatEvent);
+                if (onMessageRef.current) {
+                  onMessageRef.current(chatEvent);
+                }
+              } catch (error2) {
+                logger.error("Failed to parse SSE message:", error2);
+              }
+            };
+            eventSource.addEventListener("message", handleSSEMessage);
+            eventSource.addEventListener("reconnected", handleSSEMessage);
+            eventSource.addEventListener("typing", handleSSEMessage);
+            eventSource.addEventListener("stopped_typing", handleSSEMessage);
+            eventSource.addEventListener("waiting", handleSSEMessage);
+            eventSource.addEventListener("waiting_for_agent", handleSSEMessage);
+            eventSource.addEventListener("human_agent_joined", handleSSEMessage);
+            eventSource.addEventListener("human_agent_left", handleSSEMessage);
+            eventSource.addEventListener("chat_ended", handleSSEMessage);
+            eventSource.addEventListener("chat_updated", handleSSEMessage);
+            eventSource.addEventListener("load_chat_response", handleSSEMessage);
+            eventSource.addEventListener("new_chat_created", handleSSEMessage);
+            eventSource.addEventListener("error", handleSSEMessage);
+            eventSource.addEventListener("show_csat_survey", handleSSEMessage);
+            eventSource.addEventListener("csat_response", handleSSEMessage);
+            eventSource.addEventListener("user_suggested_actions", handleSSEMessage);
+            eventSource.addEventListener("agent_execution_started", handleSSEMessage);
+            eventSource.addEventListener("agent_execution_ended", handleSSEMessage);
+            eventSource.addEventListener("agent_context_update", handleSSEMessage);
+            eventSource.addEventListener("plan_pending_approval", handleSSEMessage);
+            eventSource.addEventListener("step_started", handleSSEMessage);
+            eventSource.addEventListener("step_completed", handleSSEMessage);
+            eventSource.addEventListener("step_failed", handleSSEMessage);
+            eventSource.addEventListener("plan_completed", handleSSEMessage);
+            eventSource.addEventListener("skills_changed", handleSSEMessage);
+            eventSource.addEventListener("summary_update", handleSSEMessage);
+            eventSource.onerror = (error2) => {
+              logger.error("SSE error:", error2);
+              if (!mountedRef.current) return;
+              if (eventSource.readyState === EventSource.CLOSED) {
+                const sseError = {
+                  code: "CONNECTION_FAILED",
+                  message: "SSE connection failed",
+                  retryable: true,
+                  timestamp: Date.now()
+                };
+                setError(sseError);
+                updateMetrics({ lastError: sseError });
+                setConnectionState("disconnected");
+                emit("disconnected", { reason: "SSE error" });
+                if (!intentionalDisconnectRef.current && mountedRef.current) {
+                  const retryInterval = calculateRetryInterval(retryCountRef.current);
+                  retryCountRef.current++;
+                  logger.info(`SSE reconnecting in ${retryInterval}ms (attempt ${retryCountRef.current})`);
+                  if (reconnectTimeoutRef.current) {
+                    clearTimeout(reconnectTimeoutRef.current);
+                  }
+                  reconnectTimeoutRef.current = setTimeout(() => {
+                    connect(userId);
+                  }, retryInterval);
+                }
+              }
+            };
+            sseRef.current = eventSource;
+            return;
+          }
+          const wsUrl = `${serverBaseUrl}?orgId=${orgId}&userId=${userId}&clientType=${clientType}&product=${product}`;
           logger.debug("Connecting to WebSocket:", wsUrl);
           console.log(`\u23F3 Initiating WebSocket connection to ${serverBaseUrl}...`);
           const ws = new WebSocket(wsUrl);
@@ -540,7 +746,7 @@ var useWebSocketChatBase = ({
   );
   const sendMessage = (0, import_react.useCallback)(
     (event, overrideUserId) => {
-      return new Promise((resolve, reject) => {
+      return new Promise(async (resolve, reject) => {
         if (!mountedRef.current) {
           reject(new Error("Component not mounted"));
           return;
@@ -549,8 +755,161 @@ var useWebSocketChatBase = ({
           ...event,
           timestamp: Date.now()
         };
-        const messageId = `${fullEvent.type}_${fullEvent.timestamp}_${Math.random()}`;
         logger.debug("Sending message:", fullEvent.type);
+        if (transportRef.current === "sse") {
+          if (!sseRef.current || sseRef.current.readyState !== EventSource.OPEN) {
+            logger.debug("SSE not connected, attempting to connect");
+            if (connectionState === "disconnected" && overrideUserId) {
+              try {
+                await connect(overrideUserId);
+              } catch (error2) {
+                reject(error2);
+                return;
+              }
+            } else {
+              reject(new Error("SSE not connected"));
+              return;
+            }
+          }
+          try {
+            switch (fullEvent.type) {
+              case "message":
+                await sendRestMessage("send", {
+                  orgId: fullEvent.orgId,
+                  chatKey: fullEvent.chatKey || currentChatKeyRef.current,
+                  userId: fullEvent.userId,
+                  message: fullEvent.message
+                });
+                break;
+              case "typing":
+                await sendRestMessage("typing", {
+                  orgId: fullEvent.orgId,
+                  chatKey: fullEvent.chatKey || currentChatKeyRef.current,
+                  userId: fullEvent.userId,
+                  typing: true
+                });
+                break;
+              case "stopped_typing":
+                await sendRestMessage("typing", {
+                  orgId: fullEvent.orgId,
+                  chatKey: fullEvent.chatKey || currentChatKeyRef.current,
+                  userId: fullEvent.userId,
+                  typing: false
+                });
+                break;
+              case "load_chat":
+                const loadResponse = await sendRestMessage("load", {
+                  orgId: fullEvent.orgId,
+                  chatKey: fullEvent.chatKey,
+                  userId: fullEvent.userId
+                });
+                if (loadResponse.success && loadResponse.data?.chat) {
+                  currentChatKeyRef.current = loadResponse.data.chat.key;
+                  const chatEvent = {
+                    type: "load_chat_response",
+                    orgId: fullEvent.orgId,
+                    chatKey: loadResponse.data.chat.key,
+                    userId: fullEvent.userId,
+                    timestamp: Date.now(),
+                    data: loadResponse.data
+                  };
+                  emit("load_chat_response", chatEvent);
+                  if (onMessageRef.current) {
+                    onMessageRef.current(chatEvent);
+                  }
+                }
+                break;
+              case "new_chat":
+                const createResponse = await sendRestMessage("create", {
+                  orgId: fullEvent.orgId,
+                  userId: fullEvent.userId,
+                  metadata: fullEvent.data
+                });
+                if (createResponse.success && createResponse.data?.chatKey) {
+                  currentChatKeyRef.current = createResponse.data.chatKey;
+                  const newChatEvent = {
+                    type: "new_chat_created",
+                    orgId: fullEvent.orgId,
+                    chatKey: createResponse.data.chatKey,
+                    userId: fullEvent.userId,
+                    timestamp: Date.now(),
+                    data: { chatKey: createResponse.data.chatKey }
+                  };
+                  emit("new_chat_created", newChatEvent);
+                  if (onMessageRef.current) {
+                    onMessageRef.current(newChatEvent);
+                  }
+                  if (chatCreationPromiseRef.current) {
+                    chatCreationPromiseRef.current.resolve(createResponse.data.chatKey);
+                    chatCreationPromiseRef.current = null;
+                  }
+                }
+                break;
+              case "end_chat":
+                await sendRestMessage("end", {
+                  orgId: fullEvent.orgId,
+                  chatKey: fullEvent.chatKey || currentChatKeyRef.current,
+                  userId: fullEvent.userId,
+                  data: fullEvent.data
+                });
+                break;
+              case "human_agent_join":
+                await sendRestMessage("agent-join", {
+                  orgId: fullEvent.orgId,
+                  chatKey: fullEvent.chatKey || currentChatKeyRef.current,
+                  user: fullEvent.data?.user
+                });
+                break;
+              case "human_agent_leave":
+                await sendRestMessage("agent-leave", {
+                  orgId: fullEvent.orgId,
+                  chatKey: fullEvent.chatKey || currentChatKeyRef.current,
+                  user: fullEvent.data?.user
+                });
+                break;
+              // Event types that use the generic /event endpoint
+              case "load_agent_context":
+              case "skill_activate":
+              case "skill_deactivate":
+              case "sync_metadata":
+              case "plan_approved":
+              case "plan_rejected":
+                await sendRestMessage("event", {
+                  type: fullEvent.type,
+                  orgId: fullEvent.orgId,
+                  chatKey: fullEvent.chatKey || currentChatKeyRef.current,
+                  userId: fullEvent.userId,
+                  data: fullEvent.data
+                });
+                break;
+              default:
+                logger.warn("Sending unrecognized event type via generic endpoint:", fullEvent.type);
+                await sendRestMessage("event", {
+                  type: fullEvent.type,
+                  orgId: fullEvent.orgId,
+                  chatKey: fullEvent.chatKey || currentChatKeyRef.current,
+                  userId: fullEvent.userId,
+                  data: fullEvent.data
+                });
+                break;
+            }
+            updateMetrics({ messagesSent: metrics.messagesSent + 1 });
+            logger.debug("SSE REST message sent successfully");
+            resolve();
+          } catch (error2) {
+            logger.error("Failed to send SSE REST message:", error2);
+            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);
+          }
+          return;
+        }
         if (!wsRef.current || wsRef.current.readyState !== WebSocket.OPEN) {
           if (addToQueue(fullEvent)) {
             logger.debug("Message queued, attempting to connect");
@@ -587,7 +946,7 @@ var useWebSocketChatBase = ({
         }
       });
     },
-    [connectionState, connect, addToQueue, logger, metrics, updateMetrics]
+    [connectionState, connect, addToQueue, logger, metrics, updateMetrics, sendRestMessage, emit]
   );
   const startNewChat = (0, import_react.useCallback)(
     (userId, data) => {
@@ -625,7 +984,7 @@ var useWebSocketChatBase = ({
   );
   const disconnect = (0, import_react.useCallback)(
     (intentional = true) => {
-      logger.info("Disconnecting WebSocket", { intentional });
+      logger.info("Disconnecting", { intentional, transport: transportRef.current });
       intentionalDisconnectRef.current = intentional;
       cleanup();
       setConnectionState("disconnected");