@paymanai/payman-typescript-ask-sdk 1.2.9 → 1.2.11

package/dist/index.mjs

@@ -166,6 +166,14 @@ function getEventMessage(event) {
       return eventType;
   }
 }
+function workingPhaseDetailForDisplay(raw) {
+  const t = raw.trim();
+  if (!t) return "";
+  if (/^Identified\s+\d+\s+tasks?\s+to\s+execute\.?$/i.test(t)) {
+    return "";
+  }
+  return t;
+}
 function extractResponseContent(response) {
   if (typeof response === "string") {
     return response;
@@ -472,8 +480,84 @@ function processStreamEvent(event, state) {
 
 // src/utils/messageStateManager.ts
 var FRIENDLY_ERROR_MESSAGE = "Oops, something went wrong. Please try again.";
+function buildFormattedThinking(steps, allThinkingText) {
+  const parts = [];
+  const safeSteps = steps ?? [];
+  const cleanAll = allThinkingText.replace(/^\s+/, "");
+  if (cleanAll) {
+    const firstStepWithThinking = safeSteps.find(
+      (s) => s.thinkingText && s.thinkingText.trim()
+    );
+    if (!firstStepWithThinking) {
+      parts.push("**Preflight**");
+      parts.push(cleanAll);
+    } else {
+      const stepText = firstStepWithThinking.thinkingText.trim();
+      const idx = cleanAll.indexOf(stepText);
+      if (idx > 0) {
+        const orphaned = cleanAll.substring(0, idx).replace(/\s+$/, "");
+        if (orphaned) {
+          parts.push("**Preflight**");
+          parts.push(orphaned);
+        }
+      }
+    }
+  }
+  for (const step of safeSteps) {
+    switch (step.eventType) {
+      case "ORCHESTRATOR_THINKING":
+        parts.push("**Planning**");
+        if (step.message) parts.push(step.message);
+        break;
+      case "WORKING": {
+        const detail = workingPhaseDetailForDisplay(step.message || "");
+        parts.push("**Working**");
+        if (detail) parts.push(detail);
+        break;
+      }
+      case "INTENT_STARTED": {
+        let label = step.message || "Processing";
+        const started = label.match(/^(.+?)\s+started$/i);
+        const progress = label.match(/^(.+?)\s+in progress$/i);
+        if (started) label = started[1];
+        else if (progress) label = progress[1];
+        parts.push(`**${label}**`);
+        if (step.thinkingText) parts.push(step.thinkingText);
+        break;
+      }
+      case "INTENT_PROGRESS": {
+        if (step.thinkingText) parts.push(step.thinkingText);
+        else if (step.message) parts.push(step.message);
+        break;
+      }
+      case "AGGREGATOR_THINKING":
+        parts.push("**Finalizing**");
+        if (step.message) parts.push(step.message);
+        break;
+      case "USER_ACTION_REQUIRED":
+        parts.push("**Verification Required**");
+        if (step.message) parts.push(step.message);
+        break;
+      case "USER_ACTION_SUCCESS":
+        parts.push(`\u2713 ${step.message || "Verification successful"}`);
+        break;
+      case "USER_ACTION_REJECTED":
+        parts.push(`\u2717 ${step.message || "Verification rejected"}`);
+        break;
+      case "USER_ACTION_EXPIRED":
+        parts.push(`\u2717 ${step.message || "Verification expired"}`);
+        break;
+      case "USER_ACTION_FAILED":
+        parts.push(`\u2717 ${step.message || "Verification failed"}`);
+        break;
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : allThinkingText;
+}
 function createStreamingMessageUpdate(state) {
   const hasCompletedContent = state.accumulatedContent && state.finalData !== void 0;
+  const steps = state.hasError ? [] : [...state.steps];
+  const allThinking = state.hasError ? void 0 : state.allThinkingText;
   return {
     streamingContent: state.hasError ? FRIENDLY_ERROR_MESSAGE : hasCompletedContent ? state.accumulatedContent : "",
     content: state.hasError ? FRIENDLY_ERROR_MESSAGE : "",
@@ -483,12 +567,13 @@ function createStreamingMessageUpdate(state) {
     errorDetails: state.hasError ? state.errorMessage : void 0,
     executionId: state.executionId,
     sessionId: state.sessionId,
-    steps: state.hasError ? [] : [...state.steps],
+    steps,
     currentExecutingStepId: state.hasError ? void 0 : state.currentExecutingStepId,
     isCancelled: false,
     userActionResult: state.userActionResult,
     activeThinkingText: state.hasError ? void 0 : state.activeThinkingText,
-    allThinkingText: state.hasError ? void 0 : state.allThinkingText
+    allThinkingText: allThinking,
+    formattedThinkingText: state.hasError ? void 0 : buildFormattedThinking(steps, allThinking || "")
   };
 }
 function createErrorMessageUpdate(error, state) {
@@ -512,6 +597,8 @@ function createErrorMessageUpdate(error, state) {
   };
 }
 function createFinalMessage(streamingId, state) {
+  const steps = state.hasError ? [] : [...state.steps];
+  const allThinking = state.hasError ? void 0 : state.allThinkingText;
   return {
     id: streamingId,
     sessionId: state.sessionId,
@@ -524,12 +611,13 @@ function createFinalMessage(streamingId, state) {
     errorDetails: state.hasError ? state.errorMessage : void 0,
     executionId: state.executionId,
     tracingData: state.finalData,
-    steps: state.hasError ? [] : [...state.steps],
+    steps,
     isCancelled: false,
     currentExecutingStepId: void 0,
     userActionResult: state.userActionResult,
     activeThinkingText: void 0,
-    allThinkingText: state.hasError ? void 0 : state.allThinkingText,
+    allThinkingText: allThinking,
+    formattedThinkingText: state.hasError ? void 0 : buildFormattedThinking(steps, allThinking || ""),
     isResolvingImages: state.hasError ? void 0 : state.isResolvingImages
   };
 }
@@ -1295,6 +1383,924 @@ function useChat(config, callbacks = {}) {
     resendOtp
   };
 }
+
+// src/utils/v2EventProcessor.ts
+function getEventText(event, field) {
+  const value = event[field];
+  return typeof value === "string" ? value.trim() : "";
+}
+function shouldShowIntentHeader(event) {
+  const workerName = getEventText(event, "workerName");
+  const intentId = getEventText(event, "intentId");
+  return Boolean(workerName && intentId && workerName === intentId);
+}
+function addThinkingHeader(state, header) {
+  state.formattedThinkingText += (state.formattedThinkingText ? "\n" : "") + header;
+}
+function addThinkingDetail(state, detail) {
+  const trimmed = detail.trim();
+  if (!trimmed) return;
+  state.formattedThinkingText += (state.formattedThinkingText ? "\n" : "") + trimmed;
+}
+function addThinkingLine(state, header, detail) {
+  state.formattedThinkingText += (state.formattedThinkingText ? "\n" : "") + header + "\n" + detail;
+}
+function appendThinkingText(state, text) {
+  state.formattedThinkingText += text;
+}
+function completeLastInProgressStep2(steps) {
+  for (let i = steps.length - 1; i >= 0; i--) {
+    if (steps[i].status === "in_progress") {
+      steps[i].status = "completed";
+      return;
+    }
+  }
+}
+function createInitialV2State() {
+  return {
+    formattedThinkingText: "",
+    finalResponse: "",
+    currentWorker: "",
+    lastEventType: "",
+    sessionId: void 0,
+    executionId: void 0,
+    hasError: false,
+    errorMessage: "",
+    userActionRequest: void 0,
+    userActionPending: false,
+    userActionResult: void 0,
+    finalData: void 0,
+    steps: [],
+    stepCounter: 0,
+    currentExecutingStepId: void 0
+  };
+}
+function processStreamEventV2(event, state) {
+  const eventType = event.eventType;
+  if (typeof eventType === "string" && eventType.toUpperCase() === "KEEP_ALIVE") {
+    if (event.executionId) state.executionId = event.executionId;
+    if (event.sessionId) state.sessionId = event.sessionId;
+    return state;
+  }
+  if (event.executionId) state.executionId = event.executionId;
+  if (event.sessionId) state.sessionId = event.sessionId;
+  const message = getEventMessage(event);
+  switch (eventType) {
+    case "WORKFLOW_STARTED":
+    case "STARTED":
+      state.lastEventType = eventType;
+      break;
+    case "INTENT_THINKING": {
+      const worker = getEventText(event, "workerName") || "Worker";
+      const msg = getEventText(event, "message") || "Thinking...";
+      const showHeader = shouldShowIntentHeader(event);
+      if (worker !== state.currentWorker) {
+        state.currentWorker = worker;
+        if (showHeader && msg && msg !== worker) {
+          addThinkingLine(state, `**${worker}**`, msg);
+        } else if (showHeader) {
+          addThinkingHeader(state, `**${worker}**`);
+        } else if (msg !== "Thinking...") {
+          addThinkingDetail(state, msg);
+        }
+      } else if ((showHeader || msg !== "Thinking...")) {
+        appendThinkingText(state, "\n" + msg);
+      }
+      const lastInProgress = [...state.steps].reverse().find((s) => s.status === "in_progress");
+      if (lastInProgress) {
+        lastInProgress.thinkingText = "";
+        lastInProgress.isThinking = true;
+      }
+      state.lastEventType = "INTENT_THINKING";
+      break;
+    }
+    case "INTENT_THINKING_CONT": {
+      const msg = event.message || "";
+      if (!msg) break;
+      if (state.lastEventType === "INTENT_THINKING") {
+        appendThinkingText(state, "\n" + msg);
+      } else {
+        appendThinkingText(state, msg);
+      }
+      const thinkingStep = [...state.steps].reverse().find((s) => s.isThinking);
+      if (thinkingStep) {
+        thinkingStep.thinkingText = (thinkingStep.thinkingText || "") + msg;
+      }
+      state.lastEventType = "INTENT_THINKING_CONT";
+      break;
+    }
+    case "ORCHESTRATOR_THINKING": {
+      addThinkingLine(state, "**Planning**", event.message || "Understanding your request...");
+      const stepId = `step-${state.stepCounter++}`;
+      state.steps.push({
+        id: stepId,
+        eventType,
+        message,
+        status: "in_progress",
+        timestamp: Date.now(),
+        elapsedMs: event.elapsedMs
+      });
+      state.currentExecutingStepId = stepId;
+      state.lastEventType = eventType;
+      break;
+    }
+    case "ORCHESTRATOR_COMPLETED": {
+      const workingDetail = workingPhaseDetailForDisplay(message);
+      if (workingDetail) {
+        addThinkingLine(state, "**Working**", workingDetail);
+      } else {
+        addThinkingHeader(state, "**Working**");
+      }
+      state.steps.push({
+        id: `step-${state.stepCounter++}`,
+        eventType: "WORKING",
+        message: workingDetail,
+        status: "completed",
+        timestamp: Date.now()
+      });
+      const step = state.steps.find((s) => s.eventType === "ORCHESTRATOR_THINKING" && s.status === "in_progress");
+      if (step) {
+        step.status = "completed";
+        if (event.elapsedMs) step.elapsedMs = event.elapsedMs;
+        if (step.id === state.currentExecutingStepId) state.currentExecutingStepId = void 0;
+      }
+      state.lastEventType = eventType;
+      break;
+    }
+    case "INTENT_STARTED": {
+      const worker = getEventText(event, "workerName") || "Worker";
+      const msg = getEventText(event, "message") || "Starting...";
+      const showHeader = shouldShowIntentHeader(event);
+      state.currentWorker = worker;
+      if (showHeader && msg !== worker) {
+        addThinkingLine(state, `**${worker}**`, msg);
+      } else if (showHeader) {
+        addThinkingHeader(state, `**${worker}**`);
+      } else {
+        addThinkingDetail(state, msg);
+      }
+      const thinkingStep = state.steps.find((s) => s.isThinking);
+      if (thinkingStep) thinkingStep.isThinking = false;
+      const stepId = `step-${state.stepCounter++}`;
+      state.steps.push({
+        id: stepId,
+        eventType,
+        message,
+        status: "in_progress",
+        timestamp: Date.now(),
+        elapsedMs: event.elapsedMs
+      });
+      state.currentExecutingStepId = stepId;
+      state.lastEventType = eventType;
+      break;
+    }
+    case "INTENT_COMPLETED": {
+      const intentStep = state.steps.find((s) => s.eventType === "INTENT_STARTED" && s.status === "in_progress");
+      if (intentStep) {
+        intentStep.status = "completed";
+        intentStep.isThinking = false;
+        if (event.elapsedMs) intentStep.elapsedMs = event.elapsedMs;
+        if (intentStep.id === state.currentExecutingStepId) state.currentExecutingStepId = void 0;
+      }
+      state.lastEventType = eventType;
+      break;
+    }
+    case "AGGREGATOR_THINKING": {
+      addThinkingLine(state, "**Finalizing**", event.message || "Preparing response...");
+      const stepId = `step-${state.stepCounter++}`;
+      state.steps.push({
+        id: stepId,
+        eventType,
+        message,
+        status: "in_progress",
+        timestamp: Date.now(),
+        elapsedMs: event.elapsedMs
+      });
+      state.currentExecutingStepId = stepId;
+      state.lastEventType = eventType;
+      break;
+    }
+    case "AGGREGATOR_COMPLETED": {
+      appendThinkingText(state, "\n" + (event.message || "Response ready"));
+      const step = state.steps.find((s) => s.eventType === "AGGREGATOR_THINKING" && s.status === "in_progress");
+      if (step) {
+        step.status = "completed";
+        if (event.elapsedMs) step.elapsedMs = event.elapsedMs;
+        if (step.id === state.currentExecutingStepId) state.currentExecutingStepId = void 0;
+      }
+      state.lastEventType = eventType;
+      break;
+    }
+    case "WORKFLOW_COMPLETED":
+    case "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.finalResponse = content;
+        state.finalData = event.response ?? event.trace;
+        state.hasError = false;
+        state.errorMessage = "";
+      } else {
+        state.hasError = true;
+        state.errorMessage = "WORKFLOW_FAILED";
+      }
+      state.steps.forEach((step) => {
+        if (step.status === "in_progress") {
+          step.status = "completed";
+          step.isThinking = false;
+        }
+      });
+      state.lastEventType = eventType;
+      break;
+    }
+    case "USER_ACTION_REQUIRED": {
+      completeLastInProgressStep2(state.steps);
+      if (event.userActionRequest) {
+        state.userActionRequest = {
+          userActionId: event.userActionRequest.userActionId,
+          userActionType: event.userActionRequest.userActionType,
+          message: event.userActionRequest.message,
+          requestedSchema: event.userActionRequest.requestedSchema,
+          metadata: event.userActionRequest.metadata
+        };
+      }
+      state.userActionPending = true;
+      const req = event.userActionRequest;
+      if (req) {
+        addThinkingLine(state, "**Verification Required**", req.message || "Waiting for authorization...");
+      }
+      const stepId = `step-${state.stepCounter++}`;
+      state.steps.push({
+        id: stepId,
+        eventType,
+        message,
+        status: "in_progress",
+        timestamp: Date.now(),
+        elapsedMs: event.elapsedMs
+      });
+      state.currentExecutingStepId = stepId;
+      state.lastEventType = eventType;
+      break;
+    }
+    case "USER_ACTION_SUCCESS": {
+      appendThinkingText(state, "\n\u2713 " + (event.message || "Verification successful"));
+      completeLastInProgressStep2(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
+      });
+      state.lastEventType = eventType;
+      break;
+    }
+    case "USER_ACTION_INVALID": {
+      completeLastInProgressStep2(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;
+      state.lastEventType = eventType;
+      break;
+    }
+    case "USER_ACTION_REJECTED": {
+      appendThinkingText(state, "\n\u2717 " + (event.message || "Verification rejected"));
+      completeLastInProgressStep2(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
+      });
+      state.lastEventType = eventType;
+      break;
+    }
+    case "USER_ACTION_EXPIRED": {
+      appendThinkingText(state, "\n\u2717 " + (event.message || "Verification expired"));
+      completeLastInProgressStep2(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
+      });
+      state.lastEventType = eventType;
+      break;
+    }
+    case "USER_ACTION_RESENT": {
+      const stepId = `step-${state.stepCounter++}`;
+      state.steps.push({
+        id: stepId,
+        eventType,
+        message,
+        status: "completed",
+        timestamp: Date.now(),
+        elapsedMs: event.elapsedMs
+      });
+      state.lastEventType = eventType;
+      break;
+    }
+    case "USER_ACTION_FAILED": {
+      appendThinkingText(state, "\n\u2717 " + (event.message || "Verification failed"));
+      completeLastInProgressStep2(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
+      });
+      state.lastEventType = eventType;
+      break;
+    }
+    case "WORKFLOW_ERROR":
+    case "ERROR":
+      state.hasError = true;
+      state.errorMessage = event.errorMessage || event.message || "Workflow error";
+      state.lastEventType = eventType;
+      break;
+    case "INTENT_ERROR": {
+      state.errorMessage = message || event.errorMessage || "An error occurred";
+      const intentStep = state.steps.find((s) => s.eventType === "INTENT_STARTED" && s.status === "in_progress");
+      if (intentStep) {
+        intentStep.status = "error";
+        intentStep.isThinking = false;
+      }
+      state.lastEventType = eventType;
+      break;
+    }
+    default:
+      state.lastEventType = eventType;
+      break;
+  }
+  return state;
+}
+
+// src/hooks/useStreamManagerV2.ts
+var FRIENDLY_ERROR_MESSAGE2 = "Oops, something went wrong. Please try again.";
+function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForResponse) {
+  const abortControllerRef = useRef(null);
+  const configRef = useRef(config);
+  configRef.current = config;
+  const callbacksRef = useRef(callbacks);
+  callbacksRef.current = callbacks;
+  const startStream = useCallback(
+    async (userMessage, streamingId, sessionId, externalAbortController) => {
+      abortControllerRef.current?.abort();
+      const abortController = externalAbortController ?? new AbortController();
+      abortControllerRef.current = abortController;
+      const state = createInitialV2State();
+      const updateMessage = (update) => {
+        if (abortController.signal.aborted) return;
+        setMessages(
+          (prev) => prev.map(
+            (msg) => msg.id === streamingId ? { ...msg, ...update } : msg
+          )
+        );
+      };
+      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,
+          onEvent: (event) => {
+            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.sessionId = event.sessionId;
+              return;
+            }
+            processStreamEventV2(event, state);
+            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 activeStep = state.steps.find((s) => s.id === state.currentExecutingStepId);
+            const lastInProgressStep = [...state.steps].reverse().find((s) => s.status === "in_progress");
+            const currentMessage = activeStep?.message || lastInProgressStep?.message || getEventMessage(event);
+            if (state.hasError) {
+              updateMessage({
+                streamingContent: FRIENDLY_ERROR_MESSAGE2,
+                content: FRIENDLY_ERROR_MESSAGE2,
+                streamProgress: "error",
+                isError: true,
+                errorDetails: state.errorMessage,
+                formattedThinkingText: state.formattedThinkingText || void 0,
+                steps: [...state.steps],
+                currentExecutingStepId: void 0,
+                executionId: state.executionId,
+                sessionId: state.sessionId
+              });
+            } else {
+              updateMessage({
+                streamingContent: "",
+                content: "",
+                currentMessage,
+                streamProgress: "processing",
+                isError: false,
+                formattedThinkingText: state.formattedThinkingText || void 0,
+                steps: [...state.steps],
+                currentExecutingStepId: state.currentExecutingStepId,
+                executionId: state.executionId,
+                sessionId: state.sessionId,
+                userActionResult: state.userActionResult,
+                isCancelled: false
+              });
+            }
+          },
+          onError: (error) => {
+            setIsWaitingForResponse(false);
+            if (error.name !== "AbortError") {
+              callbacksRef.current.onError?.(error);
+            }
+            if (state.userActionPending) {
+              state.userActionPending = false;
+              state.userActionRequest = void 0;
+              callbacksRef.current.onUserActionEvent?.(
+                "USER_ACTION_FAILED",
+                "Connection lost. Please try again."
+              );
+            }
+            const isAborted = error.name === "AbortError";
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? {
+                  ...msg,
+                  isStreaming: false,
+                  streamProgress: isAborted ? "processing" : "error",
+                  isError: !isAborted,
+                  isCancelled: isAborted,
+                  errorDetails: isAborted ? void 0 : error.message,
+                  content: isAborted ? state.finalResponse || "" : state.finalResponse || FRIENDLY_ERROR_MESSAGE2,
+                  currentMessage: isAborted ? "Thinking..." : void 0,
+                  formattedThinkingText: state.formattedThinkingText || void 0,
+                  steps: [...state.steps].map((step) => {
+                    if (step.status === "in_progress" && isAborted) {
+                      return { ...step, status: "pending" };
+                    }
+                    return step;
+                  }),
+                  currentExecutingStepId: void 0
+                } : msg
+              )
+            );
+          },
+          onComplete: () => {
+            setIsWaitingForResponse(false);
+            if (state.userActionPending) {
+              state.userActionPending = false;
+              state.userActionRequest = void 0;
+              callbacksRef.current.onUserActionEvent?.(
+                "USER_ACTION_FAILED",
+                "Verification could not be completed."
+              );
+            }
+            if (state.sessionId && state.sessionId !== sessionId) {
+              callbacksRef.current.onSessionIdChange?.(state.sessionId);
+            }
+            const needsImageResolve = !state.hasError && !abortController.signal.aborted && hasRagImages(state.finalResponse);
+            const finalMessage = {
+              id: streamingId,
+              sessionId: state.sessionId || sessionId,
+              role: "assistant",
+              content: state.hasError ? FRIENDLY_ERROR_MESSAGE2 : state.finalResponse || "",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              isStreaming: false,
+              streamProgress: state.hasError ? "error" : "completed",
+              isError: state.hasError,
+              errorDetails: state.hasError ? state.errorMessage : void 0,
+              executionId: state.executionId,
+              tracingData: state.finalData,
+              steps: state.hasError ? [] : [...state.steps],
+              isCancelled: false,
+              currentExecutingStepId: void 0,
+              userActionResult: state.userActionResult,
+              formattedThinkingText: state.hasError ? void 0 : state.formattedThinkingText || void 0,
+              isResolvingImages: needsImageResolve
+            };
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? finalMessage : msg
+              )
+            );
+            callbacksRef.current.onStreamComplete?.(finalMessage);
+          }
+        });
+        const shouldResolveImages = !abortController.signal.aborted && !state.hasError && hasRagImages(state.finalResponse);
+        if (shouldResolveImages) {
+          await waitForNextPaint(abortController.signal);
+        }
+        if (shouldResolveImages && !abortController.signal.aborted) {
+          try {
+            const resolvedContent = await resolveRagImageUrls(
+              currentConfig,
+              state.finalResponse,
+              abortController.signal
+            );
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? { ...msg, content: resolvedContent, isResolvingImages: false } : msg
+              )
+            );
+          } catch {
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? { ...msg, isResolvingImages: false } : msg
+              )
+            );
+          }
+        }
+        return state.sessionId;
+      } catch (error) {
+        setIsWaitingForResponse(false);
+        if (error.name !== "AbortError") {
+          callbacksRef.current.onError?.(error);
+        }
+        if (state.userActionPending) {
+          state.userActionPending = false;
+          state.userActionRequest = void 0;
+          callbacksRef.current.onUserActionEvent?.(
+            "USER_ACTION_FAILED",
+            "Connection lost. Please try again."
+          );
+        }
+        const isAborted = error.name === "AbortError";
+        setMessages(
+          (prev) => prev.map(
+            (msg) => msg.id === streamingId ? {
+              ...msg,
+              isStreaming: false,
+              streamProgress: isAborted ? "processing" : "error",
+              isError: !isAborted,
+              isCancelled: isAborted,
+              errorDetails: isAborted ? void 0 : error.message,
+              content: isAborted ? state.finalResponse || "" : state.finalResponse || FRIENDLY_ERROR_MESSAGE2,
+              formattedThinkingText: state.formattedThinkingText || void 0,
+              steps: [...state.steps].map((step) => {
+                if (step.status === "in_progress" && isAborted) {
+                  return { ...step, status: "pending" };
+                }
+                return step;
+              }),
+              currentExecutingStepId: void 0
+            } : msg
+          )
+        );
+        return state.sessionId;
+      }
+    },
+    [setMessages, setIsWaitingForResponse]
+  );
+  const cancelStream = useCallback(() => {
+    abortControllerRef.current?.abort();
+  }, []);
+  return {
+    startStream,
+    cancelStream,
+    abortControllerRef
+  };
+}
+
+// src/hooks/useChatV2.ts
+function useChatV2(config, callbacks = {}) {
+  const [messages, setMessages] = useState(() => {
+    if (config.userId) return chatStore.get(config.userId);
+    return config.initialMessages ?? [];
+  });
+  const [isWaitingForResponse, setIsWaitingForResponse] = useState(false);
+  const sessionIdRef = useRef(
+    config.userId ? chatStore.get(config.userId).find((m) => m.sessionId)?.sessionId ?? config.initialSessionId ?? void 0 : config.initialSessionId ?? void 0
+  );
+  const prevUserIdRef = useRef(config.userId);
+  const callbacksRef = useRef(callbacks);
+  callbacksRef.current = callbacks;
+  const configRef = useRef(config);
+  configRef.current = config;
+  const messagesRef = useRef(messages);
+  messagesRef.current = messages;
+  const storeAwareSetMessages = 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 = 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] = useState({
+    request: null,
+    result: null,
+    clearOtpTrigger: 0
+  });
+  const userActionStateRef = useRef(userActionState);
+  userActionStateRef.current = userActionState;
+  const wrappedCallbacks = 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 } = useStreamManagerV2(
+    config,
+    wrappedCallbacks,
+    storeAwareSetMessages,
+    storeAwareSetIsWaiting
+  );
+  const sendMessage = useCallback(
+    async (userMessage) => {
+      if (!userMessage.trim()) return;
+      if (!sessionIdRef.current && configRef.current.autoGenerateSessionId !== false) {
+        sessionIdRef.current = generateId();
+        callbacksRef.current.onSessionIdChange?.(sessionIdRef.current);
+      }
+      const userMessageId = `user-${Date.now()}`;
+      const userMsg = {
+        id: userMessageId,
+        sessionId: sessionIdRef.current,
+        role: "user",
+        content: userMessage,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setMessages((prev) => [...prev, userMsg]);
+      callbacksRef.current.onMessageSent?.(userMessage);
+      setIsWaitingForResponse(true);
+      callbacksRef.current.onStreamStart?.();
+      const streamingId = `assistant-${Date.now()}`;
+      const streamingMsg = {
+        id: streamingId,
+        sessionId: sessionIdRef.current,
+        role: "assistant",
+        content: "",
+        streamingContent: "",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        isStreaming: true,
+        streamProgress: "started",
+        steps: [],
+        currentExecutingStepId: void 0,
+        isCancelled: false,
+        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,
+        abortController
+      );
+      if (userId) {
+        activeStreamStore.complete(userId);
+      }
+      if (!abortController.signal.aborted && newSessionId && newSessionId !== sessionIdRef.current) {
+        sessionIdRef.current = newSessionId;
+      }
+    },
+    [startStream]
+  );
+  const clearMessages = useCallback(() => {
+    if (configRef.current.userId) {
+      chatStore.delete(configRef.current.userId);
+    }
+    setMessages([]);
+  }, []);
+  const prependMessages = useCallback((msgs) => {
+    setMessages((prev) => [...msgs, ...prev]);
+  }, []);
+  const cancelStream = useCallback(() => {
+    if (configRef.current.userId) {
+      activeStreamStore.abort(configRef.current.userId);
+    }
+    cancelStreamManager();
+    setIsWaitingForResponse(false);
+    setUserActionState((prev) => ({ ...prev, request: null, result: null }));
+    setMessages(
+      (prev) => prev.map((msg) => {
+        if (msg.isStreaming) {
+          return {
+            ...msg,
+            ...createCancelledMessageUpdate(
+              msg.steps || [],
+              msg.currentMessage
+            )
+          };
+        }
+        return msg;
+      })
+    );
+  }, [cancelStreamManager]);
+  const resetSession = useCallback(() => {
+    if (configRef.current.userId) {
+      activeStreamStore.abort(configRef.current.userId);
+      chatStore.delete(configRef.current.userId);
+    }
+    setMessages([]);
+    sessionIdRef.current = void 0;
+    abortControllerRef.current?.abort();
+    setIsWaitingForResponse(false);
+    setUserActionState({ request: null, result: null, clearOtpTrigger: 0 });
+  }, []);
+  const getSessionId = useCallback(() => {
+    return sessionIdRef.current;
+  }, []);
+  const getMessages = useCallback(() => {
+    return messages;
+  }, [messages]);
+  const approveUserAction = 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 = 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 = 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;
+    }
+  }, []);
+  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;
+  }, []);
+  useEffect(() => {
+    if (!config.userId) return;
+    const toSave = messages.filter((m) => !m.isStreaming);
+    if (toSave.length > 0) {
+      chatStore.set(config.userId, toSave);
+    }
+  }, [messages, config.userId]);
+  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,
+    getMessages,
+    isWaitingForResponse,
+    sessionId: sessionIdRef.current,
+    userActionState,
+    approveUserAction,
+    rejectUserAction,
+    resendOtp
+  };
+}
 function getSpeechRecognition() {
   if (typeof window === "undefined") return null;
   return window.SpeechRecognition || window.webkitSpeechRecognition || null;
@@ -1511,6 +2517,6 @@ function useVoice(config = {}, callbacks = {}) {
   };
 }
 
-export { cancelUserAction, generateId, resendUserAction, streamWorkflowEvents, submitUserAction, useChat, useVoice };
+export { buildFormattedThinking, cancelUserAction, createInitialV2State, generateId, processStreamEventV2, resendUserAction, streamWorkflowEvents, submitUserAction, useChat, useChatV2, useVoice, workingPhaseDetailForDisplay };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map