@paymanai/payman-typescript-ask-sdk 4.0.9 → 4.0.13

package/dist/index.js

@@ -2,7 +2,9 @@
 
 var react = require('react');
 
-// src/hooks/useChatV2.ts
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
 
 // src/utils/generateId.ts
 function generateId() {
@@ -13,10 +15,95 @@ function generateId() {
   });
 }
 
+// src/utils/chatStore.ts
+var memoryStore = /* @__PURE__ */ new Map();
+var chatStore = {
+  get(key) {
+    return memoryStore.get(key) ?? [];
+  },
+  set(key, messages) {
+    memoryStore.set(key, messages);
+  },
+  delete(key) {
+    memoryStore.delete(key);
+  }
+};
+
+// src/utils/activeStreamStore.ts
+var streams = /* @__PURE__ */ new Map();
+var activeStreamStore = {
+  has(key) {
+    return streams.has(key);
+  },
+  get(key) {
+    const entry = streams.get(key);
+    if (!entry) return null;
+    return { messages: entry.messages, isWaiting: entry.isWaiting };
+  },
+  // Called before startStream — registers the controller and initial messages
+  start(key, abortController, initialMessages) {
+    const existing = streams.get(key);
+    streams.set(key, {
+      messages: initialMessages,
+      isWaiting: true,
+      abortController,
+      listeners: existing?.listeners ?? /* @__PURE__ */ new Set()
+    });
+  },
+  // Called by the stream on every event — applies the same updater pattern React uses
+  applyMessages(key, updater) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    const next = typeof updater === "function" ? updater(entry.messages) : updater;
+    entry.messages = next;
+    entry.listeners.forEach((l) => l(next, entry.isWaiting));
+  },
+  setWaiting(key, waiting) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.isWaiting = waiting;
+    entry.listeners.forEach((l) => l(entry.messages, waiting));
+  },
+  // Called when stream completes — persists to chatStore and cleans up
+  complete(key) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.isWaiting = false;
+    entry.listeners.forEach((l) => l(entry.messages, false));
+    const toSave = entry.messages.filter((m) => !m.isStreaming);
+    if (toSave.length > 0) chatStore.set(key, toSave);
+    streams.delete(key);
+  },
+  // Subscribe — returns unsubscribe fn. Component calls this on mount, cleanup on unmount.
+  subscribe(key, listener) {
+    const entry = streams.get(key);
+    if (!entry) return () => {
+    };
+    entry.listeners.add(listener);
+    return () => {
+      streams.get(key)?.listeners.delete(listener);
+    };
+  },
+  // Rename an entry — used when the server assigns a new session ID mid-stream
+  rename(oldKey, newKey) {
+    const entry = streams.get(oldKey);
+    if (!entry) return;
+    streams.set(newKey, entry);
+    streams.delete(oldKey);
+  },
+  // Explicit user cancel — aborts the controller and removes the entry
+  abort(key) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.abortController.abort();
+    streams.delete(key);
+  }
+};
+
 // src/utils/streamingClient.ts
 function yieldAfterProgressEvent(event) {
   const t = event.eventType;
-  if (t === "RUN_IN_PROGRESS" || t === "INTENT_PROGRESS" || t === "AGGREGATOR_THINKING_CONT" || t === "INTENT_THINKING_CONT" || t === "THINKING_DELTA") {
+  if (t === "RUN_IN_PROGRESS" || t === "INTENT_PROGRESS" || t === "THINKING_DELTA") {
     return new Promise((resolve) => setTimeout(resolve, 0));
   }
   return Promise.resolve();
@@ -258,62 +345,28 @@ function normalizeEvent(event) {
       return event;
   }
 }
-function isUserActionPrompt(text) {
-  return /\benter\b.+\b(code|otp)\b/i.test(text) || /\b(authorization|verification)\s+code\b/i.test(text) || /\bsent\s+to\s+your\b/i.test(text);
+function isVerificationSchema(schema) {
+  const props = schema?.properties;
+  if (!props) return false;
+  const keys = Object.keys(props);
+  return keys.length === 1 && keys[0] === "verificationCode";
 }
-function getUserActionDisplayMessage(eventType, rawMessage) {
-  const raw = rawMessage?.trim();
-  const safeRaw = raw && !isUserActionPrompt(raw) ? raw : "";
-  switch (eventType) {
-    case "USER_ACTION_REQUIRED":
-      return raw || "Waiting for verification...";
-    case "USER_ACTION_SUCCESS":
-      return safeRaw || "Verification approved";
-    case "USER_ACTION_INVALID":
-      return safeRaw || "Invalid code. Please try again.";
-    case "USER_ACTION_REJECTED":
-      return safeRaw || "Verification cancelled";
-    case "USER_ACTION_EXPIRED":
-      return safeRaw || "Verification expired";
-    case "USER_ACTION_RESENT":
-      return safeRaw || "Verification code resent";
-    case "USER_ACTION_FAILED":
-      return safeRaw || "Verification failed";
+function classifyUserActionKind(action, schema) {
+  switch ((action || "").toLowerCase()) {
+    case "userverificationrequest":
+      return "verification";
+    case "usernotificationrequest":
+      return "notification";
+    case "userformrequest":
+      return isVerificationSchema(schema) ? "verification" : "form";
     default:
-      return safeRaw || raw || 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 isVerificationSchema(schema) ? "verification" : "form";
   }
-  return t;
 }
 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 updateExecutionStageMessage(state, msg) {
   if (!msg) return;
   for (let i = state.steps.length - 1; i >= 0; i--) {
@@ -334,26 +387,38 @@ function completeLastInProgressStep(steps) {
 }
 function createInitialV2State() {
   return {
-    formattedThinkingText: "",
     finalResponse: "",
-    currentWorker: "",
     lastEventType: "",
     sessionId: void 0,
     executionId: void 0,
     hasError: false,
     errorMessage: "",
-    userActionRequest: void 0,
-    userActionPending: false,
-    userActionResult: void 0,
+    userActions: [],
+    notifications: [],
+    lastUserAction: void 0,
+    lastNotification: void 0,
     finalData: void 0,
     steps: [],
     stepCounter: 0,
     currentExecutingStepId: void 0
   };
 }
+function upsertUserAction(state, req) {
+  const active = { ...req, status: "pending" };
+  const matchIdx = state.userActions.findIndex(
+    (p) => req.toolCallId ? p.toolCallId === req.toolCallId : p.userActionId === req.userActionId
+  );
+  if (matchIdx >= 0) {
+    state.userActions[matchIdx] = active;
+  } else {
+    state.userActions.push(active);
+  }
+}
 function processStreamEventV2(rawEvent, state) {
   const event = normalizeEvent(rawEvent);
   const eventType = event.eventType;
+  state.lastUserAction = void 0;
+  state.lastNotification = void 0;
   if (typeof eventType === "string" && eventType.toUpperCase() === "KEEP_ALIVE") {
     if (event.executionId) state.executionId = event.executionId;
     if (event.sessionId) state.sessionId = event.sessionId;
@@ -369,10 +434,6 @@ function processStreamEventV2(rawEvent, state) {
     return state;
   }
   if (typeof eventType === "string" && eventType.toUpperCase() === "THINKING_DELTA") {
-    const text = typeof event.text === "string" ? event.text : "";
-    if (text) {
-      appendThinkingText(state, text);
-    }
     if (event.executionId) state.executionId = event.executionId;
     if (event.sessionId) state.sessionId = event.sessionId;
     state.lastEventType = "THINKING_DELTA";
@@ -383,7 +444,6 @@ function processStreamEventV2(rawEvent, state) {
   const message = getEventMessage(event);
   switch (eventType) {
     case "WORKFLOW_STARTED":
-    case "STARTED":
       state.lastEventType = eventType;
       break;
     case "INTENT_PROGRESS": {
@@ -396,97 +456,7 @@ function processStreamEventV2(rawEvent, state) {
       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,
@@ -505,55 +475,18 @@ function processStreamEventV2(rawEvent, state) {
       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": {
+    case "WORKFLOW_COMPLETED": {
       const totalTime = Number(event.totalTimeMs);
       if (Number.isFinite(totalTime) && totalTime > 0) {
         state.totalElapsedMs = totalTime;
       }
-      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);
-      }
+      const content = extractResponseContent(event.response);
       if (content) {
         state.finalResponse = content;
         if (event.trace && typeof event.trace === "object") {
@@ -568,178 +501,81 @@ function processStreamEventV2(rawEvent, state) {
       state.steps.forEach((step) => {
         if (step.status === "in_progress") {
           step.status = "completed";
-          step.isThinking = false;
         }
       });
       state.lastEventType = eventType;
       break;
     }
     case "USER_ACTION_REQUIRED": {
-      completeLastInProgressStep(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
+      const rawAction = typeof event.action === "string" ? event.action : void 0;
+      const schema = event.requestedSchema;
+      const kind = classifyUserActionKind(rawAction, schema);
+      const promptMessage = typeof event.message === "string" && event.message.trim() || message || "";
+      const userActionId = typeof event.userActionId === "string" ? event.userActionId : "";
+      if (kind === "notification") {
+        const notification = {
+          id: userActionId || `note-${state.stepCounter++}`,
+          message: promptMessage
         };
+        state.notifications.push(notification);
+        state.lastNotification = notification;
+        state.lastEventType = eventType;
+        break;
       }
-      state.userActionPending = true;
-      const req = event.userActionRequest;
-      const displayMessage = getUserActionDisplayMessage(
-        eventType,
-        req?.message || message
-      );
-      if (req) {
-        addThinkingLine(state, "**Verification Required**", displayMessage);
+      if (!userActionId) {
+        state.lastEventType = eventType;
+        break;
       }
-      const stepId = `step-${state.stepCounter++}`;
-      state.steps.push({
-        id: stepId,
-        eventType,
-        message: displayMessage,
-        status: "in_progress",
-        timestamp: Date.now(),
-        elapsedMs: event.elapsedMs
-      });
-      state.currentExecutingStepId = stepId;
-      state.lastEventType = eventType;
-      break;
-    }
-    case "USER_ACTION_SUCCESS": {
-      const displayMessage = getUserActionDisplayMessage(eventType, event.message);
-      appendThinkingText(state, "\n\u2713 " + displayMessage);
       completeLastInProgressStep(state.steps);
-      state.userActionRequest = void 0;
-      state.userActionPending = false;
-      state.userActionResult = "approved";
+      const verificationType = event.verificationType === "ALPHANUMERIC_CODE" || event.verificationType === "NUMERIC_CODE" ? event.verificationType : void 0;
+      const request = {
+        userActionId,
+        kind,
+        rawAction,
+        subAction: typeof event.subAction === "string" ? event.subAction : void 0,
+        verificationType,
+        expirySeconds: typeof event.expirySeconds === "number" ? event.expirySeconds : void 0,
+        message: promptMessage || void 0,
+        requestedSchema: schema,
+        metadata: event.metadata,
+        toolCallId: typeof event.toolCallId === "string" ? event.toolCallId : void 0,
+        executionId: state.executionId,
+        sessionId: state.sessionId
+      };
+      upsertUserAction(state, request);
+      state.lastUserAction = request;
       const stepId = `step-${state.stepCounter++}`;
       state.steps.push({
         id: stepId,
         eventType,
-        message: displayMessage,
-        status: "completed",
-        timestamp: Date.now(),
-        elapsedMs: event.elapsedMs
-      });
-      state.lastEventType = eventType;
-      break;
-    }
-    case "USER_ACTION_INVALID": {
-      const displayMessage = getUserActionDisplayMessage(eventType, event.message);
-      appendThinkingText(state, "\n\u2717 " + displayMessage);
-      completeLastInProgressStep(state.steps);
-      const errorStepId = `step-${state.stepCounter++}`;
-      state.steps.push({
-        id: errorStepId,
-        eventType,
-        message: displayMessage,
-        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...",
+        message: promptMessage || (kind === "verification" ? "Waiting for verification..." : "Waiting for your input..."),
         status: "in_progress",
-        timestamp: Date.now()
-      });
-      state.currentExecutingStepId = retryStepId;
-      state.lastEventType = eventType;
-      break;
-    }
-    case "USER_ACTION_REJECTED": {
-      const displayMessage = getUserActionDisplayMessage(eventType, event.message);
-      appendThinkingText(state, "\n" + displayMessage);
-      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: displayMessage,
-        status: "completed",
-        timestamp: Date.now(),
-        elapsedMs: event.elapsedMs
-      });
-      state.lastEventType = eventType;
-      break;
-    }
-    case "USER_ACTION_EXPIRED": {
-      const displayMessage = getUserActionDisplayMessage(eventType, event.message);
-      appendThinkingText(state, "\n\u2717 " + displayMessage);
-      completeLastInProgressStep(state.steps);
-      state.userActionRequest = void 0;
-      state.userActionPending = false;
-      const stepId = `step-${state.stepCounter++}`;
-      state.steps.push({
-        id: stepId,
-        eventType,
-        message: displayMessage,
-        status: "error",
-        timestamp: Date.now(),
-        elapsedMs: event.elapsedMs
-      });
-      state.lastEventType = eventType;
-      break;
-    }
-    case "USER_ACTION_RESENT": {
-      const displayMessage = getUserActionDisplayMessage(eventType, event.message);
-      appendThinkingText(state, "\n" + displayMessage);
-      const stepId = `step-${state.stepCounter++}`;
-      state.steps.push({
-        id: stepId,
-        eventType,
-        message: displayMessage,
-        status: "completed",
         timestamp: Date.now(),
         elapsedMs: event.elapsedMs
       });
+      state.currentExecutingStepId = stepId;
       state.lastEventType = eventType;
       break;
     }
-    case "USER_ACTION_FAILED": {
-      const displayMessage = getUserActionDisplayMessage(
-        eventType,
-        event.message || event.errorMessage
-      );
-      appendThinkingText(state, "\n\u2717 " + displayMessage);
-      completeLastInProgressStep(state.steps);
-      state.userActionRequest = void 0;
-      state.userActionPending = false;
-      const stepId = `step-${state.stepCounter++}`;
-      state.steps.push({
-        id: stepId,
-        eventType,
-        message: displayMessage,
-        status: "error",
-        timestamp: Date.now(),
-        elapsedMs: event.elapsedMs
-      });
+    case "USER_NOTIFICATION": {
+      const noteMessage = typeof event.message === "string" && event.message.trim() || message || "";
+      const userActionId = typeof event.userActionId === "string" ? event.userActionId : "";
+      if (noteMessage || userActionId) {
+        const notification = {
+          id: userActionId || `note-${state.stepCounter++}`,
+          message: noteMessage
+        };
+        state.notifications.push(notification);
+        state.lastNotification = notification;
+      }
       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;
-    }
     // ---- K2 pipeline stage lifecycle events ----
     //
     // The k2-server playground streaming API emits
@@ -860,96 +696,6 @@ function processStreamEventV2(rawEvent, state) {
   return state;
 }
 
-// src/utils/messageStateManager.ts
-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 "STAGE_STARTED": {
-        if (step.message) parts.push(`**${step.message}**`);
-        break;
-      }
-      case "ORCHESTRATOR_THINKING":
-        parts.push("**Planning**");
-        if (step.message) parts.push(step.message);
-        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 createCancelledMessageUpdate(steps, currentMessage) {
-  const updatedSteps = steps.map((step) => {
-    if (step.status === "in_progress") {
-      return { ...step, status: "pending" };
-    }
-    return step;
-  });
-  return {
-    isStreaming: false,
-    isCancelled: true,
-    steps: updatedSteps,
-    currentExecutingStepId: void 0,
-    // Preserve currentMessage so UI can show it with X icon
-    currentMessage: currentMessage || "Thinking..."
-  };
-}
-
 // src/utils/requestBuilder.ts
 var DEFAULT_STREAM_ENDPOINT = "/api/playground/ask/stream";
 function buildRequestBody(config, userMessage, sessionId, options) {
@@ -1023,111 +769,6 @@ 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");
-}
-
-// src/utils/chatStore.ts
-var memoryStore = /* @__PURE__ */ new Map();
-var chatStore = {
-  get(key) {
-    return memoryStore.get(key) ?? [];
-  },
-  set(key, messages) {
-    memoryStore.set(key, messages);
-  },
-  delete(key) {
-    memoryStore.delete(key);
-  }
-};
-
-// src/utils/activeStreamStore.ts
-var streams = /* @__PURE__ */ new Map();
-var activeStreamStore = {
-  has(key) {
-    return streams.has(key);
-  },
-  get(key) {
-    const entry = streams.get(key);
-    if (!entry) return null;
-    return { messages: entry.messages, isWaiting: entry.isWaiting };
-  },
-  // Called before startStream — registers the controller and initial messages
-  start(key, abortController, initialMessages) {
-    const existing = streams.get(key);
-    streams.set(key, {
-      messages: initialMessages,
-      isWaiting: true,
-      abortController,
-      listeners: existing?.listeners ?? /* @__PURE__ */ new Set()
-    });
-  },
-  // Called by the stream on every event — applies the same updater pattern React uses
-  applyMessages(key, updater) {
-    const entry = streams.get(key);
-    if (!entry) return;
-    const next = typeof updater === "function" ? updater(entry.messages) : updater;
-    entry.messages = next;
-    entry.listeners.forEach((l) => l(next, entry.isWaiting));
-  },
-  setWaiting(key, waiting) {
-    const entry = streams.get(key);
-    if (!entry) return;
-    entry.isWaiting = waiting;
-    entry.listeners.forEach((l) => l(entry.messages, waiting));
-  },
-  // Called when stream completes — persists to chatStore and cleans up
-  complete(key) {
-    const entry = streams.get(key);
-    if (!entry) return;
-    entry.isWaiting = false;
-    entry.listeners.forEach((l) => l(entry.messages, false));
-    const toSave = entry.messages.filter((m) => !m.isStreaming);
-    if (toSave.length > 0) chatStore.set(key, toSave);
-    streams.delete(key);
-  },
-  // Subscribe — returns unsubscribe fn. Component calls this on mount, cleanup on unmount.
-  subscribe(key, listener) {
-    const entry = streams.get(key);
-    if (!entry) return () => {
-    };
-    entry.listeners.add(listener);
-    return () => {
-      streams.get(key)?.listeners.delete(listener);
-    };
-  },
-  // Explicit user cancel — aborts the controller and removes the entry
-  abort(key) {
-    const entry = streams.get(key);
-    if (!entry) return;
-    entry.abortController.abort();
-    streams.delete(key);
-  }
-};
-
 // src/utils/ragImageResolver.ts
 var RAG_IMAGE_REGEX = /\/api\/rag\/chunks\/[^"'\s]+\/image/;
 function hasRagImages(content) {
@@ -1215,15 +856,11 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
           onEvent: (event) => {
             if (abortController.signal.aborted) return;
             processStreamEventV2(event, state);
-            const eventType = event.eventType;
-            if (eventType === "USER_ACTION_REQUIRED" && state.userActionRequest) {
-              callbacksRef.current.onUserActionRequired?.(state.userActionRequest);
-            } else if (typeof eventType === "string" && eventType.startsWith("USER_ACTION_") && eventType !== "USER_ACTION_REQUIRED") {
-              const msg = getUserActionDisplayMessage(
-                eventType,
-                event.message?.trim() || event.errorMessage?.trim() || getEventMessage(event)
-              );
-              callbacksRef.current.onUserActionEvent?.(eventType, msg);
+            if (state.lastUserAction) {
+              callbacksRef.current.onUserActionRequired?.(state.lastUserAction);
+            }
+            if (state.lastNotification) {
+              callbacksRef.current.onUserNotification?.(state.lastNotification);
             }
             const activeStep = state.steps.find((s) => s.id === state.currentExecutingStepId);
             const lastInProgressStep = [...state.steps].reverse().find((s) => s.status === "in_progress");
@@ -1246,7 +883,6 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
                 streamProgress: "error",
                 isError: true,
                 errorDetails: state.errorMessage,
-                formattedThinkingText: state.formattedThinkingText || void 0,
                 steps: [...state.steps],
                 currentExecutingStepId: void 0,
                 executionId: state.executionId,
@@ -1259,12 +895,10 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
                 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
               });
             }
@@ -1275,14 +909,6 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
             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(
@@ -1295,7 +921,6 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
                   errorDetails: isAborted ? void 0 : error.message,
                   content: isAborted ? state.finalResponse || "" : state.finalResponse || FRIENDLY_ERROR_MESSAGE,
                   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" };
@@ -1311,14 +936,6 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
             setIsWaitingForResponse(false);
             callbacksRef.current.onStatusMessage?.(null);
             callbacksRef.current.onStepsUpdate?.([]);
-            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);
             }
@@ -1342,8 +959,6 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
               steps: state.hasError ? [] : [...state.steps],
               isCancelled: false,
               currentExecutingStepId: void 0,
-              userActionResult: state.userActionResult,
-              formattedThinkingText: state.hasError ? void 0 : state.formattedThinkingText || void 0,
               isResolvingImages: needsImageResolve,
               totalElapsedMs: state.hasError ? void 0 : state.totalElapsedMs
             };
@@ -1385,14 +1000,6 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
         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(
@@ -1404,7 +1011,6 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
               isCancelled: isAborted,
               errorDetails: isAborted ? void 0 : error.message,
               content: isAborted ? state.finalResponse || "" : state.finalResponse || FRIENDLY_ERROR_MESSAGE,
-              formattedThinkingText: state.formattedThinkingText || void 0,
               steps: [...state.steps].map((step) => {
                 if (step.status === "in_progress" && isAborted) {
                   return { ...step, status: "pending" };
@@ -1430,9 +1036,79 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
   };
 }
 
+// src/utils/messageStateManager.ts
+function createCancelledMessageUpdate(steps, currentMessage) {
+  const updatedSteps = steps.map((step) => {
+    if (step.status === "in_progress") {
+      return { ...step, status: "pending" };
+    }
+    return step;
+  });
+  return {
+    isStreaming: false,
+    isCancelled: true,
+    steps: updatedSteps,
+    currentExecutingStepId: void 0,
+    currentMessage: currentMessage || "Thinking..."
+  };
+}
+
+// src/utils/userActionClient.ts
+var UserActionStaleError = class extends Error {
+  constructor(userActionId, message = "User action is no longer actionable") {
+    super(message);
+    __publicField(this, "userActionId");
+    this.name = "UserActionStaleError";
+    this.userActionId = userActionId;
+  }
+};
+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.status === 404) {
+    throw new UserActionStaleError(userActionId);
+  }
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  return await response.json();
+}
+async function submitUserAction(config, userActionId, content) {
+  return sendUserActionRequest(config, userActionId, "submit", content ?? {});
+}
+async function cancelUserAction(config, userActionId) {
+  return sendUserActionRequest(config, userActionId, "cancel");
+}
+async function resendUserAction(config, userActionId) {
+  return sendUserActionRequest(config, userActionId, "resend");
+}
+
 // src/hooks/useChatV2.ts
+var EMPTY_USER_ACTION_STATE = { prompts: [], notifications: [] };
+function upsertPrompt(prompts, req) {
+  const active = { ...req, status: "pending" };
+  const idx = prompts.findIndex(
+    (p) => req.toolCallId ? p.toolCallId === req.toolCallId : p.userActionId === req.userActionId
+  );
+  if (idx >= 0) {
+    const next = prompts.slice();
+    next[idx] = active;
+    return next;
+  }
+  return [...prompts, active];
+}
 function getStoredOrInitialMessages(config) {
   if (!config.userId) return config.initialMessages ?? [];
+  const activeStream = activeStreamStore.get(config.userId);
+  if (activeStream) return activeStream.messages;
   const stored = chatStore.get(config.userId);
   if (stored.length > 0) return stored;
   if (config.initialMessages?.length) {
@@ -1446,11 +1122,16 @@ function getSessionIdFromMessages(messages) {
 }
 function useChatV2(config, callbacks = {}) {
   const [messages, setMessages] = react.useState(() => getStoredOrInitialMessages(config));
-  const [isWaitingForResponse, setIsWaitingForResponse] = react.useState(false);
+  const [isWaitingForResponse, setIsWaitingForResponse] = react.useState(() => {
+    if (!config.userId) return false;
+    return activeStreamStore.get(config.userId)?.isWaiting ?? false;
+  });
   const sessionIdRef = react.useRef(
     getSessionIdFromMessages(getStoredOrInitialMessages(config)) ?? config.initialSessionId ?? void 0
   );
   const prevUserIdRef = react.useRef(config.userId);
+  const streamUserIdRef = react.useRef(void 0);
+  const subscriptionPrevUserIdRef = react.useRef(config.userId);
   const callbacksRef = react.useRef(callbacks);
   callbacksRef.current = callbacks;
   const configRef = react.useRef(config);
@@ -1459,33 +1140,35 @@ function useChatV2(config, callbacks = {}) {
   messagesRef.current = messages;
   const storeAwareSetMessages = react.useCallback(
     (updater) => {
-      const { userId } = configRef.current;
-      if (userId && activeStreamStore.has(userId)) {
-        activeStreamStore.applyMessages(userId, updater);
+      const streamUserId = streamUserIdRef.current;
+      const currentUserId = configRef.current.userId;
+      const storeKey = streamUserId ?? currentUserId;
+      if (storeKey && activeStreamStore.has(storeKey)) {
+        activeStreamStore.applyMessages(storeKey, updater);
+      }
+      if (!streamUserId || streamUserId === currentUserId) {
+        setMessages(updater);
       }
-      setMessages(updater);
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
     []
   );
   const storeAwareSetIsWaiting = react.useCallback(
     (waiting) => {
-      const { userId } = configRef.current;
-      if (userId && activeStreamStore.has(userId)) {
-        activeStreamStore.setWaiting(userId, waiting);
+      const streamUserId = streamUserIdRef.current;
+      const currentUserId = configRef.current.userId;
+      const storeKey = streamUserId ?? currentUserId;
+      if (storeKey && activeStreamStore.has(storeKey)) {
+        activeStreamStore.setWaiting(storeKey, waiting);
+      }
+      if (!streamUserId || streamUserId === currentUserId) {
+        setIsWaitingForResponse(waiting);
       }
-      setIsWaitingForResponse(waiting);
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
     []
   );
-  const [userActionState, setUserActionState] = react.useState({
-    request: null,
-    result: null,
-    clearOtpTrigger: 0
-  });
-  const userActionStateRef = react.useRef(userActionState);
-  userActionStateRef.current = userActionState;
+  const [userActionState, setUserActionState] = react.useState(EMPTY_USER_ACTION_STATE);
   const wrappedCallbacks = react.useMemo(() => ({
     ...callbacksRef.current,
     onMessageSent: (message) => callbacksRef.current.onMessageSent?.(message),
@@ -1495,26 +1178,17 @@ function useChatV2(config, callbacks = {}) {
     onExecutionTraceClick: (data) => callbacksRef.current.onExecutionTraceClick?.(data),
     onSessionIdChange: (sessionId) => callbacksRef.current.onSessionIdChange?.(sessionId),
     onUserActionRequired: (request) => {
-      setUserActionState((prev) => ({ ...prev, request, result: null }));
+      setUserActionState((prev) => ({
+        ...prev,
+        prompts: upsertPrompt(prev.prompts, request)
+      }));
       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);
+    onUserNotification: (notification) => {
+      setUserActionState(
+        (prev) => prev.notifications.some((n) => n.id === notification.id) ? prev : { ...prev, notifications: [...prev.notifications, notification] }
+      );
+      callbacksRef.current.onUserNotification?.(notification);
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }), []);
@@ -1562,6 +1236,7 @@ function useChatV2(config, callbacks = {}) {
       const abortController = new AbortController();
       const { userId } = configRef.current;
       if (userId) {
+        streamUserIdRef.current = userId;
         const initialMessages = [...messagesRef.current, userMsg, streamingMsg];
         activeStreamStore.start(userId, abortController, initialMessages);
       }
@@ -1572,9 +1247,11 @@ function useChatV2(config, callbacks = {}) {
         abortController,
         options
       );
-      if (userId) {
-        activeStreamStore.complete(userId);
+      const finalStreamUserId = streamUserIdRef.current ?? userId;
+      if (finalStreamUserId) {
+        activeStreamStore.complete(finalStreamUserId);
       }
+      streamUserIdRef.current = void 0;
       if (!abortController.signal.aborted && newSessionId && newSessionId !== sessionIdRef.current) {
         sessionIdRef.current = newSessionId;
       }
@@ -1591,12 +1268,14 @@ function useChatV2(config, callbacks = {}) {
     setMessages((prev) => [...msgs, ...prev]);
   }, []);
   const cancelStream = react.useCallback(() => {
-    if (configRef.current.userId) {
-      activeStreamStore.abort(configRef.current.userId);
+    const streamUserId = streamUserIdRef.current ?? configRef.current.userId;
+    if (streamUserId) {
+      activeStreamStore.abort(streamUserId);
     }
+    streamUserIdRef.current = void 0;
     cancelStreamManager();
     setIsWaitingForResponse(false);
-    setUserActionState((prev) => ({ ...prev, request: null, result: null }));
+    setUserActionState((prev) => ({ ...prev, prompts: [] }));
     setMessages(
       (prev) => prev.map((msg) => {
         if (msg.isStreaming) {
@@ -1613,15 +1292,19 @@ function useChatV2(config, callbacks = {}) {
     );
   }, [cancelStreamManager]);
   const resetSession = react.useCallback(() => {
+    const streamUserId = streamUserIdRef.current ?? configRef.current.userId;
+    if (streamUserId) {
+      activeStreamStore.abort(streamUserId);
+    }
     if (configRef.current.userId) {
-      activeStreamStore.abort(configRef.current.userId);
       chatStore.delete(configRef.current.userId);
     }
+    streamUserIdRef.current = void 0;
     setMessages([]);
     sessionIdRef.current = void 0;
     abortControllerRef.current?.abort();
     setIsWaitingForResponse(false);
-    setUserActionState({ request: null, result: null, clearOtpTrigger: 0 });
+    setUserActionState(EMPTY_USER_ACTION_STATE);
   }, []);
   const getSessionId = react.useCallback(() => {
     return sessionIdRef.current;
@@ -1629,59 +1312,91 @@ function useChatV2(config, callbacks = {}) {
   const getMessages = react.useCallback(() => {
     return messages;
   }, [messages]);
-  const approveUserAction = react.useCallback(
-    async (otp) => {
-      const request = userActionStateRef.current.request;
-      if (!request) return;
+  const setPromptStatus = react.useCallback(
+    (userActionId, status) => {
+      setUserActionState((prev) => ({
+        ...prev,
+        prompts: prev.prompts.map(
+          (p) => p.userActionId === userActionId ? { ...p, status } : p
+        )
+      }));
+    },
+    []
+  );
+  const removePrompt = react.useCallback((userActionId) => {
+    setUserActionState((prev) => ({
+      ...prev,
+      prompts: prev.prompts.filter((p) => p.userActionId !== userActionId)
+    }));
+  }, []);
+  const submitUserAction2 = react.useCallback(
+    async (userActionId, content) => {
+      setPromptStatus(userActionId, "submitting");
       try {
-        await submitUserAction(configRef.current, request.userActionId, { otp });
+        await submitUserAction(configRef.current, userActionId, content);
+        removePrompt(userActionId);
       } catch (error) {
-        setUserActionState((prev) => ({
-          ...prev,
-          clearOtpTrigger: prev.clearOtpTrigger + 1
-        }));
+        if (error instanceof UserActionStaleError) {
+          setPromptStatus(userActionId, "stale");
+          return;
+        }
+        setPromptStatus(userActionId, "pending");
         callbacksRef.current.onError?.(error);
         throw error;
       }
     },
-    []
+    [removePrompt, setPromptStatus]
   );
-  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;
-          }
+  const cancelUserAction2 = react.useCallback(
+    async (userActionId) => {
+      setPromptStatus(userActionId, "submitting");
+      try {
+        await cancelUserAction(configRef.current, userActionId);
+        removePrompt(userActionId);
+      } catch (error) {
+        if (error instanceof UserActionStaleError) {
+          removePrompt(userActionId);
+          return;
         }
-        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;
-    }
+        setPromptStatus(userActionId, "pending");
+        callbacksRef.current.onError?.(error);
+        throw error;
+      }
+    },
+    [removePrompt, setPromptStatus]
+  );
+  const resendUserAction2 = react.useCallback(
+    async (userActionId) => {
+      setPromptStatus(userActionId, "submitting");
+      try {
+        await resendUserAction(configRef.current, userActionId);
+        setPromptStatus(userActionId, "pending");
+      } catch (error) {
+        if (error instanceof UserActionStaleError) {
+          setPromptStatus(userActionId, "stale");
+          return;
+        }
+        setPromptStatus(userActionId, "pending");
+        callbacksRef.current.onError?.(error);
+        throw error;
+      }
+    },
+    [setPromptStatus]
+  );
+  const dismissNotification = react.useCallback((id) => {
+    setUserActionState((prev) => ({
+      ...prev,
+      notifications: prev.notifications.filter((n) => n.id !== id)
+    }));
   }, []);
   react.useEffect(() => {
+    const prevSubscriptionUserId = subscriptionPrevUserIdRef.current;
+    subscriptionPrevUserIdRef.current = config.userId;
     const { userId } = config;
     if (!userId) return;
+    if (prevSubscriptionUserId && prevSubscriptionUserId !== userId && streamUserIdRef.current === prevSubscriptionUserId && !activeStreamStore.has(prevSubscriptionUserId) && activeStreamStore.has(userId)) {
+      streamUserIdRef.current = userId;
+    }
     const unsubscribe = activeStreamStore.subscribe(userId, (msgs, isWaiting) => {
       setMessages(msgs);
       setIsWaitingForResponse(isWaiting);
@@ -1695,6 +1410,7 @@ function useChatV2(config, callbacks = {}) {
   }, [config.userId]);
   react.useEffect(() => {
     if (!config.userId) return;
+    if (prevUserIdRef.current !== config.userId) return;
     const toSave = messages.filter((m) => !m.isStreaming);
     if (toSave.length > 0) {
       chatStore.set(config.userId, toSave);
@@ -1716,7 +1432,7 @@ function useChatV2(config, callbacks = {}) {
       setMessages([]);
       sessionIdRef.current = void 0;
       setIsWaitingForResponse(false);
-      setUserActionState({ request: null, result: null, clearOtpTrigger: 0 });
+      setUserActionState(EMPTY_USER_ACTION_STATE);
     } else if (config.userId) {
       const active = activeStreamStore.get(config.userId);
       if (active) {
@@ -1743,9 +1459,10 @@ function useChatV2(config, callbacks = {}) {
     isWaitingForResponse,
     sessionId: sessionIdRef.current,
     userActionState,
-    approveUserAction,
-    rejectUserAction,
-    resendOtp
+    submitUserAction: submitUserAction2,
+    cancelUserAction: cancelUserAction2,
+    resendUserAction: resendUserAction2,
+    dismissNotification
   };
 }
 function getSpeechRecognition() {
@@ -1964,15 +1681,150 @@ function useVoice(config = {}, callbacks = {}) {
   };
 }
 
-exports.buildFormattedThinking = buildFormattedThinking;
+// src/utils/jsonSchemaForm.ts
+function classifyField(field) {
+  if (!field) return "text";
+  if (Array.isArray(field.oneOf) && field.oneOf.length > 0) return "select";
+  switch (field.type) {
+    case "boolean":
+      return "boolean";
+    case "integer":
+      return "integer";
+    case "number":
+      return "decimal";
+    case "string":
+      return "text";
+    default:
+      return "text";
+  }
+}
+function isNestedOrUnsupported(field) {
+  if (!field) return false;
+  if (field.type === "object" || field.type === "array") return true;
+  if ("properties" in field && field.properties != null) return true;
+  if ("items" in field && field.items != null) return true;
+  return false;
+}
+function getOptions(field) {
+  if (!field || !Array.isArray(field.oneOf)) return [];
+  return field.oneOf.filter(
+    (o) => !!o && typeof o === "object" && typeof o.const === "string"
+  );
+}
+function isRequired(schema, key) {
+  return Array.isArray(schema?.required) && schema.required.includes(key);
+}
+function coerceValue(field, raw) {
+  const widget = classifyField(field);
+  if (widget === "boolean") {
+    if (typeof raw === "boolean") return raw;
+    if (raw === "true") return true;
+    if (raw === "false") return false;
+    return Boolean(raw);
+  }
+  if (widget === "integer" || widget === "decimal") {
+    if (raw === "" || raw == null) return void 0;
+    const num = typeof raw === "number" ? raw : Number(String(raw).trim());
+    if (Number.isNaN(num)) return void 0;
+    return widget === "integer" ? Math.trunc(num) : num;
+  }
+  if (raw == null) return void 0;
+  const str = String(raw);
+  return str === "" ? void 0 : str;
+}
+function defaultValueFor(field) {
+  if (!field || field.default === void 0) {
+    return classifyField(field) === "boolean" ? false : "";
+  }
+  return field.default;
+}
+function validateField(field, value, required) {
+  const widget = classifyField(field);
+  const label = field?.title || "This field";
+  const isEmpty = value === void 0 || value === null || typeof value === "string" && value.trim() === "";
+  if (isEmpty) {
+    if (required && widget !== "boolean") return `${label} is required.`;
+    return null;
+  }
+  if (widget === "integer" || widget === "decimal") {
+    const num = typeof value === "number" ? value : Number(value);
+    if (Number.isNaN(num)) return `${label} must be a number.`;
+    if (widget === "integer" && !Number.isInteger(num)) {
+      return `${label} must be a whole number.`;
+    }
+    if (typeof field?.minimum === "number" && num < field.minimum) {
+      return `${label} must be at least ${field.minimum}.`;
+    }
+    if (typeof field?.maximum === "number" && num > field.maximum) {
+      return `${label} must be at most ${field.maximum}.`;
+    }
+    return null;
+  }
+  if (widget === "select") {
+    const allowed = getOptions(field).map((o) => o.const);
+    if (allowed.length > 0 && !allowed.includes(String(value))) {
+      return `${label} has an invalid selection.`;
+    }
+    return null;
+  }
+  const str = String(value);
+  if (typeof field?.minLength === "number" && str.length < field.minLength) {
+    return `${label} must be at least ${field.minLength} characters.`;
+  }
+  if (typeof field?.maxLength === "number" && str.length > field.maxLength) {
+    return `${label} must be at most ${field.maxLength} characters.`;
+  }
+  return null;
+}
+function renderableFields(schema) {
+  const props = schema?.properties;
+  if (!props) return [];
+  return Object.entries(props).filter(([, field]) => !isNestedOrUnsupported(field));
+}
+function validateForm(schema, values) {
+  const errors = {};
+  for (const [key, field] of renderableFields(schema)) {
+    const coerced = coerceValue(field, values[key]);
+    const err = validateField(field, coerced, isRequired(schema, key));
+    if (err) errors[key] = err;
+  }
+  return errors;
+}
+function buildContent(schema, values) {
+  const content = {};
+  for (const [key, field] of renderableFields(schema)) {
+    const coerced = coerceValue(field, values[key]);
+    if (coerced !== void 0) content[key] = coerced;
+  }
+  return content;
+}
+
+// src/index.ts
+function migrateActiveStream(oldUserId, newUserId) {
+  activeStreamStore.rename(oldUserId, newUserId);
+}
+
+exports.UserActionStaleError = UserActionStaleError;
+exports.buildContent = buildContent;
 exports.cancelUserAction = cancelUserAction;
+exports.classifyField = classifyField;
+exports.classifyUserActionKind = classifyUserActionKind;
+exports.coerceValue = coerceValue;
 exports.createInitialV2State = createInitialV2State;
+exports.defaultValueFor = defaultValueFor;
 exports.generateId = generateId;
+exports.getOptions = getOptions;
+exports.isNestedOrUnsupported = isNestedOrUnsupported;
+exports.isRequired = isRequired;
+exports.migrateActiveStream = migrateActiveStream;
 exports.processStreamEventV2 = processStreamEventV2;
+exports.renderableFields = renderableFields;
 exports.resendUserAction = resendUserAction;
 exports.streamWorkflowEvents = streamWorkflowEvents;
 exports.submitUserAction = submitUserAction;
 exports.useChatV2 = useChatV2;
 exports.useVoice = useVoice;
+exports.validateField = validateField;
+exports.validateForm = validateForm;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map