@paymanai/payman-typescript-ask-sdk 1.0.2 → 1.1.0

package/dist/index.native.js

@@ -137,10 +137,10 @@ async function streamWorkflowEvents(url, body, headers, options = {}) {
 // src/utils/eventProcessor.ts
 function getEventMessage(event) {
   if (event.message?.trim()) {
-    return event.message;
+    return event.message.trim();
   }
   if (event.errorMessage?.trim()) {
-    return event.errorMessage;
+    return event.errorMessage.trim();
   }
   const eventType = event.eventType;
   switch (eventType) {
@@ -168,6 +168,20 @@ function getEventMessage(event) {
     case "WORKFLOW_ERROR":
     case "INTENT_ERROR":
       return event.errorMessage || "An error occurred";
+    case "USER_ACTION_REQUIRED":
+      return "Waiting for verification...";
+    case "USER_ACTION_SUCCESS":
+      return "Verification successful";
+    case "USER_ACTION_EXPIRED":
+      return "Verification expired";
+    case "USER_ACTION_INVALID":
+      return "Invalid input, please try again";
+    case "USER_ACTION_REJECTED":
+      return "Verification rejected";
+    case "USER_ACTION_RESENT":
+      return "Verification code resent";
+    case "USER_ACTION_FAILED":
+      return "Verification failed";
     default:
       return eventType;
   }
@@ -194,6 +208,14 @@ function extractResponseContent(response) {
   }
   return "";
 }
+function completeLastInProgressStep(steps) {
+  for (let i = steps.length - 1; i >= 0; i--) {
+    if (steps[i].status === "in_progress") {
+      steps[i].status = "completed";
+      return;
+    }
+  }
+}
 function processStreamEvent(event, state) {
   const eventType = event.eventType;
   const message = getEventMessage(event);
@@ -293,6 +315,110 @@ function processStreamEvent(event, state) {
       });
       state.currentExecutingStepId = stepId;
     }
+  } else if (eventType === "USER_ACTION_REQUIRED") {
+    completeLastInProgressStep(state.steps);
+    if (event.userActionRequest) {
+      state.userActionRequest = {
+        userActionId: event.userActionRequest.userActionId,
+        message: event.userActionRequest.message,
+        requestedSchema: event.userActionRequest.requestedSchema
+      };
+    }
+    state.userActionPending = true;
+    const stepId = `step-${state.stepCounter++}`;
+    state.steps.push({
+      id: stepId,
+      eventType,
+      message,
+      status: "in_progress",
+      timestamp: Date.now(),
+      elapsedMs: event.elapsedMs
+    });
+    state.currentExecutingStepId = stepId;
+  } else if (eventType === "USER_ACTION_SUCCESS") {
+    completeLastInProgressStep(state.steps);
+    state.userActionRequest = void 0;
+    state.userActionPending = false;
+    state.userActionResult = "approved";
+    const stepId = `step-${state.stepCounter++}`;
+    state.steps.push({
+      id: stepId,
+      eventType,
+      message,
+      status: "completed",
+      timestamp: Date.now(),
+      elapsedMs: event.elapsedMs
+    });
+  } else if (eventType === "USER_ACTION_INVALID") {
+    completeLastInProgressStep(state.steps);
+    const errorStepId = `step-${state.stepCounter++}`;
+    state.steps.push({
+      id: errorStepId,
+      eventType,
+      message,
+      status: "error",
+      timestamp: Date.now(),
+      elapsedMs: event.elapsedMs
+    });
+    const retryStepId = `step-${state.stepCounter++}`;
+    state.steps.push({
+      id: retryStepId,
+      eventType: "USER_ACTION_REQUIRED",
+      message: "Waiting for verification...",
+      status: "in_progress",
+      timestamp: Date.now()
+    });
+    state.currentExecutingStepId = retryStepId;
+  } else if (eventType === "USER_ACTION_EXPIRED") {
+    completeLastInProgressStep(state.steps);
+    state.userActionRequest = void 0;
+    state.userActionPending = false;
+    const stepId = `step-${state.stepCounter++}`;
+    state.steps.push({
+      id: stepId,
+      eventType,
+      message,
+      status: "error",
+      timestamp: Date.now(),
+      elapsedMs: event.elapsedMs
+    });
+  } else if (eventType === "USER_ACTION_REJECTED") {
+    completeLastInProgressStep(state.steps);
+    state.userActionRequest = void 0;
+    state.userActionPending = false;
+    state.userActionResult = "rejected";
+    const stepId = `step-${state.stepCounter++}`;
+    state.steps.push({
+      id: stepId,
+      eventType,
+      message,
+      status: "completed",
+      timestamp: Date.now(),
+      elapsedMs: event.elapsedMs
+    });
+  } else if (eventType === "USER_ACTION_RESENT") {
+    const stepId = `step-${state.stepCounter++}`;
+    state.steps.push({
+      id: stepId,
+      eventType,
+      message,
+      status: "completed",
+      timestamp: Date.now(),
+      elapsedMs: event.elapsedMs
+    });
+  } else if (eventType === "USER_ACTION_FAILED") {
+    completeLastInProgressStep(state.steps);
+    state.userActionRequest = void 0;
+    state.userActionPending = false;
+    const stepId = `step-${state.stepCounter++}`;
+    state.steps.push({
+      id: stepId,
+      eventType,
+      message,
+      status: "error",
+      timestamp: Date.now(),
+      elapsedMs: event.elapsedMs
+    });
   }
   return state;
 }
