@elqnt/chat 2.0.8 → 3.0.1

package/dist/hooks/index.js

@@ -0,0 +1,741 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  useChat: () => useChat
+});
+module.exports = __toCommonJS(hooks_exports);
+
+// hooks/use-chat.ts
+var import_react = require("react");
+
+// transport/types.ts
+function createLogger(debug = false) {
+  return {
+    debug: debug ? console.log.bind(console, "[chat]") : () => {
+    },
+    info: console.info.bind(console, "[chat]"),
+    warn: console.warn.bind(console, "[chat]"),
+    error: console.error.bind(console, "[chat]")
+  };
+}
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 10,
+  intervals: [1e3, 2e3, 5e3],
+  backoffMultiplier: 1.5,
+  maxBackoffTime: 3e4
+};
+function calculateRetryInterval(retryCount, config = DEFAULT_RETRY_CONFIG) {
+  const {
+    intervals = DEFAULT_RETRY_CONFIG.intervals,
+    backoffMultiplier = DEFAULT_RETRY_CONFIG.backoffMultiplier,
+    maxBackoffTime = DEFAULT_RETRY_CONFIG.maxBackoffTime
+  } = 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);
+}
+
+// transport/sse.ts
+function createSSETransport(options = {}) {
+  const {
+    retryConfig = DEFAULT_RETRY_CONFIG,
+    debug = false,
+    logger = createLogger(debug)
+  } = options;
+  let eventSource;
+  let config;
+  let state = "disconnected";
+  let error;
+  let retryCount = 0;
+  let reconnectTimeout;
+  let intentionalDisconnect = false;
+  const metrics = {
+    latency: 0,
+    messagesSent: 0,
+    messagesReceived: 0,
+    messagesQueued: 0,
+    reconnectCount: 0,
+    transportType: "sse"
+  };
+  const globalHandlers = /* @__PURE__ */ new Set();
+  const typeHandlers = /* @__PURE__ */ new Map();
+  function emit(event) {
+    metrics.messagesReceived++;
+    metrics.lastMessageAt = Date.now();
+    globalHandlers.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (err) {
+        logger.error("Error in message handler:", err);
+      }
+    });
+    const handlers = typeHandlers.get(event.type);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (err) {
+          logger.error(`Error in ${event.type} handler:`, err);
+        }
+      });
+    }
+  }
+  async function sendRest(endpoint, body) {
+    if (!config) {
+      throw new Error("Transport not connected");
+    }
+    const url = `${config.baseUrl}/${endpoint}`;
+    logger.debug(`POST ${endpoint}`, body);
+    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(`API error: ${response.status} - ${errorText}`);
+    }
+    const json = await response.json();
+    if (json && typeof json === "object" && "data" in json) {
+      return json.data;
+    }
+    return json;
+  }
+  function handleMessage(event) {
+    if (!event.data || event.data === "") return;
+    try {
+      const data = JSON.parse(event.data);
+      logger.debug("Received:", data.type);
+      emit(data);
+    } catch (err) {
+      logger.error("Failed to parse SSE message:", err);
+    }
+  }
+  function setupEventListeners(es) {
+    es.addEventListener("message", handleMessage);
+    const eventTypes = [
+      "reconnected",
+      "typing",
+      "stopped_typing",
+      "waiting",
+      "waiting_for_agent",
+      "human_agent_joined",
+      "human_agent_left",
+      "chat_ended",
+      "chat_updated",
+      "load_chat_response",
+      "new_chat_created",
+      "show_csat_survey",
+      "csat_response",
+      "user_suggested_actions",
+      "agent_execution_started",
+      "agent_execution_ended",
+      "agent_context_update",
+      "plan_pending_approval",
+      "step_started",
+      "step_completed",
+      "step_failed",
+      "plan_completed",
+      "skills_changed",
+      "summary_update"
+    ];
+    eventTypes.forEach((type) => {
+      es.addEventListener(type, handleMessage);
+    });
+  }
+  function scheduleReconnect() {
+    if (intentionalDisconnect || !config) return;
+    const maxRetries = retryConfig.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries;
+    if (retryCount >= maxRetries) {
+      logger.error(`Max retries (${maxRetries}) exceeded`);
+      error = {
+        code: "CONNECTION_FAILED",
+        message: `Max retries (${maxRetries}) exceeded`,
+        retryable: false,
+        timestamp: Date.now()
+      };
+      return;
+    }
+    const interval = calculateRetryInterval(retryCount, retryConfig);
+    retryCount++;
+    metrics.reconnectCount++;
+    logger.info(`Reconnecting in ${interval}ms (attempt ${retryCount})`);
+    state = "reconnecting";
+    reconnectTimeout = setTimeout(() => {
+      if (config) {
+        transport.connect(config).catch((err) => {
+          logger.error("Reconnect failed:", err);
+        });
+      }
+    }, interval);
+  }
+  const transport = {
+    async connect(cfg) {
+      config = cfg;
+      intentionalDisconnect = false;
+      if (eventSource) {
+        eventSource.close();
+        eventSource = void 0;
+      }
+      if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+        reconnectTimeout = void 0;
+      }
+      state = retryCount > 0 ? "reconnecting" : "connecting";
+      return new Promise((resolve, reject) => {
+        const connectionStart = Date.now();
+        const url = `${cfg.baseUrl}/stream?orgId=${cfg.orgId}&userId=${cfg.userId}&clientType=${cfg.clientType}${cfg.chatKey ? `&chatId=${cfg.chatKey}` : ""}`;
+        logger.debug("Connecting to:", url);
+        const es = new EventSource(url);
+        es.onopen = () => {
+          const connectionTime = Date.now() - connectionStart;
+          logger.info(`Connected in ${connectionTime}ms`);
+          state = "connected";
+          error = void 0;
+          retryCount = 0;
+          metrics.connectedAt = Date.now();
+          metrics.latency = connectionTime;
+          setupEventListeners(es);
+          resolve();
+        };
+        es.onerror = () => {
+          if (es.readyState === EventSource.CLOSED) {
+            const sseError = {
+              code: "CONNECTION_FAILED",
+              message: "SSE connection failed",
+              retryable: true,
+              timestamp: Date.now()
+            };
+            error = sseError;
+            metrics.lastError = sseError;
+            state = "disconnected";
+            if (!intentionalDisconnect) {
+              scheduleReconnect();
+            }
+            if (retryCount === 0) {
+              reject(sseError);
+            }
+          }
+        };
+        eventSource = es;
+      });
+    },
+    disconnect(intentional = true) {
+      logger.info("Disconnecting", { intentional });
+      intentionalDisconnect = intentional;
+      if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+        reconnectTimeout = void 0;
+      }
+      if (eventSource) {
+        eventSource.close();
+        eventSource = void 0;
+      }
+      state = "disconnected";
+      retryCount = 0;
+    },
+    async send(event) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      switch (event.type) {
+        case "message":
+          await sendRest("send", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            message: event.message
+          });
+          break;
+        case "typing":
+          await sendRest("typing", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            typing: true
+          });
+          break;
+        case "stopped_typing":
+          await sendRest("typing", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            typing: false
+          });
+          break;
+        case "load_chat":
+          await sendRest("load", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId
+          });
+          break;
+        case "new_chat":
+          await sendRest("create", {
+            orgId: event.orgId,
+            userId: event.userId,
+            metadata: event.data
+          });
+          break;
+        case "end_chat":
+          await sendRest("end", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            data: event.data
+          });
+          break;
+        default:
+          await sendRest("event", {
+            type: event.type,
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            data: event.data
+          });
+      }
+      metrics.messagesSent++;
+    },
+    async sendMessage(message) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      await sendRest("send", {
+        orgId: config.orgId,
+        chatKey: config.chatKey,
+        userId: config.userId,
+        message
+      });
+      metrics.messagesSent++;
+    },
+    async createChat(options2) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      const response = await sendRest("create", {
+        orgId: options2.orgId,
+        userId: options2.userId,
+        metadata: options2.metadata
+      });
+      if (!response?.chatKey) {
+        throw new Error("Failed to create chat: no chatKey returned");
+      }
+      return { chatKey: response.chatKey };
+    },
+    async loadChatData(options2) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      const response = await sendRest("load", {
+        orgId: options2.orgId,
+        chatKey: options2.chatKey,
+        userId: options2.userId
+      });
+      if (!response?.chat) {
+        throw new Error("Failed to load chat: no chat data returned");
+      }
+      return {
+        chat: response.chat,
+        agentId: response.agentId
+      };
+    },
+    onMessage(handler) {
+      globalHandlers.add(handler);
+      return () => globalHandlers.delete(handler);
+    },
+    on(eventType, handler) {
+      if (!typeHandlers.has(eventType)) {
+        typeHandlers.set(eventType, /* @__PURE__ */ new Set());
+      }
+      typeHandlers.get(eventType).add(handler);
+      return () => {
+        const handlers = typeHandlers.get(eventType);
+        if (handlers) {
+          handlers.delete(handler);
+          if (handlers.size === 0) {
+            typeHandlers.delete(eventType);
+          }
+        }
+      };
+    },
+    getState() {
+      return state;
+    },
+    getMetrics() {
+      return { ...metrics };
+    },
+    getError() {
+      return error;
+    },
+    clearError() {
+      error = void 0;
+    }
+  };
+  return transport;
+}
+
+// hooks/use-chat.ts
+function getDefaultTransport(type, debug) {
+  return createSSETransport({ debug });
+}
+function useChat(options) {
+  const {
+    baseUrl,
+    orgId,
+    userId,
+    clientType = "customer",
+    transport: transportOption,
+    onMessage,
+    onError,
+    onConnectionChange,
+    autoConnect = false,
+    retryConfig,
+    debug = false
+  } = options;
+  const [connectionState, setConnectionState] = (0, import_react.useState)("disconnected");
+  const [currentChat, setCurrentChat] = (0, import_react.useState)(null);
+  const [chatKey, setChatKey] = (0, import_react.useState)(null);
+  const [messages, setMessages] = (0, import_react.useState)([]);
+  const [error, setError] = (0, import_react.useState)(null);
+  const [metrics, setMetrics] = (0, import_react.useState)({
+    latency: 0,
+    messagesSent: 0,
+    messagesReceived: 0,
+    messagesQueued: 0,
+    reconnectCount: 0
+  });
+  const transportRef = (0, import_react.useRef)(null);
+  const mountedRef = (0, import_react.useRef)(false);
+  const onMessageRef = (0, import_react.useRef)(onMessage);
+  const onErrorRef = (0, import_react.useRef)(onError);
+  const typingTimeoutRef = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    onMessageRef.current = onMessage;
+    onErrorRef.current = onError;
+  }, [onMessage, onError]);
+  (0, import_react.useEffect)(() => {
+    if (typeof transportOption === "object") {
+      transportRef.current = transportOption;
+    } else {
+      transportRef.current = getDefaultTransport(
+        transportOption,
+        debug
+      );
+    }
+  }, [transportOption, debug]);
+  const handleEvent = (0, import_react.useCallback)((event) => {
+    if (!mountedRef.current) return;
+    setMetrics((prev) => ({
+      ...prev,
+      messagesReceived: prev.messagesReceived + 1,
+      lastMessageAt: Date.now()
+    }));
+    switch (event.type) {
+      case "new_chat_created":
+        const newChatKey = event.data?.chatKey;
+        if (newChatKey) {
+          setChatKey(newChatKey);
+        }
+        break;
+      case "load_chat_response":
+        const chat = event.data?.chat;
+        if (chat) {
+          setCurrentChat(chat);
+          setChatKey(chat.key);
+          setMessages(chat.messages || []);
+        }
+        break;
+      case "message":
+        if (event.message) {
+          setMessages((prev) => [...prev, event.message]);
+        }
+        break;
+      case "chat_ended":
+        setCurrentChat(null);
+        setChatKey(null);
+        break;
+      case "error":
+        const errorMsg = event.data?.message;
+        if (errorMsg) {
+          const transportError = {
+            code: "NETWORK_ERROR",
+            message: errorMsg,
+            retryable: true,
+            timestamp: Date.now()
+          };
+          setError(transportError);
+          onErrorRef.current?.(transportError);
+        }
+        break;
+    }
+    onMessageRef.current?.(event);
+  }, []);
+  const connect = (0, import_react.useCallback)(async () => {
+    const transport = transportRef.current;
+    if (!transport) {
+      throw new Error("Transport not initialized");
+    }
+    if (!orgId) {
+      const err = {
+        code: "CONNECTION_FAILED",
+        message: "orgId is required",
+        retryable: false,
+        timestamp: Date.now()
+      };
+      setError(err);
+      throw err;
+    }
+    setConnectionState("connecting");
+    try {
+      const unsubscribe = transport.onMessage(handleEvent);
+      await transport.connect({
+        baseUrl,
+        orgId,
+        userId,
+        clientType,
+        chatKey: chatKey || void 0,
+        debug
+      });
+      setConnectionState("connected");
+      setError(null);
+      setMetrics(transport.getMetrics());
+      onConnectionChange?.("connected");
+      return;
+    } catch (err) {
+      const transportError = err;
+      setConnectionState("disconnected");
+      setError(transportError);
+      onErrorRef.current?.(transportError);
+      throw err;
+    }
+  }, [baseUrl, orgId, userId, clientType, chatKey, debug, handleEvent, onConnectionChange]);
+  const disconnect = (0, import_react.useCallback)(() => {
+    const transport = transportRef.current;
+    if (transport) {
+      transport.disconnect(true);
+    }
+    setConnectionState("disconnected");
+    onConnectionChange?.("disconnected");
+  }, [onConnectionChange]);
+  const startChat = (0, import_react.useCallback)(
+    async (metadata) => {
+      const transport = transportRef.current;
+      if (!transport) {
+        throw new Error("Transport not initialized");
+      }
+      const response = await transport.createChat({
+        orgId,
+        userId,
+        metadata
+      });
+      setChatKey(response.chatKey);
+      return response.chatKey;
+    },
+    [orgId, userId]
+  );
+  const loadChat = (0, import_react.useCallback)(
+    async (key) => {
+      const transport = transportRef.current;
+      if (!transport) {
+        throw new Error("Transport not initialized");
+      }
+      const response = await transport.loadChatData({
+        orgId,
+        chatKey: key,
+        userId
+      });
+      setCurrentChat(response.chat);
+      setChatKey(response.chat.key);
+      setMessages(response.chat.messages || []);
+      return response.chat;
+    },
+    [orgId, userId]
+  );
+  const sendMessage = (0, import_react.useCallback)(
+    async (content, attachments) => {
+      const transport = transportRef.current;
+      if (!transport) {
+        throw new Error("Transport not initialized");
+      }
+      if (!chatKey) {
+        throw new Error("No active chat");
+      }
+      const message = {
+        id: `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+        role: "user",
+        content,
+        time: Date.now(),
+        status: "sending",
+        senderId: userId,
+        createdAt: Date.now(),
+        attachments
+      };
+      setMessages((prev) => [...prev, message]);
+      await transport.send({
+        type: "message",
+        orgId,
+        chatKey,
+        userId,
+        timestamp: Date.now(),
+        message
+      });
+      setMetrics((prev) => ({
+        ...prev,
+        messagesSent: prev.messagesSent + 1
+      }));
+    },
+    [orgId, chatKey, userId]
+  );
+  const endChat = (0, import_react.useCallback)(
+    async (reason) => {
+      const transport = transportRef.current;
+      if (!transport) {
+        throw new Error("Transport not initialized");
+      }
+      if (!chatKey) {
+        return;
+      }
+      await transport.send({
+        type: "end_chat",
+        orgId,
+        chatKey,
+        userId,
+        timestamp: Date.now(),
+        data: reason ? { reason } : void 0
+      });
+      setCurrentChat(null);
+      setChatKey(null);
+    },
+    [orgId, chatKey, userId]
+  );
+  const sendEvent = (0, import_react.useCallback)(
+    async (event) => {
+      const transport = transportRef.current;
+      if (!transport) {
+        throw new Error("Transport not initialized");
+      }
+      await transport.send({
+        ...event,
+        timestamp: Date.now()
+      });
+    },
+    []
+  );
+  const startTyping = (0, import_react.useCallback)(() => {
+    const transport = transportRef.current;
+    if (!transport || !chatKey) return;
+    if (typingTimeoutRef.current) {
+      clearTimeout(typingTimeoutRef.current);
+    }
+    transport.send({
+      type: "typing",
+      orgId,
+      chatKey,
+      userId,
+      timestamp: Date.now()
+    }).catch(() => {
+    });
+    typingTimeoutRef.current = setTimeout(() => {
+      stopTyping();
+    }, 3e3);
+  }, [orgId, chatKey, userId]);
+  const stopTyping = (0, import_react.useCallback)(() => {
+    const transport = transportRef.current;
+    if (!transport || !chatKey) return;
+    if (typingTimeoutRef.current) {
+      clearTimeout(typingTimeoutRef.current);
+      typingTimeoutRef.current = null;
+    }
+    transport.send({
+      type: "stopped_typing",
+      orgId,
+      chatKey,
+      userId,
+      timestamp: Date.now()
+    }).catch(() => {
+    });
+  }, [orgId, chatKey, userId]);
+  const on = (0, import_react.useCallback)(
+    (eventType, handler) => {
+      const transport = transportRef.current;
+      if (!transport) {
+        return () => {
+        };
+      }
+      return transport.on(eventType, handler);
+    },
+    []
+  );
+  const clearError = (0, import_react.useCallback)(() => {
+    setError(null);
+    transportRef.current?.clearError();
+  }, []);
+  (0, import_react.useEffect)(() => {
+    mountedRef.current = true;
+    if (autoConnect) {
+      connect().catch(() => {
+      });
+    }
+    return () => {
+      mountedRef.current = false;
+      if (typingTimeoutRef.current) {
+        clearTimeout(typingTimeoutRef.current);
+      }
+      disconnect();
+    };
+  }, []);
+  const isConnected = connectionState === "connected";
+  return {
+    // Connection
+    connect,
+    disconnect,
+    connectionState,
+    isConnected,
+    // Chat operations
+    startChat,
+    loadChat,
+    sendMessage,
+    sendEvent,
+    endChat,
+    // Typing
+    startTyping,
+    stopTyping,
+    // State
+    currentChat,
+    chatKey,
+    messages,
+    error,
+    metrics,
+    // Events
+    on,
+    clearError
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useChat
+});
+//# sourceMappingURL=index.js.map