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

package/dist/index.d.mts

@@ -3,6 +3,17 @@ import React from 'react';
 type MessageRole = "user" | "assistant" | "system";
 type StreamProgress = "started" | "processing" | "completed" | "error";
 type WorkflowStage = "DEV" | "SANDBOX" | "PROD" | "ARCHIVED";
+type UserActionRequest = {
+    userActionId: string;
+    message: string;
+    requestedSchema: Record<string, unknown>;
+};
+type UserActionResult = "approved" | "rejected";
+type UserActionState = {
+    request: UserActionRequest | null;
+    result: UserActionResult | null;
+    clearOtpTrigger: number;
+};
 type StreamingStep = {
     id: string;
     eventType: string;
@@ -36,6 +47,8 @@ type MessageDisplay = {
     steps?: StreamingStep[];
     isCancelled?: boolean;
     currentExecutingStepId?: string;
+    /** Result of user action (OTP approval/rejection) */
+    userActionResult?: UserActionResult;
 };
 type SessionParams = {
     id?: string;
@@ -125,9 +138,13 @@ type ChatCallbacks = {
     }) => void;
     /** Called when session ID changes */
     onSessionIdChange?: (sessionId: string) => void;
+    /** Called when a user action (e.g. OTP) is required */
+    onUserActionRequired?: (request: UserActionRequest) => void;
+    /** Called on user action events (SUCCESS, INVALID, EXPIRED, REJECTED, RESENT, FAILED) */
+    onUserActionEvent?: (eventType: string, message: string) => void;
 };
 