@@ -314,9 +440,9 @@ ${state.errorMessage}` : "",
     executionId: state.executionId,
     sessionId: state.sessionId,
     steps: state.hasError ? [] : [...state.steps],
-    // Don't show steps on error
     currentExecutingStepId: state.hasError ? void 0 : state.currentExecutingStepId,
-    isCancelled: false
+    isCancelled: false,
+    userActionResult: state.userActionResult
   };
 }
 function createErrorMessageUpdate(error, state) {
@@ -357,9 +483,9 @@ ${state.errorMessage}` : state.accumulatedContent || "",
     executionId: state.executionId,
     tracingData: state.finalData,
     steps: state.hasError ? [] : [...state.steps],
-    // Don't show steps on error
     isCancelled: false,
-    currentExecutingStepId: void 0
+    currentExecutingStepId: void 0,
+    userActionResult: state.userActionResult
   };
 }
 function createCancelledMessageUpdate(steps, currentMessage) {
@@ -405,6 +531,14 @@ function buildStreamingUrl(config) {
   }
   return `${config.api.baseUrl}${endpoint}?${queryParams.toString()}`;
 }
+function buildUserActionUrl(config, userActionId, action) {
+  const endpoint = config.api.streamEndpoint || "/api/workflows/ask/stream";
+  const [endpointPath] = endpoint.split("?");
+  const normalizedEndpointPath = endpointPath.replace(/\/+$/, "");
+  const basePath = normalizedEndpointPath.endsWith("/stream") ? normalizedEndpointPath.slice(0, -"/stream".length) : normalizedEndpointPath;
+  const encodedUserActionId = encodeURIComponent(userActionId);
+  return `${config.api.baseUrl}${basePath}/user-action/${encodedUserActionId}/${action}`;
+}
 function buildRequestHeaders(config) {
   const headers = {
     ...config.api.headers
@@ -414,8 +548,39 @@ function buildRequestHeaders(config) {
   }
   return headers;
 }
+
+// src/utils/userActionClient.ts
+async function sendUserActionRequest(config, userActionId, action, data) {
+  const url = buildUserActionUrl(config, userActionId, action);
+  const baseHeaders = buildRequestHeaders(config);
+  const hasBody = data !== void 0;
+  const headers = hasBody ? { "Content-Type": "application/json", ...baseHeaders } : baseHeaders;
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: hasBody ? JSON.stringify(data) : void 0
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  return await response.json();
+}
+async function submitUserAction(config, userActionId, data) {
+  return sendUserActionRequest(config, userActionId, "submit", data);
+}
+async function cancelUserAction(config, userActionId) {
+  return sendUserActionRequest(config, userActionId, "cancel");
+}
+async function resendUserAction(config, userActionId) {
+  return sendUserActionRequest(config, userActionId, "resend");
+}
 function useStreamManager(config, callbacks, setMessages, setIsWaitingForResponse) {
   const abortControllerRef = react.useRef(null);
+  const configRef = react.useRef(config);
+  configRef.current = config;
+  const callbacksRef = react.useRef(callbacks);
+  callbacksRef.current = callbacks;
   const startStream = react.useCallback(
     async (userMessage, streamingId, sessionId) => {
       abortControllerRef.current?.abort();
@@ -430,11 +595,15 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
         stepCounter: 0,
         currentExecutingStepId: void 0,
         hasError: false,
-        errorMessage: ""
+        errorMessage: "",
+        userActionRequest: void 0,
+        userActionPending: false,
+        userActionResult: void 0
       };
-      const requestBody = buildRequestBody(config, userMessage, sessionId);
-      const url = buildStreamingUrl(config);
-      const headers = buildRequestHeaders(config);
+      const currentConfig = configRef.current;
+      const requestBody = buildRequestBody(currentConfig, userMessage, sessionId);
+      const url = buildStreamingUrl(currentConfig);
+      const headers = buildRequestHeaders(currentConfig);
       try {
         await streamWorkflowEvents(url, requestBody, headers, {
           signal: abortController.signal,
@@ -445,7 +614,15 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
             if (event.executionId) state.executionId = event.executionId;
             if (event.sessionId) state.currentSessionId = event.sessionId;
             processStreamEvent(event, state);
-            const currentMessage = event.message?.trim() || event.errorMessage?.trim();
+            const eventType = event.eventType;
+            if (eventType === "USER_ACTION_REQUIRED" && state.userActionRequest) {
+              callbacksRef.current.onUserActionRequired?.(state.userActionRequest);
+            } else if (eventType.startsWith("USER_ACTION_") && eventType !== "USER_ACTION_REQUIRED") {
+              const msg = event.message?.trim() || event.errorMessage?.trim() || getEventMessage(event);
+              callbacksRef.current.onUserActionEvent?.(eventType, msg);
+            }
+            const rawMessage = event.message?.trim() || event.errorMessage?.trim();
+            const currentMessage = rawMessage || (event.eventType?.startsWith("USER_ACTION_") ? getEventMessage(event) : void 0);
             setMessages(
               (prev) => prev.map(
                 (msg) => msg.id === streamingId ? {
@@ -461,7 +638,7 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
           onError: (error) => {
             setIsWaitingForResponse(false);
             if (error.name !== "AbortError") {
-              callbacks.onError?.(error);
+              callbacksRef.current.onError?.(error);
             }
             setMessages(
               (prev) => prev.map(
@@ -475,7 +652,7 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
           onComplete: () => {
             setIsWaitingForResponse(false);
             if (state.currentSessionId && state.currentSessionId !== sessionId) {
-              callbacks.onSessionIdChange?.(state.currentSessionId);
+              callbacksRef.current.onSessionIdChange?.(state.currentSessionId);
             }
             const finalMessage = createFinalMessage(streamingId, {
               ...state,
@@ -486,14 +663,14 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
                 (msg) => msg.id === streamingId ? finalMessage : msg
               )
             );
-            callbacks.onStreamComplete?.(finalMessage);
+            callbacksRef.current.onStreamComplete?.(finalMessage);
           }
         });
         return state.currentSessionId;
       } catch (error) {
         setIsWaitingForResponse(false);
         if (error.name !== "AbortError") {
-          callbacks.onError?.(error);
+          callbacksRef.current.onError?.(error);
         }
         setMessages(
           (prev) => prev.map(
@@ -506,7 +683,7 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
         return state.currentSessionId;
       }
     },
-    [config, callbacks, setMessages, setIsWaitingForResponse]
+    [setMessages, setIsWaitingForResponse]
   );
   const cancelStream = react.useCallback(() => {
     abortControllerRef.current?.abort();
@@ -523,18 +700,61 @@ function useChat(config, callbacks = {}) {
   const [messages, setMessages] = react.useState([]);
   const [isWaitingForResponse, setIsWaitingForResponse] = react.useState(false);
   const sessionIdRef = react.useRef(void 0);
+  const callbacksRef = react.useRef(callbacks);
+  callbacksRef.current = callbacks;
+  const configRef = react.useRef(config);
+  configRef.current = config;
+  const [userActionState, setUserActionState] = react.useState({
+    request: null,
+    result: null,
+    clearOtpTrigger: 0
+  });
+  const userActionStateRef = react.useRef(userActionState);
+  userActionStateRef.current = userActionState;
+  const wrappedCallbacks = react.useMemo(() => ({
+    ...callbacksRef.current,
+    onMessageSent: (message) => callbacksRef.current.onMessageSent?.(message),
+    onStreamStart: () => callbacksRef.current.onStreamStart?.(),
+    onStreamComplete: (message) => callbacksRef.current.onStreamComplete?.(message),
+    onError: (error) => callbacksRef.current.onError?.(error),
+    onExecutionTraceClick: (data) => callbacksRef.current.onExecutionTraceClick?.(data),
+    onSessionIdChange: (sessionId) => callbacksRef.current.onSessionIdChange?.(sessionId),
+    onUserActionRequired: (request) => {
+      setUserActionState((prev) => ({ ...prev, request, result: null }));
+      callbacksRef.current.onUserActionRequired?.(request);
+    },
+    onUserActionEvent: (eventType, message) => {
+      switch (eventType) {
+        case "USER_ACTION_SUCCESS":
+          setUserActionState((prev) => ({ ...prev, request: null, result: "approved" }));
+          break;
+        case "USER_ACTION_REJECTED":
+          setUserActionState((prev) => ({ ...prev, request: null, result: "rejected" }));
+          break;
+        case "USER_ACTION_EXPIRED":
+        case "USER_ACTION_FAILED":
+          setUserActionState((prev) => ({ ...prev, request: null }));
+          break;
+        case "USER_ACTION_INVALID":
+          setUserActionState((prev) => ({ ...prev, clearOtpTrigger: prev.clearOtpTrigger + 1 }));
+          break;
+      }
+      callbacksRef.current.onUserActionEvent?.(eventType, message);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }), []);
   const { startStream, cancelStream: cancelStreamManager, abortControllerRef } = useStreamManager(
     config,
-    callbacks,
+    wrappedCallbacks,
     setMessages,
     setIsWaitingForResponse
   );
   const sendMessage = react.useCallback(
     async (userMessage) => {
       if (!userMessage.trim()) return;
-      if (!sessionIdRef.current && config.autoGenerateSessionId !== false) {
+      if (!sessionIdRef.current && configRef.current.autoGenerateSessionId !== false) {
         sessionIdRef.current = generateId();
-        callbacks.onSessionIdChange?.(sessionIdRef.current);
+        callbacksRef.current.onSessionIdChange?.(sessionIdRef.current);
       }
       const userMessageId = `user-${Date.now()}`;
       const userMsg = {
@@ -545,9 +765,9 @@ function useChat(config, callbacks = {}) {
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       setMessages((prev) => [...prev, userMsg]);
-      callbacks.onMessageSent?.(userMessage);
+      callbacksRef.current.onMessageSent?.(userMessage);
       setIsWaitingForResponse(true);
-      callbacks.onStreamStart?.();
+      callbacksRef.current.onStreamStart?.();
       const streamingId = `assistant-${Date.now()}`;
       const streamingMsg = {
         id: streamingId,
@@ -573,7 +793,7 @@ function useChat(config, callbacks = {}) {
         sessionIdRef.current = newSessionId;
       }
     },
-    [config, callbacks, startStream, setMessages, setIsWaitingForResponse]
+    [startStream]
   );
   const clearMessages = react.useCallback(() => {
     setMessages([]);
@@ -581,6 +801,7 @@ function useChat(config, callbacks = {}) {
   const cancelStream = react.useCallback(() => {
     cancelStreamManager();
     setIsWaitingForResponse(false);
+    setUserActionState((prev) => ({ ...prev, request: null, result: null }));
     setMessages(
       (prev) => prev.map((msg) => {
         if (msg.isStreaming) {
@@ -601,6 +822,7 @@ function useChat(config, callbacks = {}) {
     sessionIdRef.current = void 0;
     abortControllerRef.current?.abort();
     setIsWaitingForResponse(false);
+    setUserActionState({ request: null, result: null, clearOtpTrigger: 0 });
   }, []);
   const getSessionId = react.useCallback(() => {
     return sessionIdRef.current;
@@ -608,6 +830,56 @@ function useChat(config, callbacks = {}) {
   const getMessages = react.useCallback(() => {
     return messages;
   }, [messages]);
+  const approveUserAction = react.useCallback(
+    async (otp) => {
+      const request = userActionStateRef.current.request;
+      if (!request) return;
+      try {
+        await submitUserAction(configRef.current, request.userActionId, { otp });
+      } catch (error) {
+        setUserActionState((prev) => ({
+          ...prev,
+          clearOtpTrigger: prev.clearOtpTrigger + 1
+        }));
+        callbacksRef.current.onError?.(error);
+        throw error;
+      }
+    },
+    []
+  );
+  const rejectUserAction = react.useCallback(async () => {
+    const request = userActionStateRef.current.request;
+    if (!request) return;
+    try {
+      setMessages((prev) => {
+        let lastStreamingIdx = -1;
+        for (let i = prev.length - 1; i >= 0; i--) {
+          if (prev[i].role === "assistant" && prev[i].isStreaming) {
+            lastStreamingIdx = i;
+            break;
+          }
+        }
+        if (lastStreamingIdx === -1) return prev;
+        return prev.map(
+          (msg, i) => i === lastStreamingIdx ? { ...msg, currentMessage: "Rejecting..." } : msg
+        );
+      });
+      await cancelUserAction(configRef.current, request.userActionId);
+    } catch (error) {
+      callbacksRef.current.onError?.(error);
+      throw error;
+    }
+  }, []);
+  const resendOtp = react.useCallback(async () => {
+    const request = userActionStateRef.current.request;
+    if (!request) return;
+    try {
+      await resendUserAction(configRef.current, request.userActionId);
+    } catch (error) {
+      callbacksRef.current.onError?.(error);
+      throw error;
+    }
+  }, []);
   return {
     messages,
     sendMessage,
@@ -617,12 +889,20 @@ function useChat(config, callbacks = {}) {
     getSessionId,
     getMessages,
     isWaitingForResponse,
-    sessionId: sessionIdRef.current
+    sessionId: sessionIdRef.current,
+    // User action (OTP) state and methods
+    userActionState,
+    approveUserAction,
+    rejectUserAction,
+    resendOtp
   };
 }
 
+exports.cancelUserAction = cancelUserAction;
 exports.generateId = generateId;
+exports.resendUserAction = resendUserAction;
 exports.streamWorkflowEvents = streamWorkflowEvents;
+exports.submitUserAction = submitUserAction;
 exports.useChat = useChat;
 //# sourceMappingURL=index.native.js.map
 //# sourceMappingURL=index.native.js.map