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

package/dist/index.d.mts

@@ -144,6 +144,8 @@ type ChatConfig = {
     api: APIConfig;
     /** Workflow name */
     workflowName: string;
+    /** User ID for chatStore and activeStreamStore — required for context store messages management. Set to undefined on logout to clear stored messages. */
+    userId?: string;
     /** Workflow version */
     workflowVersion?: number;
     /** Stage/Environment */
@@ -194,6 +196,10 @@ type ChatConfig = {
     isChatDisabled?: boolean;
     /** Custom component to render when chat is disabled. If not provided, default disabled UI will be shown */
     disabledComponent?: React.ReactNode;
+    /** Pre-populate the chat with messages (e.g. loaded conversation history) */
+    initialMessages?: MessageDisplay[];
+    /** Resume an existing session by providing its ID */
+    initialSessionId?: string;
 };
 type ChatCallbacks = {
     /** Called when a message is sent (before API call) */
@@ -222,6 +228,8 @@ type UseChatReturn = {
     messages: MessageDisplay[];
     sendMessage: (userMessage: string) => Promise<void>;
     clearMessages: () => void;
+    /** Prepend older messages to the top of the list (e.g. loaded from history pagination) */
+    prependMessages: (messages: MessageDisplay[]) => void;
     cancelStream: () => void;
     resetSession: () => void;
     getSessionId: () => string | undefined;

package/dist/index.d.ts

@@ -144,6 +144,8 @@ type ChatConfig = {
     api: APIConfig;
     /** Workflow name */
     workflowName: string;
+    /** User ID for chatStore and activeStreamStore — required for context store messages management. Set to undefined on logout to clear stored messages. */
+    userId?: string;
     /** Workflow version */
     workflowVersion?: number;
     /** Stage/Environment */
@@ -194,6 +196,10 @@ type ChatConfig = {
     isChatDisabled?: boolean;
     /** Custom component to render when chat is disabled. If not provided, default disabled UI will be shown */
     disabledComponent?: React.ReactNode;
+    /** Pre-populate the chat with messages (e.g. loaded conversation history) */
+    initialMessages?: MessageDisplay[];
+    /** Resume an existing session by providing its ID */
+    initialSessionId?: string;
 };
 type ChatCallbacks = {
     /** Called when a message is sent (before API call) */
@@ -222,6 +228,8 @@ type UseChatReturn = {
     messages: MessageDisplay[];
     sendMessage: (userMessage: string) => Promise<void>;
     clearMessages: () => void;
+    /** Prepend older messages to the top of the list (e.g. loaded from history pagination) */
+    prependMessages: (messages: MessageDisplay[]) => void;
     cancelStream: () => void;
     resetSession: () => void;
     getSessionId: () => string | undefined;

package/dist/index.js

@@ -209,11 +209,25 @@ function processStreamEvent(event, state) {
     }
     state.activeThinkingText = void 0;
   }
-  if ((eventType === "COMPLETED" || eventType === "WORKFLOW_COMPLETED") && event.response !== void 0) {
-    const content = extractResponseContent(event.response);
+  if (eventType === "COMPLETED" || eventType === "WORKFLOW_COMPLETED") {
+    let content = extractResponseContent(event.response);
+    const trace = event.trace && typeof event.trace === "object" ? event.trace : null;
+    if (!content && trace?.workflowMsg && typeof trace.workflowMsg === "string") {
+      content = trace.workflowMsg;
+    }
+    if (!content && trace?.aggregator && typeof trace.aggregator === "object") {
+      const agg = trace.aggregator;
+      if (typeof agg.response === "string") content = agg.response;
+      else content = extractResponseContent(agg.response);
+    }
     if (content) {
       state.accumulatedContent = content;
-      state.finalData = event.response;
+      state.finalData = event.response ?? event.trace;
+      state.hasError = false;
+      state.errorMessage = "";
+    } else {
+      state.hasError = true;
+      state.errorMessage = "WORKFLOW_FAILED";
     }
   }
   if (eventType === "STARTED" || eventType === "WORKFLOW_STARTED") ; else if (eventType === "COMPLETED" || eventType === "WORKFLOW_COMPLETED") {
@@ -223,7 +237,6 @@ function processStreamEvent(event, state) {
       }
     });
   } else if (eventType === "INTENT_ERROR") {
-    state.hasError = true;
     state.errorMessage = message || event.errorMessage || "An error occurred";
     const intentStep = state.steps.find(
       (s) => s.eventType === "INTENT_STARTED" && s.status === "in_progress"
@@ -453,15 +466,12 @@ function processStreamEvent(event, state) {
 }
 
 // src/utils/messageStateManager.ts
+var FRIENDLY_ERROR_MESSAGE = "Oops, something went wrong. Please try again.";
 function createStreamingMessageUpdate(state) {
   const hasCompletedContent = state.accumulatedContent && state.finalData !== void 0;
   return {
-    streamingContent: state.hasError ? `Oops, something went wrong. Please try again.
-
-${state.errorMessage}` : hasCompletedContent ? state.accumulatedContent : "",
-    content: state.hasError ? `Oops, something went wrong. Please try again.
-
-${state.errorMessage}` : "",
+    streamingContent: state.hasError ? FRIENDLY_ERROR_MESSAGE : hasCompletedContent ? state.accumulatedContent : "",
+    content: state.hasError ? FRIENDLY_ERROR_MESSAGE : "",
     currentMessage: state.hasError ? void 0 : state.currentMessage,
     streamProgress: state.hasError ? "error" : "processing",
     isError: state.hasError,
@@ -484,9 +494,7 @@ function createErrorMessageUpdate(error, state) {
     isError: !isAborted,
     isCancelled: isAborted,
     errorDetails: isAborted ? void 0 : error.message,
-    content: isAborted ? state.accumulatedContent || "" : state.accumulatedContent || `Oops, something went wrong. Please try again.
-
-${error.message}`,
+    content: isAborted ? state.accumulatedContent || "" : state.accumulatedContent || FRIENDLY_ERROR_MESSAGE,
     // Preserve currentMessage when cancelled so UI can show it
     currentMessage: isAborted ? state.currentMessage || "Thinking..." : void 0,
     steps: [...state.steps].map((step) => {
@@ -503,9 +511,7 @@ function createFinalMessage(streamingId, state) {
     id: streamingId,
     sessionId: state.sessionId,
     role: "assistant",
-    content: state.hasError ? `Oops, something went wrong. Please try again.
-
-${state.errorMessage}` : state.accumulatedContent || "",
+    content: state.hasError ? FRIENDLY_ERROR_MESSAGE : state.accumulatedContent || "",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     isStreaming: false,
     streamProgress: state.hasError ? "error" : "completed",
@@ -608,6 +614,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 = react.useRef(null);
   const configRef = react.useRef(config);
@@ -615,9 +699,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: "",
@@ -821,13 +905,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,
@@ -870,8 +984,8 @@ function useChat(config, callbacks = {}) {
   const { startStream, cancelStream: cancelStreamManager, abortControllerRef } = useStreamManager(
     config,
     wrappedCallbacks,
-    setMessages,
-    setIsWaitingForResponse
+    storeAwareSetMessages,
+    storeAwareSetIsWaiting
   );
   const sendMessage = react.useCallback(
     async (userMessage) => {
@@ -908,11 +1022,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;
       }
@@ -920,9 +1044,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 }));
@@ -942,6 +1075,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();
@@ -1004,10 +1141,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,