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

package/dist/index.native.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var react = require('react');
+var reactNativeMmkv = require('react-native-mmkv');
 var expoSpeechRecognition = require('expo-speech-recognition');
 
 // src/hooks/useChat.ts
@@ -187,6 +188,8 @@ function getEventMessage(event) {
       return event.workerName ? `${event.workerName} thinking...` : "Thinking...";
     case "INTENT_THINKING_CONT":
       return event.message || "";
+    case "KEEP_ALIVE":
+      return "";
     default:
       return eventType;
   }
@@ -223,6 +226,9 @@ function completeLastInProgressStep(steps) {
 }
 function processStreamEvent(event, state) {
   const eventType = event.eventType;
+  if (typeof eventType === "string" && eventType.toUpperCase() === "KEEP_ALIVE") {
+    return state;
+  }
   const message = getEventMessage(event);
   if (eventType !== "INTENT_THINKING" && eventType !== "INTENT_THINKING_CONT") {
     if (state.currentThinkingStepId) {
@@ -639,6 +645,88 @@ async function cancelUserAction(config, userActionId) {
 async function resendUserAction(config, userActionId) {
   return sendUserActionRequest(config, userActionId, "resend");
 }
+var storage = reactNativeMmkv.createMMKV({ id: "payman-chat-store" });
+var chatStore = {
+  get(key) {
+    const raw = storage.getString(key);
+    if (!raw) return [];
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  },
+  set(key, messages) {
+    storage.set(key, JSON.stringify(messages));
+  },
+  delete(key) {
+    storage.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 = react.useRef(null);
   const configRef = react.useRef(config);
@@ -646,9 +734,9 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
   const callbacksRef = react.useRef(callbacks);
   callbacksRef.current = callbacks;
   const startStream = react.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: "",
@@ -727,6 +815,11 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
             if (abortController.signal.aborted) {
               return;
             }
+            if (typeof event.eventType === "string" && event.eventType.toUpperCase() === "KEEP_ALIVE") {
+              if (event.executionId) state.executionId = event.executionId;
+              if (event.sessionId) state.currentSessionId = event.sessionId;
+              return;
+            }
             if (event.executionId) state.executionId = event.executionId;
             if (event.sessionId) state.currentSessionId = event.sessionId;
             const activeThinkingLengthBeforeProcess = state.activeThinkingText?.length ?? 0;
@@ -852,13 +945,43 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
 
 // src/hooks/useChat.ts
 function useChat(config, callbacks = {}) {
-  const [messages, setMessages] = react.useState([]);
+  const [messages, setMessages] = react.useState(() => {
+    if (config.userId) return chatStore.get(config.userId);
+    return config.initialMessages ?? [];
+  });
   const [isWaitingForResponse, setIsWaitingForResponse] = react.useState(false);
-  const sessionIdRef = react.useRef(void 0);
+  const sessionIdRef = react.useRef(
+    config.userId ? chatStore.get(config.userId).find((m) => m.sessionId)?.sessionId ?? config.initialSessionId ?? void 0 : config.initialSessionId ?? void 0
+  );
+  const prevUserIdRef = react.useRef(config.userId);
   const callbacksRef = react.useRef(callbacks);
   callbacksRef.current = callbacks;
   const configRef = react.useRef(config);
   configRef.current = config;
+  const messagesRef = react.useRef(messages);
+  messagesRef.current = messages;
+  const storeAwareSetMessages = react.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 = react.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] = react.useState({
     request: null,
     result: null,
@@ -901,8 +1024,8 @@ function useChat(config, callbacks = {}) {
   const { startStream, cancelStream: cancelStreamManager, abortControllerRef } = useStreamManager(
     config,
     wrappedCallbacks,
-    setMessages,
-    setIsWaitingForResponse
+    storeAwareSetMessages,
+    storeAwareSetIsWaiting
   );
   const sendMessage = react.useCallback(
     async (userMessage) => {
@@ -939,11 +1062,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;
       }
@@ -951,9 +1084,18 @@ function useChat(config, callbacks = {}) {
     [startStream]
   );
   const clearMessages = react.useCallback(() => {
+    if (configRef.current.userId) {
+      chatStore.delete(configRef.current.userId);
+    }
     setMessages([]);
   }, []);
+  const prependMessages = react.useCallback((msgs) => {
+    setMessages((prev) => [...msgs, ...prev]);
+  }, []);
   const cancelStream = react.useCallback(() => {
+    if (configRef.current.userId) {
+      activeStreamStore.abort(configRef.current.userId);
+    }
     cancelStreamManager();
     setIsWaitingForResponse(false);
     setUserActionState((prev) => ({ ...prev, request: null, result: null }));
@@ -973,6 +1115,10 @@ function useChat(config, callbacks = {}) {
     );
   }, [cancelStreamManager]);
   const resetSession = react.useCallback(() => {
+    if (configRef.current.userId) {
+      activeStreamStore.abort(configRef.current.userId);
+      chatStore.delete(configRef.current.userId);
+    }
     setMessages([]);
     sessionIdRef.current = void 0;
     abortControllerRef.current?.abort();
@@ -1035,10 +1181,48 @@ function useChat(config, callbacks = {}) {
       throw error;
     }
   }, []);
+  react.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;
+  }, []);
+  react.useEffect(() => {
+    if (!config.userId) return;
+    const toSave = messages.filter((m) => !m.isStreaming);
+    if (toSave.length > 0) {
+      chatStore.set(config.userId, toSave);
+    }
+  }, [messages, config.userId]);
+  react.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,