@paymanai/payman-typescript-ask-sdk 1.2.4 → 1.2.5

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { useState, useRef, useMemo, useCallback, useEffect } from 'react';
+import { useState, useRef, useCallback, useMemo, useEffect } from 'react';
 
 // src/hooks/useChat.ts
 
@@ -612,6 +612,84 @@ async function cancelUserAction(config, userActionId) {
 async function resendUserAction(config, userActionId) {
   return sendUserActionRequest(config, userActionId, "resend");
 }
+
+// src/utils/chatStore.ts
+var memoryStore = /* @__PURE__ */ new Map();
+var chatStore = {
+  get(key) {
+    return memoryStore.get(key) ?? [];
+  },
+  set(key, messages) {
+    memoryStore.set(key, messages);
+  },
+  delete(key) {
+    memoryStore.delete(key);
+  }
+};
+
+// src/utils/activeStreamStore.ts
+var streams = /* @__PURE__ */ new Map();
+var activeStreamStore = {
+  has(key) {
+    return streams.has(key);
+  },
+  get(key) {
+    const entry = streams.get(key);
+    if (!entry) return null;
+    return { messages: entry.messages, isWaiting: entry.isWaiting };
+  },
+  // Called before startStream — registers the controller and initial messages
+  start(key, abortController, initialMessages) {
+    const existing = streams.get(key);
+    streams.set(key, {
+      messages: initialMessages,
+      isWaiting: true,
+      abortController,
+      listeners: existing?.listeners ?? /* @__PURE__ */ new Set()
+    });
+  },
+  // Called by the stream on every event — applies the same updater pattern React uses
+  applyMessages(key, updater) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    const next = typeof updater === "function" ? updater(entry.messages) : updater;
+    entry.messages = next;
+    entry.listeners.forEach((l) => l(next, entry.isWaiting));
+  },
+  setWaiting(key, waiting) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.isWaiting = waiting;
+    entry.listeners.forEach((l) => l(entry.messages, waiting));
+  },
+  // Called when stream completes — persists to chatStore and cleans up
+  complete(key) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.isWaiting = false;
+    entry.listeners.forEach((l) => l(entry.messages, false));
+    const toSave = entry.messages.filter((m) => !m.isStreaming);
+    if (toSave.length > 0) chatStore.set(key, toSave);
+    streams.delete(key);
+  },
+  // Subscribe — returns unsubscribe fn. Component calls this on mount, cleanup on unmount.
+  subscribe(key, listener) {
+    const entry = streams.get(key);
+    if (!entry) return () => {
+    };
+    entry.listeners.add(listener);
+    return () => {
+      streams.get(key)?.listeners.delete(listener);
+    };
+  },
+  // Explicit user cancel — aborts the controller and removes the entry
+  abort(key) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.abortController.abort();
+    streams.delete(key);
+  }
+};
 function useStreamManager(config, callbacks, setMessages, setIsWaitingForResponse) {
   const abortControllerRef = useRef(null);
   const configRef = useRef(config);
@@ -619,9 +697,9 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
   const callbacksRef = useRef(callbacks);
   callbacksRef.current = callbacks;
   const startStream = useCallback(
-    async (userMessage, streamingId, sessionId) => {
+    async (userMessage, streamingId, sessionId, externalAbortController) => {
       abortControllerRef.current?.abort();
-      const abortController = new AbortController();
+      const abortController = externalAbortController ?? new AbortController();
       abortControllerRef.current = abortController;
       const state = {
         accumulatedContent: "",
@@ -825,13 +903,43 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
 
 // src/hooks/useChat.ts
 function useChat(config, callbacks = {}) {
-  const [messages, setMessages] = useState([]);
+  const [messages, setMessages] = useState(() => {
+    if (config.userId) return chatStore.get(config.userId);
+    return config.initialMessages ?? [];
+  });
   const [isWaitingForResponse, setIsWaitingForResponse] = useState(false);
-  const sessionIdRef = useRef(void 0);
+  const sessionIdRef = useRef(
+    config.userId ? chatStore.get(config.userId).find((m) => m.sessionId)?.sessionId ?? config.initialSessionId ?? void 0 : config.initialSessionId ?? void 0
+  );
+  const prevUserIdRef = useRef(config.userId);
   const callbacksRef = useRef(callbacks);
   callbacksRef.current = callbacks;
   const configRef = useRef(config);
   configRef.current = config;
+  const messagesRef = useRef(messages);
+  messagesRef.current = messages;
+  const storeAwareSetMessages = useCallback(
+    (updater) => {
+      const { userId } = configRef.current;
+      if (userId && activeStreamStore.has(userId)) {
+        activeStreamStore.applyMessages(userId, updater);
+      }
+      setMessages(updater);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const storeAwareSetIsWaiting = useCallback(
+    (waiting) => {
+      const { userId } = configRef.current;
+      if (userId && activeStreamStore.has(userId)) {
+        activeStreamStore.setWaiting(userId, waiting);
+      }
+      setIsWaitingForResponse(waiting);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
   const [userActionState, setUserActionState] = useState({
     request: null,
     result: null,
@@ -874,8 +982,8 @@ function useChat(config, callbacks = {}) {
   const { startStream, cancelStream: cancelStreamManager, abortControllerRef } = useStreamManager(
     config,
     wrappedCallbacks,
-    setMessages,
-    setIsWaitingForResponse
+    storeAwareSetMessages,
+    storeAwareSetIsWaiting
   );
   const sendMessage = useCallback(
     async (userMessage) => {
@@ -912,11 +1020,21 @@ function useChat(config, callbacks = {}) {
         currentMessage: void 0
       };
       setMessages((prev) => [...prev, streamingMsg]);
+      const abortController = new AbortController();
+      const { userId } = configRef.current;
+      if (userId) {
+        const initialMessages = [...messagesRef.current, userMsg, streamingMsg];
+        activeStreamStore.start(userId, abortController, initialMessages);
+      }
       const newSessionId = await startStream(
         userMessage,
         streamingId,
-        sessionIdRef.current
+        sessionIdRef.current,
+        abortController
       );
+      if (userId) {
+        activeStreamStore.complete(userId);
+      }
       if (newSessionId && newSessionId !== sessionIdRef.current) {
         sessionIdRef.current = newSessionId;
       }
@@ -924,9 +1042,18 @@ function useChat(config, callbacks = {}) {
     [startStream]
   );
   const clearMessages = useCallback(() => {
+    if (configRef.current.userId) {
+      chatStore.delete(configRef.current.userId);
+    }
     setMessages([]);
   }, []);
+  const prependMessages = useCallback((msgs) => {
+    setMessages((prev) => [...msgs, ...prev]);
+  }, []);
   const cancelStream = useCallback(() => {
+    if (configRef.current.userId) {
+      activeStreamStore.abort(configRef.current.userId);
+    }
     cancelStreamManager();
     setIsWaitingForResponse(false);
     setUserActionState((prev) => ({ ...prev, request: null, result: null }));
@@ -946,6 +1073,10 @@ function useChat(config, callbacks = {}) {
     );
   }, [cancelStreamManager]);
   const resetSession = useCallback(() => {
+    if (configRef.current.userId) {
+      activeStreamStore.abort(configRef.current.userId);
+      chatStore.delete(configRef.current.userId);
+    }
     setMessages([]);
     sessionIdRef.current = void 0;
     abortControllerRef.current?.abort();
@@ -1008,10 +1139,48 @@ function useChat(config, callbacks = {}) {
       throw error;
     }
   }, []);
+  useEffect(() => {
+    const { userId } = config;
+    if (!userId) return;
+    const unsubscribe = activeStreamStore.subscribe(userId, (msgs, isWaiting) => {
+      setMessages(msgs);
+      setIsWaitingForResponse(isWaiting);
+    });
+    const active = activeStreamStore.get(userId);
+    if (active) {
+      setMessages(active.messages);
+      setIsWaitingForResponse(active.isWaiting);
+    }
+    return unsubscribe;
+  }, []);
+  useEffect(() => {
+    if (!config.userId) return;
+    const toSave = messages.filter((m) => !m.isStreaming);
+    if (toSave.length > 0) {
+      chatStore.set(config.userId, toSave);
+    }
+  }, [messages, config.userId]);
+  useEffect(() => {
+    const prevUserId = prevUserIdRef.current;
+    prevUserIdRef.current = config.userId;
+    if (prevUserId === config.userId) return;
+    if (prevUserId && !config.userId) {
+      chatStore.delete(prevUserId);
+      setMessages([]);
+      sessionIdRef.current = void 0;
+      setIsWaitingForResponse(false);
+      setUserActionState({ request: null, result: null, clearOtpTrigger: 0 });
+    } else if (config.userId) {
+      const stored = chatStore.get(config.userId);
+      setMessages(stored);
+      sessionIdRef.current = stored.find((m) => m.sessionId)?.sessionId;
+    }
+  }, [config.userId]);
   return {
     messages,
     sendMessage,
     clearMessages,
+    prependMessages,
     cancelStream,
     resetSession,
     getSessionId,