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

package/dist/index.d.mts

@@ -89,6 +89,8 @@ type StreamingStep = {
     status: "in_progress" | "completed" | "error" | "pending";
     timestamp: number;
     elapsedMs?: number;
+    thinkingText?: string;
+    isThinking?: boolean;
 };
 type ChunkDisplay = {
     id?: string;
@@ -117,6 +119,10 @@ type MessageDisplay = {
     currentExecutingStepId?: string;
     /** Result of user action (OTP approval/rejection) */
     userActionResult?: UserActionResult;
+    /** Current thinking block text (live, resets per block) */
+    activeThinkingText?: string;
+    /** All thinking accumulated across blocks (for post-stream display) */
+    allThinkingText?: string;
 };
 type SessionParams = {
     id?: string;

package/dist/index.d.ts

@@ -89,6 +89,8 @@ type StreamingStep = {
     status: "in_progress" | "completed" | "error" | "pending";
     timestamp: number;
     elapsedMs?: number;
+    thinkingText?: string;
+    isThinking?: boolean;
 };
 type ChunkDisplay = {
     id?: string;
@@ -117,6 +119,10 @@ type MessageDisplay = {
     currentExecutingStepId?: string;
     /** Result of user action (OTP approval/rejection) */
     userActionResult?: UserActionResult;
+    /** Current thinking block text (live, resets per block) */
+    activeThinkingText?: string;
+    /** All thinking accumulated across blocks (for post-stream display) */
+    allThinkingText?: string;
 };
 type SessionParams = {
     id?: string;

package/dist/index.js

@@ -158,6 +158,10 @@ function getEventMessage(event) {
       return "Verification code resent";
     case "USER_ACTION_FAILED":
       return "Verification failed";
+    case "INTENT_THINKING":
+      return event.workerName ? `${event.workerName} thinking...` : "Thinking...";
+    case "INTENT_THINKING_CONT":
+      return event.message || "";
     default:
       return eventType;
   }
@@ -195,6 +199,16 @@ function completeLastInProgressStep(steps) {
 function processStreamEvent(event, state) {
   const eventType = event.eventType;
   const message = getEventMessage(event);
+  if (eventType !== "INTENT_THINKING" && eventType !== "INTENT_THINKING_CONT") {
+    if (state.currentThinkingStepId) {
+      const thinkingStep = state.steps.find((s) => s.id === state.currentThinkingStepId);
+      if (thinkingStep) {
+        thinkingStep.isThinking = false;
+      }
+      state.currentThinkingStepId = void 0;
+    }
+    state.activeThinkingText = void 0;
+  }
   if ((eventType === "COMPLETED" || eventType === "WORKFLOW_COMPLETED") && event.response !== void 0) {
     const content = extractResponseContent(event.response);
     if (content) {
@@ -221,6 +235,7 @@ function processStreamEvent(event, state) {
     state.hasError = true;
     state.errorMessage = message || event.errorMessage || "An error occurred";
   } else if (eventType === "ORCHESTRATOR_COMPLETED") {
+    state.inOrchestratorPhase = false;
     const orchestratorStep = state.steps.find(
       (s) => s.eventType === "ORCHESTRATOR_THINKING" && s.status === "in_progress"
     );
@@ -247,6 +262,7 @@ function processStreamEvent(event, state) {
       }
     }
   } else if (eventType === "AGGREGATOR_COMPLETED") {
+    state.inAggregatorPhase = false;
     const aggregatorStep = state.steps.find(
       (s) => s.eventType === "AGGREGATOR_THINKING" && s.status === "in_progress"
     );
@@ -260,6 +276,12 @@ function processStreamEvent(event, state) {
       }
     }
   } else if (eventType === "ORCHESTRATOR_THINKING" || eventType === "INTENT_STARTED" || eventType === "INTENT_PROGRESS" || eventType === "AGGREGATOR_THINKING") {
+    if (eventType === "ORCHESTRATOR_THINKING") {
+      state.inOrchestratorPhase = true;
+    }
+    if (eventType === "AGGREGATOR_THINKING") {
+      state.inAggregatorPhase = true;
+    }
     if (eventType === "INTENT_PROGRESS") {
       const intentStep = state.steps.find(
         (s) => s.eventType === "INTENT_STARTED" && s.status === "in_progress"
@@ -395,6 +417,37 @@ function processStreamEvent(event, state) {
       timestamp: Date.now(),
       elapsedMs: event.elapsedMs
     });
+  } else if (eventType === "INTENT_THINKING") {
+    if (state.currentThinkingStepId) {
+      const prev = state.steps.find((s) => s.id === state.currentThinkingStepId);
+      if (prev) prev.isThinking = false;
+    }
+    const lastInProgress = [...state.steps].reverse().find((s) => s.status === "in_progress");
+    if (lastInProgress) {
+      lastInProgress.thinkingText = "";
+      lastInProgress.isThinking = true;
+      state.currentThinkingStepId = lastInProgress.id;
+    } else {
+      state.currentThinkingStepId = void 0;
+    }
+    if (state.allThinkingText) state.allThinkingText += "\n\n";
+    if (!state.inOrchestratorPhase && !state.inAggregatorPhase) {
+      state.activeThinkingText = "";
+    }
+  } else if (eventType === "INTENT_THINKING_CONT") {
+    const delta = event.message || "";
+    if (!delta) return state;
+    if (state.currentThinkingStepId) {
+      const step = state.steps.find((s) => s.id === state.currentThinkingStepId);
+      if (step) {
+        step.thinkingText = (step.thinkingText || "") + delta;
+      }
+    }
+    state.allThinkingText += delta;
+    if (!state.inOrchestratorPhase && !state.inAggregatorPhase) {
+      if (state.activeThinkingText == null) state.activeThinkingText = "";
+      state.activeThinkingText += delta;
+    }
   }
   return state;
 }
@@ -418,7 +471,9 @@ ${state.errorMessage}` : "",
     steps: state.hasError ? [] : [...state.steps],
     currentExecutingStepId: state.hasError ? void 0 : state.currentExecutingStepId,
     isCancelled: false,
-    userActionResult: state.userActionResult
+    userActionResult: state.userActionResult,
+    activeThinkingText: state.hasError ? void 0 : state.activeThinkingText,
+    allThinkingText: state.hasError ? void 0 : state.allThinkingText
   };
 }
 function createErrorMessageUpdate(error, state) {
@@ -461,7 +516,9 @@ ${state.errorMessage}` : state.accumulatedContent || "",
     steps: state.hasError ? [] : [...state.steps],
     isCancelled: false,
     currentExecutingStepId: void 0,
-    userActionResult: state.userActionResult
+    userActionResult: state.userActionResult,
+    activeThinkingText: void 0,
+    allThinkingText: state.hasError ? void 0 : state.allThinkingText
   };
 }
 function createCancelledMessageUpdate(steps, currentMessage) {
@@ -570,11 +627,63 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
         steps: [],
         stepCounter: 0,
         currentExecutingStepId: void 0,
+        currentThinkingStepId: void 0,
         hasError: false,
         errorMessage: "",
         userActionRequest: void 0,
         userActionPending: false,
-        userActionResult: void 0
+        userActionResult: void 0,
+        allThinkingText: "",
+        inOrchestratorPhase: false,
+        inAggregatorPhase: false
+      };
+      const THROTTLE_MS = 120;
+      const CHARS_PER_TICK = 10;
+      const displayedLengthRef = { current: 0 };
+      let throttleIntervalId = null;
+      const getActiveStepMessage = () => state.steps.find((s) => s.id === state.currentExecutingStepId)?.message || [...state.steps].reverse().find((s) => s.status === "in_progress")?.message;
+      const advanceDisplayLength = (full) => {
+        let newLen = Math.min(displayedLengthRef.current + CHARS_PER_TICK, full.length);
+        if (newLen > 0 && newLen < full.length) {
+          const code = full.charCodeAt(newLen - 1);
+          if (code >= 55296 && code <= 56319) {
+            newLen = Math.min(newLen + 1, full.length);
+          }
+        }
+        displayedLengthRef.current = newLen;
+      };
+      const clearThrottle = () => {
+        if (throttleIntervalId != null) {
+          clearInterval(throttleIntervalId);
+          throttleIntervalId = null;
+        }
+      };
+      abortController.signal.addEventListener("abort", clearThrottle, { once: true });
+      const ensureThrottle = () => {
+        if (throttleIntervalId != null) return;
+        throttleIntervalId = setInterval(() => {
+          if (abortController.signal.aborted) {
+            clearThrottle();
+            return;
+          }
+          const full = state.activeThinkingText ?? "";
+          if (displayedLengthRef.current < full.length) {
+            advanceDisplayLength(full);
+            const displayText = full.slice(0, displayedLengthRef.current);
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? {
+                  ...msg,
+                  ...createStreamingMessageUpdate({
+                    ...state,
+                    activeThinkingText: displayText,
+                    currentMessage: getActiveStepMessage() || "Thinking..."
+                  })
+                } : msg
+              )
+            );
+          }
+        }, THROTTLE_MS);
       };
       const currentConfig = configRef.current;
       const requestBody = buildRequestBody(currentConfig, userMessage, sessionId);
@@ -589,22 +698,33 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
             }
             if (event.executionId) state.executionId = event.executionId;
             if (event.sessionId) state.currentSessionId = event.sessionId;
+            const activeThinkingLengthBeforeProcess = state.activeThinkingText?.length ?? 0;
             processStreamEvent(event, state);
             const eventType = event.eventType;
+            if (eventType === "INTENT_THINKING") {
+              displayedLengthRef.current = 0;
+              ensureThrottle();
+            } else if (eventType !== "INTENT_THINKING_CONT") {
+              displayedLengthRef.current = activeThinkingLengthBeforeProcess;
+              clearThrottle();
+            }
             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 isIntentThinkingEvent = eventType === "INTENT_THINKING" || eventType === "INTENT_THINKING_CONT";
             const rawMessage = event.message?.trim() || event.errorMessage?.trim();
-            const currentMessage = rawMessage || (event.eventType?.startsWith("USER_ACTION_") ? getEventMessage(event) : void 0);
+            const currentMessage = isIntentThinkingEvent ? getActiveStepMessage() || "Thinking..." : rawMessage || (event.eventType?.startsWith("USER_ACTION_") ? getEventMessage(event) : getActiveStepMessage() || getEventMessage(event));
+            const displayThinking = state.activeThinkingText != null ? state.activeThinkingText.slice(0, displayedLengthRef.current) : state.activeThinkingText;
             setMessages(
               (prev) => prev.map(
                 (msg) => msg.id === streamingId ? {
                   ...msg,
                   ...createStreamingMessageUpdate({
                     ...state,
+                    activeThinkingText: displayThinking,
                     currentMessage
                   })
                 } : msg
@@ -612,6 +732,7 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
             );
           },
           onError: (error) => {
+            clearThrottle();
             setIsWaitingForResponse(false);
             if (error.name !== "AbortError") {
               callbacksRef.current.onError?.(error);
@@ -634,6 +755,7 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
             );
           },
           onComplete: () => {
+            clearThrottle();
             setIsWaitingForResponse(false);
             if (state.userActionPending) {
               state.userActionPending = false;
@@ -658,8 +780,10 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
             callbacksRef.current.onStreamComplete?.(finalMessage);
           }
         });
+        clearThrottle();
         return state.currentSessionId;
       } catch (error) {
+        clearThrottle();
         setIsWaitingForResponse(false);
         if (error.name !== "AbortError") {
           callbacksRef.current.onError?.(error);