@elqnt/chat 3.3.0 → 3.5.0

package/dist/index.mjs

@@ -1,1475 +1,3 @@
-"use client";
-
-// hooks/use-chat.ts
-import { useCallback, useEffect, useRef, useState } from "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 = [
-      "error",
-      "reconnected",
-      "typing",
-      "stopped_typing",
-      "waiting",
-      "waiting_for_agent",
-      "human_agent_joined",
-      "human_agent_left",
-      "chat_ended",
-      "chat_updated",
-      "chat_removed",
-      "load_chat_response",
-      "new_chat_created",
-      "show_csat_survey",
-      "csat_response",
-      "user_suggested_actions",
-      "user_suggested_action_selected",
-      "agent_execution_started",
-      "agent_execution_ended",
-      "agent_context_update",
-      "load_agent_context_response",
-      "plan_pending_approval",
-      "plan_approved",
-      "plan_rejected",
-      "step_started",
-      "step_completed",
-      "step_failed",
-      "plan_completed",
-      "skills_changed",
-      "summary_update",
-      "message_status_update",
-      "delivered",
-      "read",
-      "sync_metadata_response",
-      "sync_user_session_response",
-      "client_action",
-      "client_action_callback",
-      "attachment_processing_started",
-      "attachment_processing_progress",
-      "attachment_processing_complete",
-      "attachment_processing_error",
-      "observer_joined",
-      "observer_left",
-      "block_user",
-      "message_edited",
-      "message_deleted",
-      "message_reaction",
-      "user_presence_changed",
-      "online_users",
-      "get_agents_response",
-      "room_created",
-      "room_updated",
-      "room_deleted",
-      "rooms_response",
-      "room_user_joined",
-      "room_user_left",
-      "user_invited"
-    ];
-    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 streamParams = new URLSearchParams({
-          orgId: cfg.orgId,
-          userId: cfg.userId,
-          clientType: cfg.clientType
-        });
-        if (cfg.chatKey) streamParams.set("chatId", cfg.chatKey);
-        const url = `${cfg.baseUrl}/stream?${streamParams.toString()}`;
-        logger.debug("Connecting to:", url);
-        const es = new EventSource(url);
-        es.onopen = () => {
-          const connectionTime = Date.now() - connectionStart;
-          logger.info(`Connected in ${connectionTime}ms`);
-          const wasReconnect = retryCount > 0;
-          state = "connected";
-          error = void 0;
-          retryCount = 0;
-          metrics.connectedAt = Date.now();
-          metrics.latency = connectionTime;
-          setupEventListeners(es);
-          if (wasReconnect) {
-            emit({
-              type: "transport_reconnected",
-              orgId: cfg.orgId,
-              chatKey: cfg.chatKey || "",
-              userId: cfg.userId,
-              timestamp: Date.now()
-            });
-          }
-          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,
-            ...event.data ? { data: event.data } : {}
-          });
-          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;
-}
-
-// transport/sse-fetch.ts
-function createFetchSSETransport(options = {}) {
-  const {
-    retryConfig = DEFAULT_RETRY_CONFIG,
-    debug = false,
-    logger = createLogger(debug),
-    customFetch = fetch
-  } = options;
-  let abortController;
-  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-fetch"
-  };
-  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 customFetch(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 parseSSEChunk(chunk) {
-    const events = [];
-    const lines = chunk.split("\n");
-    let eventType = "message";
-    let data = "";
-    for (const line of lines) {
-      if (line.startsWith("event:")) {
-        eventType = line.slice(6).trim();
-      } else if (line.startsWith("data:")) {
-        data = line.slice(5).trim();
-      } else if (line === "" && data) {
-        try {
-          const parsed = JSON.parse(data);
-          events.push(parsed);
-        } catch {
-          logger.warn("Failed to parse SSE data:", data);
-        }
-        eventType = "message";
-        data = "";
-      }
-    }
-    return events;
-  }
-  async function startStream(cfg) {
-    const streamParams = new URLSearchParams({
-      orgId: cfg.orgId,
-      userId: cfg.userId,
-      clientType: cfg.clientType
-    });
-    if (cfg.chatKey) streamParams.set("chatId", cfg.chatKey);
-    const url = `${cfg.baseUrl}/stream?${streamParams.toString()}`;
-    logger.debug("Connecting to:", url);
-    abortController = new AbortController();
-    const response = await customFetch(url, {
-      method: "GET",
-      headers: {
-        Accept: "text/event-stream",
-        "Cache-Control": "no-cache"
-      },
-      signal: abortController.signal
-    });
-    if (!response.ok) {
-      throw new Error(`Stream connection failed: ${response.status}`);
-    }
-    if (!response.body) {
-      throw new Error("Response body is null - ReadableStream not supported");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    const readStream = async () => {
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            logger.info("Stream ended");
-            break;
-          }
-          buffer += decoder.decode(value, { stream: true });
-          const lastNewline = buffer.lastIndexOf("\n\n");
-          if (lastNewline !== -1) {
-            const complete = buffer.slice(0, lastNewline + 2);
-            buffer = buffer.slice(lastNewline + 2);
-            const events = parseSSEChunk(complete);
-            events.forEach(emit);
-          }
-        }
-      } catch (err) {
-        if (err.name === "AbortError") {
-          logger.debug("Stream aborted");
-          return;
-        }
-        logger.error("Stream error:", err);
-        throw err;
-      }
-      if (!intentionalDisconnect) {
-        state = "disconnected";
-        scheduleReconnect();
-      }
-    };
-    readStream().catch((err) => {
-      if (!intentionalDisconnect) {
-        error = {
-          code: "CONNECTION_FAILED",
-          message: err.message,
-          retryable: true,
-          timestamp: Date.now(),
-          originalError: err
-        };
-        metrics.lastError = error;
-        state = "disconnected";
-        scheduleReconnect();
-      }
-    });
-  }
-  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 (abortController) {
-        abortController.abort();
-        abortController = void 0;
-      }
-      if (reconnectTimeout) {
-        clearTimeout(reconnectTimeout);
-        reconnectTimeout = void 0;
-      }
-      state = retryCount > 0 ? "reconnecting" : "connecting";
-      const connectionStart = Date.now();
-      try {
-        const wasReconnect = retryCount > 0;
-        await startStream(cfg);
-        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;
-        if (wasReconnect) {
-          emit({
-            type: "transport_reconnected",
-            orgId: cfg.orgId,
-            chatKey: cfg.chatKey || "",
-            userId: cfg.userId,
-            timestamp: Date.now()
-          });
-        }
-      } catch (err) {
-        const connectError = {
-          code: "CONNECTION_FAILED",
-          message: err.message,
-          retryable: true,
-          timestamp: Date.now(),
-          originalError: err
-        };
-        error = connectError;
-        metrics.lastError = connectError;
-        state = "disconnected";
-        if (!intentionalDisconnect) {
-          scheduleReconnect();
-        }
-        throw connectError;
-      }
-    },
-    disconnect(intentional = true) {
-      logger.info("Disconnecting", { intentional });
-      intentionalDisconnect = intentional;
-      if (reconnectTimeout) {
-        clearTimeout(reconnectTimeout);
-        reconnectTimeout = void 0;
-      }
-      if (abortController) {
-        abortController.abort();
-        abortController = 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,
-            ...event.data ? { data: event.data } : {}
-          });
-          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) {
-  if (type === "sse-fetch") {
-    return createFetchSSETransport({ debug });
-  }
-  if (type === "sse") {
-    return createSSETransport({ debug });
-  }
-  const isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
-  if (isReactNative || typeof EventSource === "undefined") {
-    return createFetchSSETransport({ 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] = useState("disconnected");
-  const [currentChat, setCurrentChat] = useState(null);
-  const [chatKey, setChatKey] = useState(null);
-  const [messages, setMessages] = useState([]);
-  const [error, setError] = useState(null);
-  const [metrics, setMetrics] = useState({
-    latency: 0,
-    messagesSent: 0,
-    messagesReceived: 0,
-    messagesQueued: 0,
-    reconnectCount: 0
-  });
-  const transportRef = useRef(null);
-  const mountedRef = useRef(false);
-  const onMessageRef = useRef(onMessage);
-  const onErrorRef = useRef(onError);
-  const typingTimeoutRef = useRef(null);
-  useEffect(() => {
-    onMessageRef.current = onMessage;
-    onErrorRef.current = onError;
-  }, [onMessage, onError]);
-  useEffect(() => {
-    if (typeof transportOption === "object") {
-      transportRef.current = transportOption;
-    } else {
-      transportRef.current = getDefaultTransport(
-        transportOption,
-        debug
-      );
-    }
-  }, [transportOption, debug]);
-  const handleEvent = 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 = 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");
-    onConnectionChange?.("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");
-      onConnectionChange?.("disconnected");
-      setError(transportError);
-      onErrorRef.current?.(transportError);
-      throw err;
-    }
-  }, [baseUrl, orgId, userId, clientType, chatKey, debug, handleEvent, onConnectionChange]);
-  const disconnect = useCallback(() => {
-    const transport = transportRef.current;
-    if (transport) {
-      transport.disconnect(true);
-    }
-    setConnectionState("disconnected");
-    onConnectionChange?.("disconnected");
-  }, [onConnectionChange]);
-  const startChat = 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 loadChat2 = 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 = useCallback(
-    async (content, attachments, data) => {
-      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,
-        ...data ? { data } : {}
-      });
-      setMetrics((prev) => ({
-        ...prev,
-        messagesSent: prev.messagesSent + 1
-      }));
-    },
-    [orgId, chatKey, userId]
-  );
-  const endChat2 = 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 sendEvent2 = useCallback(
-    async (event) => {
-      const transport = transportRef.current;
-      if (!transport) {
-        throw new Error("Transport not initialized");
-      }
-      await transport.send({
-        ...event,
-        timestamp: Date.now()
-      });
-    },
-    []
-  );
-  const startTyping = 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 = 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 = useCallback(
-    (eventType, handler) => {
-      const transport = transportRef.current;
-      if (!transport) {
-        return () => {
-        };
-      }
-      return transport.on(eventType, handler);
-    },
-    []
-  );
-  const clearError = useCallback(() => {
-    setError(null);
-    transportRef.current?.clearError();
-  }, []);
-  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: loadChat2,
-    sendMessage,
-    sendEvent: sendEvent2,
-    endChat: endChat2,
-    // Typing
-    startTyping,
-    stopTyping,
-    // State
-    currentChat,
-    chatKey,
-    messages,
-    error,
-    metrics,
-    // Events
-    on,
-    clearError
-  };
-}
-
-// hooks/use-chat-history.ts
-import { useMemo } from "react";
-
-// api/index.ts
-import { browserApiRequest as browserApiRequest2 } from "@elqnt/api-client/browser";
-
-// api/memory.ts
-import { browserApiRequest } from "@elqnt/api-client/browser";
-var patchProfileApi = (patch, o) => browserApiRequest("/api/v1/memory/profile", { method: "PATCH", body: patch, ...o });
-var replaceProfileApi = (p, o) => browserApiRequest("/api/v1/memory/profile", { method: "PUT", body: p, ...o });
-var clearProfileApi = (o) => browserApiRequest("/api/v1/memory/profile", { method: "DELETE", ...o });
-var deleteContactApi = (name, o) => browserApiRequest(`/api/v1/memory/profile/contacts/${encodeURIComponent(name)}`, { method: "DELETE", ...o });
-var deleteNoteApi = (index, o) => browserApiRequest(`/api/v1/memory/profile/notes/${index}`, { method: "DELETE", ...o });
-var clearSummaryApi = (chatKey, o) => browserApiRequest(`/api/v1/chats/${chatKey}/summary`, { method: "DELETE", ...o });
-var regenerateSummaryApi = (chatKey, o) => browserApiRequest(`/api/v1/chats/${chatKey}/summary/regenerate`, { method: "POST", ...o });
-
-// api/index.ts
-async function getChatHistoryApi(options) {
-  return browserApiRequest2("/api/v1/chats", {
-    method: "POST",
-    body: {
-      limit: options.limit || 15,
-      offset: options.offset || 0,
-      ...options.skipCache ? { skipCache: true } : {}
-    },
-    ...options
-  });
-}
-async function getChatApi(chatKey, options) {
-  return browserApiRequest2(`/api/v1/chats/${chatKey}`, {
-    method: "GET",
-    ...options
-  });
-}
-async function updateChatApi(chatKey, updates, options) {
-  return browserApiRequest2(`/api/v1/chats/${chatKey}`, {
-    method: "PATCH",
-    body: updates,
-    ...options
-  });
-}
-async function deleteChatApi(chatKey, options) {
-  return browserApiRequest2(`/api/v1/chats/${chatKey}`, {
-    method: "DELETE",
-    ...options
-  });
-}
-async function getActiveChatsCountApi(options) {
-  return browserApiRequest2("/api/v1/chats/active/count", {
-    method: "GET",
-    ...options
-  });
-}
-async function getActiveChatsApi(options) {
-  const params = new URLSearchParams();
-  if (options.pastHours) params.set("pastHours", String(options.pastHours));
-  const queryString = params.toString();
-  return browserApiRequest2(`/api/v1/chats/active${queryString ? `?${queryString}` : ""}`, {
-    method: "GET",
-    ...options
-  });
-}
-async function getWaitingChatsCountApi(options) {
-  return browserApiRequest2("/api/v1/chats/waiting/count", {
-    method: "GET",
-    ...options
-  });
-}
-async function getChatsByUserApi(userEmail, options) {
-  return browserApiRequest2(`/api/v1/chats/user/${encodeURIComponent(userEmail)}`, {
-    method: "GET",
-    ...options
-  });
-}
-async function listQueuesApi(options) {
-  return browserApiRequest2("/api/v1/queues", {
-    method: "GET",
-    ...options
-  });
-}
-async function getOnlineSessionsApi(options) {
-  return browserApiRequest2("/api/v1/agents/sessions/online", {
-    method: "GET",
-    ...options
-  });
-}
-async function getAgentSessionApi(agentId, options) {
-  return browserApiRequest2(`/api/v1/agents/sessions/${agentId}`, {
-    method: "GET",
-    ...options
-  });
-}
-
-// hooks/use-chat-history.ts
-import { useApiAsync } from "@elqnt/api-client/hooks";
-
-// hooks/use-options-ref.ts
-import { useRef as useRef2, useEffect as useEffect2 } from "react";
-function useOptionsRef(options) {
-  const optionsRef = useRef2(options);
-  useEffect2(() => {
-    optionsRef.current = options;
-  }, [options]);
-  return optionsRef;
-}
-
-// hooks/use-chat-history.ts
-function useChatHistory(options) {
-  const optionsRef = useOptionsRef(options);
-  const { execute: getChatHistory, loading: listLoading, error: listError } = useApiAsync(
-    (params) => getChatHistoryApi({ ...optionsRef.current, ...params }),
-    (data) => ({
-      chats: data.chats,
-      total: data.total,
-      hasMore: data.hasMore
-    }),
-    { chats: [], total: 0, hasMore: false }
-  );
-  const { execute: getChat, loading: getLoading, error: getError } = useApiAsync(
-    (chatKey) => getChatApi(chatKey, optionsRef.current),
-    (data) => data.chat || null,
-    null
-  );
-  const { execute: updateChat, loading: updateLoading, error: updateError } = useApiAsync(
-    (chatKey, updates) => updateChatApi(chatKey, updates, optionsRef.current),
-    (data) => !!data.chatKey,
-    false
-  );
-  const { execute: deleteChat, loading: deleteLoading, error: deleteError } = useApiAsync(
-    (chatKey) => deleteChatApi(chatKey, optionsRef.current),
-    (data) => data.success,
-    false
-  );
-  const { execute: getChatsByUser, loading: userChatsLoading, error: userChatsError } = useApiAsync(
-    (userEmail) => getChatsByUserApi(userEmail, optionsRef.current),
-    (data) => data.chats,
-    []
-  );
-  const loading = listLoading || getLoading || updateLoading || deleteLoading || userChatsLoading;
-  const error = listError || getError || updateError || deleteError || userChatsError;
-  return useMemo(
-    () => ({
-      loading,
-      error,
-      getChatHistory,
-      getChat,
-      updateChat,
-      deleteChat,
-      getChatsByUser
-    }),
-    [loading, error, getChatHistory, getChat, updateChat, deleteChat, getChatsByUser]
-  );
-}
-
-// hooks/use-chat-monitoring.ts
-import { useMemo as useMemo2 } from "react";
-import { useApiAsync as useApiAsync2 } from "@elqnt/api-client/hooks";
-function useChatMonitoring(options) {
-  const optionsRef = useOptionsRef(options);
-  const { execute: getActiveChats, loading: activeLoading, error: activeError } = useApiAsync2(
-    (pastHours) => getActiveChatsApi({ ...optionsRef.current, pastHours }),
-    (data) => data.chats,
-    []
-  );
-  const { execute: getActiveChatsCount, loading: activeCountLoading, error: activeCountError } = useApiAsync2(
-    () => getActiveChatsCountApi(optionsRef.current),
-    (data) => data.count,
-    0
-  );
-  const { execute: getWaitingChatsCount, loading: waitingCountLoading, error: waitingCountError } = useApiAsync2(
-    () => getWaitingChatsCountApi(optionsRef.current),
-    (data) => data.count,
-    0
-  );
-  const { execute: listQueues, loading: queuesLoading, error: queuesError } = useApiAsync2(
-    () => listQueuesApi(optionsRef.current),
-    (data) => data.queues,
-    []
-  );
-  const loading = activeLoading || activeCountLoading || waitingCountLoading || queuesLoading;
-  const error = activeError || activeCountError || waitingCountError || queuesError;
-  return useMemo2(
-    () => ({
-      loading,
-      error,
-      getActiveChats,
-      getActiveChatsCount,
-      getWaitingChatsCount,
-      listQueues
-    }),
-    [loading, error, getActiveChats, getActiveChatsCount, getWaitingChatsCount, listQueues]
-  );
-}
-
-// hooks/use-human-agent-sessions.ts
-import { useMemo as useMemo3 } from "react";
-import { useApiAsync as useApiAsync3 } from "@elqnt/api-client/hooks";
-function useHumanAgentSessions(options) {
-  const optionsRef = useOptionsRef(options);
-  const { execute: getOnlineSessions, loading: onlineLoading, error: onlineError } = useApiAsync3(
-    () => getOnlineSessionsApi(optionsRef.current),
-    (data) => data.sessions,
-    []
-  );
-  const { execute: getAgentSession, loading: sessionLoading, error: sessionError } = useApiAsync3(
-    (agentId) => getAgentSessionApi(agentId, optionsRef.current),
-    (data) => data.session || null,
-    null
-  );
-  const loading = onlineLoading || sessionLoading;
-  const error = onlineError || sessionError;
-  return useMemo3(
-    () => ({
-      loading,
-      error,
-      getOnlineSessions,
-      getAgentSession
-    }),
-    [loading, error, getOnlineSessions, getAgentSession]
-  );
-}
-
-// hooks/use-memory.ts
-import { useCallback as useCallback2, useRef as useRef3, useState as useState2 } from "react";
-function useMemory(options, initialProfile = null) {
-  const [profile, setProfile] = useState2(initialProfile);
-  const [loading, setLoading] = useState2(false);
-  const requestCountRef = useRef3(0);
-  const runProfileMutation = useCallback2(
-    async (fn) => {
-      requestCountRef.current += 1;
-      setLoading(true);
-      try {
-        const response = await fn();
-        if (!response.error && response.data) {
-          setProfile(response.data);
-          return response.data;
-        }
-        return null;
-      } catch {
-        return null;
-      } finally {
-        requestCountRef.current -= 1;
-        if (requestCountRef.current === 0) {
-          setLoading(false);
-        }
-      }
-    },
-    []
-  );
-  const optionsRef = useRef3(options);
-  optionsRef.current = options;
-  const patchProfile = useCallback2(
-    (patch) => runProfileMutation(() => patchProfileApi(patch, optionsRef.current)),
-    [runProfileMutation]
-  );
-  const replaceProfile = useCallback2(
-    (p) => runProfileMutation(() => replaceProfileApi(p, optionsRef.current)),
-    [runProfileMutation]
-  );
-  const clearProfile = useCallback2(
-    () => runProfileMutation(() => clearProfileApi(optionsRef.current)),
-    [runProfileMutation]
-  );
-  const deleteContact = useCallback2(
-    (name) => runProfileMutation(() => deleteContactApi(name, optionsRef.current)),
-    [runProfileMutation]
-  );
-  const deleteNote = useCallback2(
-    (index) => runProfileMutation(() => deleteNoteApi(index, optionsRef.current)),
-    [runProfileMutation]
-  );
-  const clearSummary = useCallback2(
-    async (chatKey) => {
-      await clearSummaryApi(chatKey, optionsRef.current);
-    },
-    []
-  );
-  const regenerateSummary = useCallback2(
-    async (chatKey) => {
-      const response = await regenerateSummaryApi(chatKey, optionsRef.current);
-      if (!response.error && response.data) {
-        return response.data;
-      }
-      return null;
-    },
-    []
-  );
-  return {
-    profile,
-    loading,
-    patchProfile,
-    replaceProfile,
-    clearProfile,
-    deleteContact,
-    deleteNote,
-    clearSummary,
-    regenerateSummary
-  };
-}
-
-// hooks/index.ts
-import { useApiAsync as useApiAsync4 } from "@elqnt/api-client/hooks";
-
 // models/chat-models.ts
 var ChatStatusActive = "active";
 var ChatStatusDisconnected = "disconnected";
@@ -1856,13 +384,6 @@ export {
   UserStatusAway,
   UserStatusBusy,
   UserStatusOffline,
-  UserStatusOnline,
-  useApiAsync4 as useApiAsync,
-  useChat,
-  useChatHistory,
-  useChatMonitoring,
-  useHumanAgentSessions,
-  useMemory,
-  useOptionsRef
+  UserStatusOnline
 };
 //# sourceMappingURL=index.mjs.map