-declare function useChat(config: ChatConfig, callbacks?: ChatCallbacks): {
+type UseChatReturn = {
     messages: MessageDisplay[];
     sendMessage: (userMessage: string) => Promise<void>;
     clearMessages: () => void;
@@ -137,7 +154,16 @@ declare function useChat(config: ChatConfig, callbacks?: ChatCallbacks): {
     getMessages: () => MessageDisplay[];
     isWaitingForResponse: boolean;
     sessionId: string | undefined;
+    /** User action (OTP) state — always present, inert when workflow has no user actions */
+    userActionState: UserActionState;
+    /** Submit OTP for approval */
+    approveUserAction: (otp: string) => Promise<void>;
+    /** Reject / cancel a user action */
+    rejectUserAction: () => Promise<void>;
+    /** Resend OTP code */
+    resendOtp: () => Promise<void>;
 };
+declare function useChat(config: ChatConfig, callbacks?: ChatCallbacks): UseChatReturn;
 
 /**
  * Cross-platform UUID v4 generator
@@ -159,6 +185,11 @@ type StreamEvent = {
     inputTokens?: number;
     outputTokens?: number;
     elapsedMs?: number;
+    userActionRequest?: {
+        userActionId: string;
+        message: string;
+        requestedSchema: Record<string, unknown>;
+    };
     [key: string]: unknown;
 };
 type StreamOptions = {
@@ -172,4 +203,21 @@ type StreamOptions = {
  */
 declare function streamWorkflowEvents(url: string, body: Record<string, unknown>, headers: Record<string, string>, options?: StreamOptions): Promise<void>;
 
-export { type APIConfig, type ChatCallbacks, type ChatConfig, type ChunkDisplay, type MessageDisplay, type MessageRole, type SessionParams, type StreamEvent, type StreamOptions, type StreamProgress, type StreamingStep, type WorkflowStage, generateId, streamWorkflowEvents, useChat };
+type UserActionResponse = {
+    success: boolean;
+    message: string;
+};
+/**
+ * Submit a user action (e.g. OTP verification)
+ */
+declare function submitUserAction(config: ChatConfig, userActionId: string, data?: Record<string, unknown>): Promise<UserActionResponse>;
+/**
+ * Cancel / reject a user action
+ */
+declare function cancelUserAction(config: ChatConfig, userActionId: string): Promise<UserActionResponse>;
+/**
+ * Resend a user action (e.g. request a new OTP)
+ */
+declare function resendUserAction(config: ChatConfig, userActionId: string): Promise<UserActionResponse>;
+
+export { type APIConfig, type ChatCallbacks, type ChatConfig, type ChunkDisplay, type MessageDisplay, type MessageRole, type SessionParams, type StreamEvent, type StreamOptions, type StreamProgress, type StreamingStep, type UseChatReturn, type UserActionRequest, type UserActionResult, type UserActionState, type WorkflowStage, cancelUserAction, generateId, resendUserAction, streamWorkflowEvents, submitUserAction, useChat };

package/dist/index.d.ts

@@ -3,6 +3,17 @@ import React from 'react';
 type MessageRole = "user" | "assistant" | "system";
 type StreamProgress = "started" | "processing" | "completed" | "error";
 type WorkflowStage = "DEV" | "SANDBOX" | "PROD" | "ARCHIVED";
+type UserActionRequest = {
+    userActionId: string;
+    message: string;
+    requestedSchema: Record<string, unknown>;
+};
+type UserActionResult = "approved" | "rejected";
+type UserActionState = {
+    request: UserActionRequest | null;
+    result: UserActionResult | null;
+    clearOtpTrigger: number;
+};
 type StreamingStep = {
     id: string;
     eventType: string;
@@ -36,6 +47,8 @@ type MessageDisplay = {
     steps?: StreamingStep[];
     isCancelled?: boolean;
     currentExecutingStepId?: string;
+    /** Result of user action (OTP approval/rejection) */
+    userActionResult?: UserActionResult;
 };
 type SessionParams = {
     id?: string;
@@ -125,9 +138,13 @@ type ChatCallbacks = {
     }) => void;
     /** Called when session ID changes */
     onSessionIdChange?: (sessionId: string) => void;
+    /** Called when a user action (e.g. OTP) is required */
+    onUserActionRequired?: (request: UserActionRequest) => void;
+    /** Called on user action events (SUCCESS, INVALID, EXPIRED, REJECTED, RESENT, FAILED) */
+    onUserActionEvent?: (eventType: string, message: string) => void;
 };
 
-declare function useChat(config: ChatConfig, callbacks?: ChatCallbacks): {
+type UseChatReturn = {
     messages: MessageDisplay[];
     sendMessage: (userMessage: string) => Promise<void>;
     clearMessages: () => void;
@@ -137,7 +154,16 @@ declare function useChat(config: ChatConfig, callbacks?: ChatCallbacks): {
     getMessages: () => MessageDisplay[];
     isWaitingForResponse: boolean;
     sessionId: string | undefined;
+    /** User action (OTP) state — always present, inert when workflow has no user actions */
+    userActionState: UserActionState;
+    /** Submit OTP for approval */
+    approveUserAction: (otp: string) => Promise<void>;
+    /** Reject / cancel a user action */
+    rejectUserAction: () => Promise<void>;
+    /** Resend OTP code */
+    resendOtp: () => Promise<void>;
 };
+declare function useChat(config: ChatConfig, callbacks?: ChatCallbacks): UseChatReturn;
 
 /**
  * Cross-platform UUID v4 generator
@@ -159,6 +185,11 @@ type StreamEvent = {
     inputTokens?: number;
     outputTokens?: number;
     elapsedMs?: number;
+    userActionRequest?: {
+        userActionId: string;
+        message: string;
+        requestedSchema: Record<string, unknown>;
+    };
     [key: string]: unknown;
 };
 type StreamOptions = {
@@ -172,4 +203,21 @@ type StreamOptions = {
  */
 declare function streamWorkflowEvents(url: string, body: Record<string, unknown>, headers: Record<string, string>, options?: StreamOptions): Promise<void>;
 
-export { type APIConfig, type ChatCallbacks, type ChatConfig, type ChunkDisplay, type MessageDisplay, type MessageRole, type SessionParams, type StreamEvent, type StreamOptions, type StreamProgress, type StreamingStep, type WorkflowStage, generateId, streamWorkflowEvents, useChat };
+type UserActionResponse = {
+    success: boolean;
+    message: string;
+};
+/**
+ * Submit a user action (e.g. OTP verification)
+ */
+declare function submitUserAction(config: ChatConfig, userActionId: string, data?: Record<string, unknown>): Promise<UserActionResponse>;
+/**
+ * Cancel / reject a user action
+ */
+declare function cancelUserAction(config: ChatConfig, userActionId: string): Promise<UserActionResponse>;
+/**
+ * Resend a user action (e.g. request a new OTP)
+ */
+declare function resendUserAction(config: ChatConfig, userActionId: string): Promise<UserActionResponse>;
+
+export { type APIConfig, type ChatCallbacks, type ChatConfig, type ChunkDisplay, type MessageDisplay, type MessageRole, type SessionParams, type StreamEvent, type StreamOptions, type StreamProgress, type StreamingStep, type UseChatReturn, type UserActionRequest, type UserActionResult, type UserActionState, type WorkflowStage, cancelUserAction, generateId, resendUserAction, streamWorkflowEvents, submitUserAction, useChat };

package/dist/index.js

@@ -113,10 +113,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) {
@@ -144,6 +144,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;
   }
@@ -170,6 +184,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);
@@ -269,6 +291,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;
 }
@@ -290,9 +416,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) {
@@ -333,9 +459,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) {
@@ -381,6 +507,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
@@ -390,8 +524,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();
@@ -406,11 +571,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,
@@ -421,7 +590,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 ? {
@@ -437,7 +614,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(
@@ -451,7 +628,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,
@@ -462,14 +639,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(
@@ -482,7 +659,7 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
         return state.currentSessionId;
       }
     },
-    [config, callbacks, setMessages, setIsWaitingForResponse]
+    [setMessages, setIsWaitingForResponse]
   );
   const cancelStream = react.useCallback(() => {
     abortControllerRef.current?.abort();
@@ -499,18 +676,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 = {
@@ -521,9 +741,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,
@@ -549,7 +769,7 @@ function useChat(config, callbacks = {}) {
         sessionIdRef.current = newSessionId;
       }
     },
-    [config, callbacks, startStream, setMessages, setIsWaitingForResponse]
+    [startStream]
   );
   const clearMessages = react.useCallback(() => {
     setMessages([]);
@@ -557,6 +777,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) {
@@ -577,6 +798,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;
@@ -584,6 +806,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,
@@ -593,12 +865,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.js.map
 //# sourceMappingURL=index.js.map