@elqnt/chat 3.0.2 → 3.1.0

package/dist/index.js

@@ -159,6 +159,7 @@ __export(index_exports, {
   ChatStatusActive: () => ChatStatusActive,
   ChatStatusArchived: () => ChatStatusArchived,
   ChatStatusClosed: () => ChatStatusClosed,
+  ChatStatusCompleted: () => ChatStatusCompleted,
   ChatStatusDisconnected: () => ChatStatusDisconnected,
   ChatTypeCustomerSupport: () => ChatTypeCustomerSupport,
   ChatTypeDirect: () => ChatTypeDirect,
@@ -171,6 +172,7 @@ __export(index_exports, {
   EndAgentSessionSubject: () => EndAgentSessionSubject,
   GetActiveChatCountSubject: () => GetActiveChatCountSubject,
   GetActiveChatsSubject: () => GetActiveChatsSubject,
+  GetAgentContextSubject: () => GetAgentContextSubject,
   GetAgentQueuesSubject: () => GetAgentQueuesSubject,
   GetAgentSessionSubject: () => GetAgentSessionSubject,
   GetChatSubject: () => GetChatSubject,
@@ -196,6 +198,7 @@ __export(index_exports, {
   SetupOrgSubject: () => SetupOrgSubject,
   StartAgentSessionSubject: () => StartAgentSessionSubject,
   TriggerAnalyticsScanSubject: () => TriggerAnalyticsScanSubject,
+  TriggerMemorySummarizationSubject: () => TriggerMemorySummarizationSubject,
   UpdateAgentLastActivitySubject: () => UpdateAgentLastActivitySubject,
   UpdateAgentQueueSubject: () => UpdateAgentQueueSubject,
   UpdateAgentStatusSubject: () => UpdateAgentStatusSubject,
@@ -204,7 +207,13 @@ __export(index_exports, {
   UserStatusBusy: () => UserStatusBusy,
   UserStatusOffline: () => UserStatusOffline,
   UserStatusOnline: () => UserStatusOnline,
-  useChat: () => useChat
+  useApiAsync: () => import_hooks4.useApiAsync,
+  useChat: () => useChat,
+  useChatHistory: () => useChatHistory,
+  useChatMonitoring: () => useChatMonitoring,
+  useHumanAgentSessions: () => useHumanAgentSessions,
+  useMemory: () => useMemory,
+  useOptionsRef: () => useOptionsRef
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -440,6 +449,383 @@ function createSSETransport(options = {}) {
       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 url = `${cfg.baseUrl}/stream?orgId=${cfg.orgId}&userId=${cfg.userId}&clientType=${cfg.clientType}${cfg.chatKey ? `&chatId=${cfg.chatKey}` : ""}`;
+    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 {
+        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;
+      } 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");
@@ -582,6 +968,16 @@ function createSSETransport(options = {}) {
 
 // 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) {
@@ -692,6 +1088,7 @@ function useChat(options) {
       throw err;
     }
     setConnectionState("connecting");
+    onConnectionChange?.("connecting");
     try {
       const unsubscribe = transport.onMessage(handleEvent);
       await transport.connect({
@@ -710,6 +1107,7 @@ function useChat(options) {
     } catch (err) {
       const transportError = err;
       setConnectionState("disconnected");
+      onConnectionChange?.("disconnected");
       setError(transportError);
       onErrorRef.current?.(transportError);
       throw err;
@@ -739,7 +1137,7 @@ function useChat(options) {
     },
     [orgId, userId]
   );
-  const loadChat = (0, import_react.useCallback)(
+  const loadChat2 = (0, import_react.useCallback)(
     async (key) => {
       const transport = transportRef.current;
       if (!transport) {
@@ -792,7 +1190,7 @@ function useChat(options) {
     },
     [orgId, chatKey, userId]
   );
-  const endChat = (0, import_react.useCallback)(
+  const endChat2 = (0, import_react.useCallback)(
     async (reason) => {
       const transport = transportRef.current;
       if (!transport) {
@@ -814,7 +1212,7 @@ function useChat(options) {
     },
     [orgId, chatKey, userId]
   );
-  const sendEvent = (0, import_react.useCallback)(
+  const sendEvent2 = (0, import_react.useCallback)(
     async (event) => {
       const transport = transportRef.current;
       if (!transport) {
@@ -899,10 +1297,10 @@ function useChat(options) {
     isConnected,
     // Chat operations
     startChat,
-    loadChat,
+    loadChat: loadChat2,
     sendMessage,
-    sendEvent,
-    endChat,
+    sendEvent: sendEvent2,
+    endChat: endChat2,
     // Typing
     startTyping,
     stopTyping,
@@ -918,12 +1316,317 @@ function useChat(options) {
   };
 }
 
+// hooks/use-chat-history.ts
+var import_react3 = require("react");
+
+// api/index.ts
+var import_browser2 = require("@elqnt/api-client/browser");
+
+// api/memory.ts
+var import_browser = require("@elqnt/api-client/browser");
+var patchProfileApi = (patch, o) => (0, import_browser.browserApiRequest)("/api/v1/memory/profile", { method: "PATCH", body: patch, ...o });
+var replaceProfileApi = (p, o) => (0, import_browser.browserApiRequest)("/api/v1/memory/profile", { method: "PUT", body: p, ...o });
+var clearProfileApi = (o) => (0, import_browser.browserApiRequest)("/api/v1/memory/profile", { method: "DELETE", ...o });
+var deleteContactApi = (name, o) => (0, import_browser.browserApiRequest)(`/api/v1/memory/profile/contacts/${encodeURIComponent(name)}`, { method: "DELETE", ...o });
+var deleteNoteApi = (index, o) => (0, import_browser.browserApiRequest)(`/api/v1/memory/profile/notes/${index}`, { method: "DELETE", ...o });
+var clearSummaryApi = (chatKey, o) => (0, import_browser.browserApiRequest)(`/api/v1/chats/${chatKey}/summary`, { method: "DELETE", ...o });
+var regenerateSummaryApi = (chatKey, o) => (0, import_browser.browserApiRequest)(`/api/v1/chats/${chatKey}/summary/regenerate`, { method: "POST", ...o });
+
+// api/index.ts
+async function getChatHistoryApi(options) {
+  return (0, import_browser2.browserApiRequest)("/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 (0, import_browser2.browserApiRequest)(`/api/v1/chats/${chatKey}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function updateChatApi(chatKey, updates, options) {
+  return (0, import_browser2.browserApiRequest)(`/api/v1/chats/${chatKey}`, {
+    method: "PATCH",
+    body: updates,
+    ...options
+  });
+}
+async function deleteChatApi(chatKey, options) {
+  return (0, import_browser2.browserApiRequest)(`/api/v1/chats/${chatKey}`, {
+    method: "DELETE",
+    ...options
+  });
+}
+async function getActiveChatsCountApi(options) {
+  return (0, import_browser2.browserApiRequest)("/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 (0, import_browser2.browserApiRequest)(`/api/v1/chats/active${queryString ? `?${queryString}` : ""}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function getWaitingChatsCountApi(options) {
+  return (0, import_browser2.browserApiRequest)("/api/v1/chats/waiting/count", {
+    method: "GET",
+    ...options
+  });
+}
+async function getChatsByUserApi(userEmail, options) {
+  return (0, import_browser2.browserApiRequest)(`/api/v1/chats/user/${encodeURIComponent(userEmail)}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function listQueuesApi(options) {
+  return (0, import_browser2.browserApiRequest)("/api/v1/queues", {
+    method: "GET",
+    ...options
+  });
+}
+async function getOnlineSessionsApi(options) {
+  return (0, import_browser2.browserApiRequest)("/api/v1/agents/sessions/online", {
+    method: "GET",
+    ...options
+  });
+}
+async function getAgentSessionApi(agentId, options) {
+  return (0, import_browser2.browserApiRequest)(`/api/v1/agents/sessions/${agentId}`, {
+    method: "GET",
+    ...options
+  });
+}
+
+// hooks/use-chat-history.ts
+var import_hooks = require("@elqnt/api-client/hooks");
+
+// hooks/use-options-ref.ts
+var import_react2 = require("react");
+function useOptionsRef(options) {
+  const optionsRef = (0, import_react2.useRef)(options);
+  (0, import_react2.useEffect)(() => {
+    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 } = (0, import_hooks.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 } = (0, import_hooks.useApiAsync)(
+    (chatKey) => getChatApi(chatKey, optionsRef.current),
+    (data) => data.chat || null,
+    null
+  );
+  const { execute: updateChat, loading: updateLoading, error: updateError } = (0, import_hooks.useApiAsync)(
+    (chatKey, updates) => updateChatApi(chatKey, updates, optionsRef.current),
+    (data) => !!data.chatKey,
+    false
+  );
+  const { execute: deleteChat, loading: deleteLoading, error: deleteError } = (0, import_hooks.useApiAsync)(
+    (chatKey) => deleteChatApi(chatKey, optionsRef.current),
+    (data) => data.success,
+    false
+  );
+  const { execute: getChatsByUser, loading: userChatsLoading, error: userChatsError } = (0, import_hooks.useApiAsync)(
+    (userEmail) => getChatsByUserApi(userEmail, optionsRef.current),
+    (data) => data.chats,
+    []
+  );
+  const loading = listLoading || getLoading || updateLoading || deleteLoading || userChatsLoading;
+  const error = listError || getError || updateError || deleteError || userChatsError;
+  return (0, import_react3.useMemo)(
+    () => ({
+      loading,
+      error,
+      getChatHistory,
+      getChat,
+      updateChat,
+      deleteChat,
+      getChatsByUser
+    }),
+    [loading, error, getChatHistory, getChat, updateChat, deleteChat, getChatsByUser]
+  );
+}
+
+// hooks/use-chat-monitoring.ts
+var import_react4 = require("react");
+var import_hooks2 = require("@elqnt/api-client/hooks");
+function useChatMonitoring(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: getActiveChats, loading: activeLoading, error: activeError } = (0, import_hooks2.useApiAsync)(
+    (pastHours) => getActiveChatsApi({ ...optionsRef.current, pastHours }),
+    (data) => data.chats,
+    []
+  );
+  const { execute: getActiveChatsCount, loading: activeCountLoading, error: activeCountError } = (0, import_hooks2.useApiAsync)(
+    () => getActiveChatsCountApi(optionsRef.current),
+    (data) => data.count,
+    0
+  );
+  const { execute: getWaitingChatsCount, loading: waitingCountLoading, error: waitingCountError } = (0, import_hooks2.useApiAsync)(
+    () => getWaitingChatsCountApi(optionsRef.current),
+    (data) => data.count,
+    0
+  );
+  const { execute: listQueues, loading: queuesLoading, error: queuesError } = (0, import_hooks2.useApiAsync)(
+    () => listQueuesApi(optionsRef.current),
+    (data) => data.queues,
+    []
+  );
+  const loading = activeLoading || activeCountLoading || waitingCountLoading || queuesLoading;
+  const error = activeError || activeCountError || waitingCountError || queuesError;
+  return (0, import_react4.useMemo)(
+    () => ({
+      loading,
+      error,
+      getActiveChats,
+      getActiveChatsCount,
+      getWaitingChatsCount,
+      listQueues
+    }),
+    [loading, error, getActiveChats, getActiveChatsCount, getWaitingChatsCount, listQueues]
+  );
+}
+
+// hooks/use-human-agent-sessions.ts
+var import_react5 = require("react");
+var import_hooks3 = require("@elqnt/api-client/hooks");
+function useHumanAgentSessions(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: getOnlineSessions, loading: onlineLoading, error: onlineError } = (0, import_hooks3.useApiAsync)(
+    () => getOnlineSessionsApi(optionsRef.current),
+    (data) => data.sessions,
+    []
+  );
+  const { execute: getAgentSession, loading: sessionLoading, error: sessionError } = (0, import_hooks3.useApiAsync)(
+    (agentId) => getAgentSessionApi(agentId, optionsRef.current),
+    (data) => data.session || null,
+    null
+  );
+  const loading = onlineLoading || sessionLoading;
+  const error = onlineError || sessionError;
+  return (0, import_react5.useMemo)(
+    () => ({
+      loading,
+      error,
+      getOnlineSessions,
+      getAgentSession
+    }),
+    [loading, error, getOnlineSessions, getAgentSession]
+  );
+}
+
+// hooks/use-memory.ts
+var import_react6 = require("react");
+function useMemory(options, initialProfile = null) {
+  const [profile, setProfile] = (0, import_react6.useState)(initialProfile);
+  const [loading, setLoading] = (0, import_react6.useState)(false);
+  const requestCountRef = (0, import_react6.useRef)(0);
+  const runProfileMutation = (0, import_react6.useCallback)(
+    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 = (0, import_react6.useRef)(options);
+  optionsRef.current = options;
+  const patchProfile = (0, import_react6.useCallback)(
+    (patch) => runProfileMutation(() => patchProfileApi(patch, optionsRef.current)),
+    [runProfileMutation]
+  );
+  const replaceProfile = (0, import_react6.useCallback)(
+    (p) => runProfileMutation(() => replaceProfileApi(p, optionsRef.current)),
+    [runProfileMutation]
+  );
+  const clearProfile = (0, import_react6.useCallback)(
+    () => runProfileMutation(() => clearProfileApi(optionsRef.current)),
+    [runProfileMutation]
+  );
+  const deleteContact = (0, import_react6.useCallback)(
+    (name) => runProfileMutation(() => deleteContactApi(name, optionsRef.current)),
+    [runProfileMutation]
+  );
+  const deleteNote = (0, import_react6.useCallback)(
+    (index) => runProfileMutation(() => deleteNoteApi(index, optionsRef.current)),
+    [runProfileMutation]
+  );
+  const clearSummary = (0, import_react6.useCallback)(
+    async (chatKey) => {
+      await clearSummaryApi(chatKey, optionsRef.current);
+    },
+    []
+  );
+  const regenerateSummary = (0, import_react6.useCallback)(
+    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
+var import_hooks4 = require("@elqnt/api-client/hooks");
+
 // models/chat-models.ts
 var ChatStatusActive = "active";
 var ChatStatusDisconnected = "disconnected";
 var ChatStatusAbandoned = "abandoned";
 var ChatStatusClosed = "closed";
 var ChatStatusArchived = "archived";
+var ChatStatusCompleted = "completed";
 var ChatTypeCustomerSupport = "customer_support";
 var ChatTypePublicRoom = "public_room";
 var ChatTypePrivateRoom = "private_room";
@@ -1107,6 +1810,8 @@ var UpdateUserStatusSubject = "chat.user.status.update";
 var GetOnlineUsersSubject = "chat.users.online.get";
 var TriggerAnalyticsScanSubject = "chat.analytics.trigger-scan";
 var SetupOrgSubject = "chat.org.setup";
+var GetAgentContextSubject = "chat.agent-context.get";
+var TriggerMemorySummarizationSubject = "chat.memory.summarize.nightly";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentStatusAway,
@@ -1247,6 +1952,7 @@ var SetupOrgSubject = "chat.org.setup";
   ChatStatusActive,
   ChatStatusArchived,
   ChatStatusClosed,
+  ChatStatusCompleted,
   ChatStatusDisconnected,
   ChatTypeCustomerSupport,
   ChatTypeDirect,
@@ -1259,6 +1965,7 @@ var SetupOrgSubject = "chat.org.setup";
   EndAgentSessionSubject,
   GetActiveChatCountSubject,
   GetActiveChatsSubject,
+  GetAgentContextSubject,
   GetAgentQueuesSubject,
   GetAgentSessionSubject,
   GetChatSubject,
@@ -1284,6 +1991,7 @@ var SetupOrgSubject = "chat.org.setup";
   SetupOrgSubject,
   StartAgentSessionSubject,
   TriggerAnalyticsScanSubject,
+  TriggerMemorySummarizationSubject,
   UpdateAgentLastActivitySubject,
   UpdateAgentQueueSubject,
   UpdateAgentStatusSubject,
@@ -1292,6 +2000,12 @@ var SetupOrgSubject = "chat.org.setup";
   UserStatusBusy,
   UserStatusOffline,
   UserStatusOnline,
-  useChat
+  useApiAsync,
+  useChat,
+  useChatHistory,
+  useChatMonitoring,
+  useHumanAgentSessions,
+  useMemory,
+  useOptionsRef
 });
 //# sourceMappingURL=index.js.map