@paymanai/payman-ask-sdk 4.0.11 → 4.0.12

package/dist/index.js

@@ -1,8 +1,7 @@
 'use strict';
 
-var paymanTypescriptAskSdk = require('@paymanai/payman-typescript-ask-sdk');
-var framerMotion = require('framer-motion');
 var react = require('react');
+var framerMotion = require('framer-motion');
 var clsx = require('clsx');
 var tailwindMerge = require('tailwind-merge');
 var Sentry = require('@sentry/react');
@@ -30,15 +29,2035 @@ function _interopNamespace(e) {
       }
     });
   }
-  n.default = e;
-  return Object.freeze(n);
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Sentry__namespace = /*#__PURE__*/_interopNamespace(Sentry);
+var ReactMarkdown__default = /*#__PURE__*/_interopDefault(ReactMarkdown);
+var remarkGfm__default = /*#__PURE__*/_interopDefault(remarkGfm);
+var remarkBreaks__default = /*#__PURE__*/_interopDefault(remarkBreaks);
+
+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);
+function generateId() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+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") {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  return Promise.resolve();
+}
+function parseJSONBuffer(buffer) {
+  const events = [];
+  let braceCount = 0;
+  let startIndex = 0;
+  let inString = false;
+  let escapeNext = false;
+  let lastParsedIndex = -1;
+  for (let i = 0; i < buffer.length; i++) {
+    const char = buffer[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (char === '"' && !escapeNext) {
+      inString = !inString;
+      continue;
+    }
+    if (inString) {
+      continue;
+    }
+    if (char === "{") {
+      if (braceCount === 0) {
+        startIndex = i;
+      }
+      braceCount++;
+    } else if (char === "}") {
+      braceCount--;
+      if (braceCount === 0) {
+        const jsonStr = buffer.substring(startIndex, i + 1);
+        try {
+          const parsed = JSON.parse(jsonStr);
+          const event = parsed;
+          events.push(event);
+          lastParsedIndex = i;
+        } catch (err) {
+          console.error("Failed to parse JSON event:", jsonStr, err);
+        }
+      }
+    }
+  }
+  const remaining = lastParsedIndex >= 0 ? buffer.substring(lastParsedIndex + 1) : buffer;
+  return { events, remaining };
+}
+async function streamWorkflowEvents(url, body, headers, options = {}) {
+  const { signal, onEvent, onError, onComplete } = options;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        if (buffer.trim()) {
+          const { events: events2 } = parseJSONBuffer(buffer);
+          for (const event of events2) {
+            onEvent?.(event);
+            await yieldAfterProgressEvent(event);
+          }
+        }
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const { events, remaining } = parseJSONBuffer(buffer);
+      for (const event of events) {
+        onEvent?.(event);
+        await yieldAfterProgressEvent(event);
+      }
+      buffer = remaining;
+    }
+    onComplete?.();
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    onError?.(error);
+  }
+}
+var STAGE_LABELS = {
+  sanitizer: "Checking your request",
+  analyzer: "Understanding what you're asking",
+  prefetcher: "Gathering context",
+  planner: "Planning how to handle this",
+  execution: "Working on it",
+  formatter: "Writing the response"
+};
+function stageLabel(stage) {
+  const label = STAGE_LABELS[stage];
+  if (label) return label;
+  const pretty = stage.replace(/[_-]/g, " ");
+  return `Running ${pretty}`;
+}
+function isBlandStatus(message) {
+  if (!message) return true;
+  const normalized = message.trim().toLowerCase().replace(/[…\.]+$/, "").trim();
+  return BLAND_STATUS_LABELS.has(normalized);
+}
+var BLAND_STATUS_LABELS = /* @__PURE__ */ new Set([
+  "executing",
+  "working on it",
+  "thinking",
+  "processing",
+  "reviewing your request",
+  "composing response",
+  "checking your request",
+  "polishing the response"
+]);
+function getEventMessage(event) {
+  if (event.message?.trim()) {
+    return event.message.trim();
+  }
+  if (event.errorMessage?.trim()) {
+    return event.errorMessage.trim();
+  }
+  const eventType = event.eventType;
+  switch (eventType) {
+    case "RUN_STARTED":
+      return "Starting agent run...";
+    case "TOOL_CALL_STARTED": {
+      const description = typeof event.description === "string" ? event.description.trim() : "";
+      if (description) return description;
+      const toolName = typeof event.toolName === "string" ? event.toolName : "";
+      return toolName ? `Calling ${toolName}...` : "Calling tool...";
+    }
+    case "TOOL_CALL_COMPLETED": {
+      const description = typeof event.description === "string" ? event.description.trim() : "";
+      if (description) return description;
+      const toolName = typeof event.toolName === "string" ? event.toolName : "";
+      return toolName ? `${toolName} completed` : "Tool call completed";
+    }
+    case "RUN_IN_PROGRESS":
+      return event.partialText || "Thinking...";
+    case "RUN_COMPLETED":
+      return "Agent run completed";
+    case "RUN_FAILED":
+      return event.errorMessage || "Agent run failed";
+    case "KEEP_ALIVE":
+      return event.description || "";
+    case "THINKING_DELTA":
+      return event.text || "";
+    default:
+      return eventType;
+  }
+}
+function extractResponseContent(response) {
+  if (typeof response === "string") {
+    return response;
+  }
+  if (typeof response === "object" && response !== null) {
+    const resp = response;
+    if ("text" in resp && typeof resp.text === "string") {
+      return resp.text;
+    }
+    if ("content" in resp && typeof resp.content === "string") {
+      return resp.content;
+    }
+    if ("message" in resp && typeof resp.message === "string") {
+      return resp.message;
+    }
+    if ("answer" in resp && typeof resp.answer === "string") {
+      return resp.answer;
+    }
+    return JSON.stringify(response);
+  }
+  return "";
+}
+function normalizeEvent(event) {
+  const type = event.eventType;
+  switch (type) {
+    case "RUN_STARTED":
+      return { ...event, eventType: "WORKFLOW_STARTED" };
+    case "TOOL_CALL_STARTED": {
+      const toolName = typeof event.toolName === "string" ? event.toolName : void 0;
+      const description = typeof event.description === "string" ? event.description.trim() : "";
+      return {
+        ...event,
+        eventType: "INTENT_STARTED",
+        workerName: toolName ?? event.workerName,
+        message: description || event.message
+      };
+    }
+    case "TOOL_CALL_COMPLETED": {
+      const toolName = typeof event.toolName === "string" ? event.toolName : void 0;
+      const description = typeof event.description === "string" ? event.description.trim() : "";
+      return {
+        ...event,
+        eventType: "INTENT_COMPLETED",
+        workerName: toolName ?? event.workerName,
+        message: description || event.message
+      };
+    }
+    case "RUN_IN_PROGRESS":
+      return {
+        ...event,
+        eventType: "INTENT_PROGRESS",
+        message: event.partialText ?? event.message
+      };
+    case "RUN_COMPLETED":
+      return {
+        ...event,
+        eventType: "WORKFLOW_COMPLETED",
+        // state machine reads event.response for the final content
+        response: event.response ?? event.message
+      };
+    case "RUN_FAILED":
+      return {
+        ...event,
+        eventType: "WORKFLOW_ERROR",
+        errorMessage: event.errorMessage ?? event.message
+      };
+    default:
+      return event;
+  }
+}
+function isVerificationSchema(schema) {
+  const props = schema?.properties;
+  if (!props) return false;
+  const keys = Object.keys(props);
+  return keys.length === 1 && keys[0] === "verificationCode";
+}
+function classifyUserActionKind(action, schema) {
+  switch ((action || "").toLowerCase()) {
+    case "userverificationrequest":
+      return "verification";
+    case "usernotificationrequest":
+      return "notification";
+    case "userformrequest":
+      return isVerificationSchema(schema) ? "verification" : "form";
+    default:
+      return isVerificationSchema(schema) ? "verification" : "form";
+  }
+}
+function userActionHeader(kind) {
+  return kind === "verification" ? "**Verification required**" : "**Action required**";
+}
+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 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--) {
+    const s = state.steps[i];
+    if (s.eventType === "STAGE_STARTED" && (s.stage === "executor" || s.stage === "execution") && s.status === "in_progress") {
+      s.message = msg;
+      return;
+    }
+  }
+}
+function completeLastInProgressStep(steps) {
+  for (let i = steps.length - 1; i >= 0; i--) {
+    if (steps[i].status === "in_progress") {
+      steps[i].status = "completed";
+      return;
+    }
+  }
+}
+function createInitialV2State() {
+  return {
+    formattedThinkingText: "",
+    finalResponse: "",
+    currentWorker: "",
+    lastEventType: "",
+    sessionId: void 0,
+    executionId: void 0,
+    hasError: false,
+    errorMessage: "",
+    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;
+    const description = typeof event.description === "string" ? event.description : "";
+    if (description) {
+      for (let i = state.steps.length - 1; i >= 0; i--) {
+        if (state.steps[i].status === "in_progress") {
+          state.steps[i].message = description;
+          break;
+        }
+      }
+    }
+    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";
+    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_PROGRESS": {
+      const rawMessage = typeof event.message === "string" ? event.message : "";
+      const rawPartial = typeof event.partialText === "string" ? event.partialText : "";
+      const delta = rawMessage || rawPartial;
+      if (delta.length > 0) {
+        state.finalResponse += delta;
+      }
+      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;
+      updateExecutionStageMessage(state, message);
+      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": {
+      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);
+      }
+      if (content) {
+        state.finalResponse = content;
+        if (event.trace && typeof event.trace === "object") {
+          state.finalData = 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": {
+      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;
+        if (promptMessage) addThinkingDetail(state, promptMessage);
+        state.lastEventType = eventType;
+        break;
+      }
+      if (!userActionId) {
+        state.lastEventType = eventType;
+        break;
+      }
+      completeLastInProgressStep(state.steps);
+      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 header = userActionHeader(kind);
+      if (promptMessage) addThinkingLine(state, header, promptMessage);
+      else addThinkingHeader(state, header);
+      const stepId = `step-${state.stepCounter++}`;
+      state.steps.push({
+        id: stepId,
+        eventType,
+        message: promptMessage || (kind === "verification" ? "Waiting for verification..." : "Waiting for your input..."),
+        status: "in_progress",
+        timestamp: Date.now(),
+        elapsedMs: event.elapsedMs
+      });
+      state.currentExecutingStepId = stepId;
+      state.lastEventType = eventType;
+      break;
+    }
+    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;
+        if (noteMessage) addThinkingDetail(state, noteMessage);
+      }
+      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
+    // STAGE_STARTED / STAGE_COMPLETED / STAGE_FAILED /
+    // STAGE_SKIPPED around each pipeline stage so the UI can
+    // show real progress (sanitizer → analyzer → planner → …)
+    // instead of a static placeholder. Each STAGE_STARTED
+    // pushes an in-progress step with a user-facing label; the
+    // matching STAGE_COMPLETED/FAILED closes it WITHOUT
+    // rewriting the label — a terse "completed" flash between
+    // stages was more noise than signal. STAGE_SKIPPED removes
+    // the just-opened step entirely (skipping is expected on
+    // DIRECT_RESPONSE short-circuits).
+    //
+    // Finding the matching step uses `stepId` directly rather
+    // than comparing labels — the processor remembers which id
+    // it minted for the latest open STAGE_STARTED and the
+    // closing events look it up from state.currentExecutingStepId.
+    case "STAGE_STARTED": {
+      const stage = getEventText(event, "stage");
+      if (!stage) {
+        state.lastEventType = eventType;
+        break;
+      }
+      const serverMessage = getEventText(event, "message");
+      let initialMessage = serverMessage || stageLabel(stage);
+      if (stage === "executor" || stage === "execution") {
+        for (let i = state.steps.length - 1; i >= 0; i--) {
+          const s = state.steps[i];
+          if (s.eventType === "STAGE_STARTED" && s.stage === "analyzer" && s.status === "completed" && s.message) {
+            initialMessage = s.message;
+            break;
+          }
+        }
+      }
+      const stepId = `stage-${stage}-${state.stepCounter++}`;
+      state.steps.push({
+        id: stepId,
+        eventType,
+        message: initialMessage,
+        status: "in_progress",
+        timestamp: Date.now(),
+        stage
+      });
+      state.currentExecutingStepId = stepId;
+      state.lastEventType = eventType;
+      break;
+    }
+    case "STAGE_COMPLETED": {
+      const stage = getEventText(event, "stage");
+      if (!stage) {
+        state.lastEventType = eventType;
+        break;
+      }
+      const serverMessage = getEventText(event, "message");
+      for (let i = state.steps.length - 1; i >= 0; i--) {
+        const s = state.steps[i];
+        if (s.eventType === "STAGE_STARTED" && s.stage === stage && s.status === "in_progress") {
+          if (serverMessage) s.message = serverMessage;
+          s.status = "completed";
+          const durationMs = Number(event.durationMs);
+          if (Number.isFinite(durationMs)) s.elapsedMs = durationMs;
+          if (s.id === state.currentExecutingStepId) {
+            state.currentExecutingStepId = void 0;
+          }
+          break;
+        }
+      }
+      state.lastEventType = eventType;
+      break;
+    }
+    case "STAGE_FAILED": {
+      const stage = getEventText(event, "stage");
+      if (!stage) {
+        state.lastEventType = eventType;
+        break;
+      }
+      const serverMessage = getEventText(event, "message");
+      for (let i = state.steps.length - 1; i >= 0; i--) {
+        const s = state.steps[i];
+        if (s.eventType === "STAGE_STARTED" && s.stage === stage && s.status === "in_progress") {
+          if (serverMessage) s.message = serverMessage;
+          s.status = "error";
+          const durationMs = Number(event.durationMs);
+          if (Number.isFinite(durationMs)) s.elapsedMs = durationMs;
+          if (s.id === state.currentExecutingStepId) {
+            state.currentExecutingStepId = void 0;
+          }
+          break;
+        }
+      }
+      state.lastEventType = eventType;
+      break;
+    }
+    case "STAGE_SKIPPED": {
+      const stage = getEventText(event, "stage");
+      if (!stage) {
+        state.lastEventType = eventType;
+        break;
+      }
+      for (let i = state.steps.length - 1; i >= 0; i--) {
+        const s = state.steps[i];
+        if (s.eventType === "STAGE_STARTED" && s.stage === stage && s.status === "in_progress") {
+          if (s.id === state.currentExecutingStepId) {
+            state.currentExecutingStepId = void 0;
+          }
+          s.status = "skipped";
+          break;
+        }
+      }
+      state.lastEventType = eventType;
+      break;
+    }
+    default:
+      state.lastEventType = eventType;
+      break;
+  }
+  return state;
+}
+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("**Action required**");
+        if (step.message) parts.push(step.message);
+        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..."
+  };
+}
+var DEFAULT_STREAM_ENDPOINT = "/api/playground/ask/stream";
+function buildRequestBody(config, userMessage, sessionId, options) {
+  const sessionOwner = config.sessionParams;
+  const sessionOwnerId = sessionOwner?.id?.trim();
+  if (!sessionOwnerId) {
+    throw new Error("ChatConfig.sessionParams.id is required to send ask requests.");
+  }
+  const sessionAttributes = sessionOwner?.attributes && Object.keys(sessionOwner.attributes).length > 0 ? sessionOwner.attributes : void 0;
+  return {
+    agentId: config.agentId,
+    userInput: userMessage,
+    sessionId,
+    sessionOwnerId,
+    sessionOwnerLabel: sessionOwner?.name || void 0,
+    sessionAttributes,
+    analysisMode: options?.analysisMode,
+    locale: resolveLocale(config.locale),
+    timezone: resolveTimezone(config.timezone)
+  };
+}
+function resolveLocale(configured) {
+  if (configured && configured.trim().length > 0) return configured.trim();
+  if (typeof navigator !== "undefined") {
+    const navLocale = navigator.language;
+    if (navLocale && navLocale.length > 0) return navLocale;
+  }
+  return "en-US";
+}
+function resolveTimezone(configured) {
+  if (configured && configured.trim().length > 0) return configured.trim();
+  try {
+    const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (zone && zone.length > 0) return zone;
+  } catch {
+  }
+  return "UTC";
+}
+function buildStreamingUrl(config) {
+  const endpoint = config.api.streamEndpoint || DEFAULT_STREAM_ENDPOINT;
+  const stage = config.stage || "DEV";
+  const stageParamName = config.stageQueryParam ?? "stage";
+  const queryParams = new URLSearchParams({ [stageParamName]: stage });
+  return `${config.api.baseUrl}${endpoint}?${queryParams.toString()}`;
+}
+function buildUserActionUrl(config, userActionId, action) {
+  const endpoint = config.api.streamEndpoint || DEFAULT_STREAM_ENDPOINT;
+  const [endpointPath] = endpoint.split("?");
+  const normalizedEndpointPath = endpointPath.replace(/\/+$/, "");
+  const basePath = normalizedEndpointPath.endsWith("/stream") ? normalizedEndpointPath.slice(0, -"/stream".length) : normalizedEndpointPath;
+  const encodedUserActionId = encodeURIComponent(userActionId);
+  return `${config.api.baseUrl}${basePath}/user-action/${encodedUserActionId}/${action}`;
+}
+function buildResolveImagesUrl(config) {
+  if (config.api.resolveImagesEndpoint) {
+    return `${config.api.baseUrl}${config.api.resolveImagesEndpoint}`;
+  }
+  const streamEndpoint = config.api.streamEndpoint || DEFAULT_STREAM_ENDPOINT;
+  const [endpointPath] = streamEndpoint.split("?");
+  const normalizedEndpointPath = endpointPath.replace(/\/+$/, "");
+  const basePath = normalizedEndpointPath.endsWith("/stream") ? normalizedEndpointPath.slice(0, -"/stream".length) : normalizedEndpointPath;
+  return `${config.api.baseUrl}${basePath}/resolve-image-urls`;
+}
+function buildRequestHeaders(config) {
+  const headers = {
+    ...config.api.headers
+  };
+  if (config.api.authToken) {
+    headers.Authorization = `Bearer ${config.api.authToken}`;
+  }
+  return headers;
+}
+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");
+}
+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);
+  }
+};
+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);
+  }
+};
+var RAG_IMAGE_REGEX = /\/api\/rag\/chunks\/[^"'\s]+\/image/;
+function hasRagImages(content) {
+  return RAG_IMAGE_REGEX.test(content);
+}
+async function waitForNextPaint(signal) {
+  if (signal?.aborted) return;
+  await new Promise((resolve) => {
+    let isSettled = false;
+    const finish = () => {
+      if (isSettled) return;
+      isSettled = true;
+      signal?.removeEventListener("abort", finish);
+      resolve();
+    };
+    signal?.addEventListener("abort", finish, { once: true });
+    if (typeof requestAnimationFrame === "function") {
+      requestAnimationFrame(() => {
+        setTimeout(finish, 0);
+      });
+      return;
+    }
+    setTimeout(finish, 0);
+  });
+}
+async function resolveRagImageUrls(config, content, signal) {
+  const url = buildResolveImagesUrl(config);
+  const baseHeaders = buildRequestHeaders(config);
+  const headers = { "Content-Type": "application/json", ...baseHeaders };
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ input: content }),
+    signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  const text = await response.text();
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed === "string") return parsed;
+    if (typeof parsed.output === "string") return parsed.output;
+    if (typeof parsed.result === "string") return parsed.result;
+  } catch {
+  }
+  return text;
+}
+var FRIENDLY_ERROR_MESSAGE = "Oops, something went wrong. Please try again.";
+function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForResponse) {
+  const abortControllerRef = react.useRef(null);
+  const configRef = react.useRef(config);
+  configRef.current = config;
+  const callbacksRef = react.useRef(callbacks);
+  callbacksRef.current = callbacks;
+  const startStream = react.useCallback(
+    async (userMessage, streamingId, sessionId, externalAbortController, options) => {
+      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
+          )
+        );
+      };
+      try {
+        const currentConfig = configRef.current;
+        const requestBody = buildRequestBody(
+          currentConfig,
+          userMessage,
+          sessionId,
+          options
+        );
+        const url = buildStreamingUrl(currentConfig);
+        const headers = buildRequestHeaders(currentConfig);
+        await streamWorkflowEvents(url, requestBody, headers, {
+          signal: abortController.signal,
+          onEvent: (event) => {
+            if (abortController.signal.aborted) return;
+            processStreamEventV2(event, state);
+            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");
+            const useful = (m) => m && !isBlandStatus(m) ? m : void 0;
+            const latestUsefulStep = [...state.steps].reverse().find(
+              (s) => s.message && !isBlandStatus(s.message)
+            );
+            const currentMessage = useful(activeStep?.message) ?? useful(lastInProgressStep?.message) ?? latestUsefulStep?.message ?? useful(getEventMessage(event)) ?? // Last-resort: every candidate is bland (very first event,
+            // nothing useful seen yet). Render the bland label so the
+            // bubble isn't blank.
+            activeStep?.message ?? lastInProgressStep?.message ?? getEventMessage(event);
+            if (currentMessage) {
+              callbacksRef.current.onStatusMessage?.(currentMessage);
+            }
+            callbacksRef.current.onStepsUpdate?.([...state.steps]);
+            if (state.hasError) {
+              updateMessage({
+                streamingContent: FRIENDLY_ERROR_MESSAGE,
+                content: FRIENDLY_ERROR_MESSAGE,
+                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: state.finalResponse,
+                content: "",
+                currentMessage,
+                streamProgress: "processing",
+                isError: false,
+                formattedThinkingText: state.formattedThinkingText || void 0,
+                steps: [...state.steps],
+                currentExecutingStepId: state.currentExecutingStepId,
+                executionId: state.executionId,
+                sessionId: state.sessionId,
+                isCancelled: false
+              });
+            }
+          },
+          onError: (error) => {
+            setIsWaitingForResponse(false);
+            callbacksRef.current.onStatusMessage?.(null);
+            if (error.name !== "AbortError") {
+              callbacksRef.current.onError?.(error);
+            }
+            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_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" };
+                    }
+                    return step;
+                  }),
+                  currentExecutingStepId: void 0
+                } : msg
+              )
+            );
+          },
+          onComplete: () => {
+            setIsWaitingForResponse(false);
+            callbacksRef.current.onStatusMessage?.(null);
+            callbacksRef.current.onStepsUpdate?.([]);
+            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_MESSAGE : 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,
+              // Defensive: tracingData must be an object (or undefined)
+              // so the JSON viewer doesn't char-iterate a string. The
+              // event processor already drops bare strings; this is
+              // the last stop before the message leaves the SDK.
+              tracingData: state.finalData != null && typeof state.finalData === "object" ? state.finalData : void 0,
+              steps: state.hasError ? [] : [...state.steps],
+              isCancelled: false,
+              currentExecutingStepId: void 0,
+              formattedThinkingText: state.hasError ? void 0 : state.formattedThinkingText || void 0,
+              isResolvingImages: needsImageResolve,
+              totalElapsedMs: state.hasError ? void 0 : state.totalElapsedMs
+            };
+            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);
+        }
+        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_MESSAGE,
+              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 = react.useCallback(() => {
+    abortControllerRef.current?.abort();
+  }, []);
+  return {
+    startStream,
+    cancelStream,
+    abortControllerRef
+  };
+}
+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) {
+    chatStore.set(config.userId, config.initialMessages);
+    return config.initialMessages;
+  }
+  return [];
+}
+function getSessionIdFromMessages(messages) {
+  return messages.find((message) => message.sessionId)?.sessionId;
+}
+function useChatV2(config, callbacks = {}) {
+  const [messages, setMessages] = react.useState(() => getStoredOrInitialMessages(config));
+  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);
+  configRef.current = config;
+  const messagesRef = react.useRef(messages);
+  messagesRef.current = messages;
+  const storeAwareSetMessages = react.useCallback(
+    (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);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const storeAwareSetIsWaiting = react.useCallback(
+    (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);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const [userActionState, setUserActionState] = react.useState(EMPTY_USER_ACTION_STATE);
+  const wrappedCallbacks = react.useMemo(() => ({
+    ...callbacksRef.current,
+    onMessageSent: (message) => callbacksRef.current.onMessageSent?.(message),
+    onStreamStart: () => callbacksRef.current.onStreamStart?.(),
+    onStreamComplete: (message) => callbacksRef.current.onStreamComplete?.(message),
+    onError: (error) => callbacksRef.current.onError?.(error),
+    onExecutionTraceClick: (data) => callbacksRef.current.onExecutionTraceClick?.(data),
+    onSessionIdChange: (sessionId) => callbacksRef.current.onSessionIdChange?.(sessionId),
+    onUserActionRequired: (request) => {
+      setUserActionState((prev) => ({
+        ...prev,
+        prompts: upsertPrompt(prev.prompts, request)
+      }));
+      callbacksRef.current.onUserActionRequired?.(request);
+    },
+    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
+  }), []);
+  const { startStream, cancelStream: cancelStreamManager, abortControllerRef } = useStreamManagerV2(
+    config,
+    wrappedCallbacks,
+    storeAwareSetMessages,
+    storeAwareSetIsWaiting
+  );
+  const sendMessage = react.useCallback(
+    async (userMessage, options) => {
+      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) {
+        streamUserIdRef.current = userId;
+        const initialMessages = [...messagesRef.current, userMsg, streamingMsg];
+        activeStreamStore.start(userId, abortController, initialMessages);
+      }
+      const newSessionId = await startStream(
+        userMessage,
+        streamingId,
+        sessionIdRef.current,
+        abortController,
+        options
+      );
+      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;
+      }
+    },
+    [startStream]
+  );
+  const clearMessages = react.useCallback(() => {
+    if (configRef.current.userId) {
+      chatStore.delete(configRef.current.userId);
+    }
+    setMessages([]);
+  }, []);
+  const prependMessages = react.useCallback((msgs) => {
+    setMessages((prev) => [...msgs, ...prev]);
+  }, []);
+  const cancelStream = react.useCallback(() => {
+    const streamUserId = streamUserIdRef.current ?? configRef.current.userId;
+    if (streamUserId) {
+      activeStreamStore.abort(streamUserId);
+    }
+    streamUserIdRef.current = void 0;
+    cancelStreamManager();
+    setIsWaitingForResponse(false);
+    setUserActionState((prev) => ({ ...prev, prompts: [] }));
+    setMessages(
+      (prev) => prev.map((msg) => {
+        if (msg.isStreaming) {
+          return {
+            ...msg,
+            ...createCancelledMessageUpdate(
+              msg.steps || [],
+              msg.currentMessage
+            )
+          };
+        }
+        return msg;
+      })
+    );
+  }, [cancelStreamManager]);
+  const resetSession = react.useCallback(() => {
+    const streamUserId = streamUserIdRef.current ?? configRef.current.userId;
+    if (streamUserId) {
+      activeStreamStore.abort(streamUserId);
+    }
+    if (configRef.current.userId) {
+      chatStore.delete(configRef.current.userId);
+    }
+    streamUserIdRef.current = void 0;
+    setMessages([]);
+    sessionIdRef.current = void 0;
+    abortControllerRef.current?.abort();
+    setIsWaitingForResponse(false);
+    setUserActionState(EMPTY_USER_ACTION_STATE);
+  }, []);
+  const getSessionId = react.useCallback(() => {
+    return sessionIdRef.current;
+  }, []);
+  const getMessages = react.useCallback(() => {
+    return messages;
+  }, [messages]);
+  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, userActionId, content);
+        removePrompt(userActionId);
+      } catch (error) {
+        if (error instanceof UserActionStaleError) {
+          setPromptStatus(userActionId, "stale");
+          return;
+        }
+        setPromptStatus(userActionId, "pending");
+        callbacksRef.current.onError?.(error);
+        throw error;
+      }
+    },
+    [removePrompt, setPromptStatus]
+  );
+  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;
+        }
+        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);
+    });
+    const active = activeStreamStore.get(userId);
+    if (active) {
+      setMessages(active.messages);
+      setIsWaitingForResponse(active.isWaiting);
+    }
+    return unsubscribe;
+  }, [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);
+    }
+  }, [messages, config.userId]);
+  react.useEffect(() => {
+    if (!config.userId || activeStreamStore.has(config.userId)) return;
+    if (!config.initialMessages?.length || messagesRef.current.length > 0) return;
+    chatStore.set(config.userId, config.initialMessages);
+    setMessages(config.initialMessages);
+    sessionIdRef.current = getSessionIdFromMessages(config.initialMessages) ?? config.initialSessionId;
+  }, [config.initialMessages, config.initialSessionId, config.userId]);
+  react.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(EMPTY_USER_ACTION_STATE);
+    } else if (config.userId) {
+      const active = activeStreamStore.get(config.userId);
+      if (active) {
+        setMessages(active.messages);
+        setIsWaitingForResponse(active.isWaiting);
+        sessionIdRef.current = getSessionIdFromMessages(active.messages) ?? config.initialSessionId;
+        return;
+      }
+      const nextMessages = getStoredOrInitialMessages(config);
+      setMessages(nextMessages);
+      sessionIdRef.current = getSessionIdFromMessages(nextMessages) ?? config.initialSessionId;
+      setIsWaitingForResponse(false);
+    }
+  }, [config]);
+  return {
+    messages,
+    sendMessage,
+    clearMessages,
+    prependMessages,
+    cancelStream,
+    resetSession,
+    getSessionId,
+    getMessages,
+    isWaitingForResponse,
+    sessionId: sessionIdRef.current,
+    userActionState,
+    submitUserAction: submitUserAction2,
+    cancelUserAction: cancelUserAction2,
+    resendUserAction: resendUserAction2,
+    dismissNotification
+  };
+}
+function getSpeechRecognition() {
+  if (typeof window === "undefined") return null;
+  return window.SpeechRecognition || window.webkitSpeechRecognition || null;
+}
+function useVoice(config = {}, callbacks = {}) {
+  const [voiceState, setVoiceState] = react.useState("idle");
+  const [transcribedText, setTranscribedText] = react.useState("");
+  const [isAvailable, setIsAvailable] = react.useState(false);
+  const [isRecording, setIsRecording] = react.useState(false);
+  const recognitionRef = react.useRef(null);
+  const autoStopTimerRef = react.useRef(null);
+  const {
+    lang = "en-US",
+    interimResults = true,
+    continuous = true,
+    maxAlternatives = 1,
+    autoStopAfterSilence
+  } = config;
+  const { onStart, onEnd, onResult, onError, onStateChange } = callbacks;
+  react.useEffect(() => {
+    const SpeechRecognitionAPI = getSpeechRecognition();
+    setIsAvailable(SpeechRecognitionAPI !== null);
+  }, []);
+  react.useEffect(() => {
+    onStateChange?.(voiceState);
+  }, [voiceState, onStateChange]);
+  const requestPermissions = react.useCallback(async () => {
+    try {
+      const result = await navigator.mediaDevices.getUserMedia({
+        audio: true
+      });
+      result.getTracks().forEach((track) => track.stop());
+      return {
+        granted: true,
+        status: "granted"
+      };
+    } catch (error) {
+      return {
+        granted: false,
+        status: "denied"
+      };
+    }
+  }, []);
+  const getPermissions = react.useCallback(async () => {
+    if (typeof navigator === "undefined" || !navigator.permissions) {
+      return {
+        granted: false,
+        status: "undetermined"
+      };
+    }
+    try {
+      const result = await navigator.permissions.query({
+        name: "microphone"
+      });
+      return {
+        granted: result.state === "granted",
+        status: result.state === "granted" ? "granted" : result.state === "denied" ? "denied" : "undetermined"
+      };
+    } catch {
+      return {
+        granted: false,
+        status: "undetermined"
+      };
+    }
+  }, []);
+  const clearAutoStopTimer = react.useCallback(() => {
+    if (autoStopTimerRef.current) {
+      clearTimeout(autoStopTimerRef.current);
+      autoStopTimerRef.current = null;
+    }
+  }, []);
+  const resetAutoStopTimer = react.useCallback(() => {
+    clearAutoStopTimer();
+    if (autoStopAfterSilence && autoStopAfterSilence > 0) {
+      autoStopTimerRef.current = setTimeout(() => {
+        if (recognitionRef.current && isRecording) {
+          recognitionRef.current.stop();
+        }
+      }, autoStopAfterSilence);
+    }
+  }, [autoStopAfterSilence, clearAutoStopTimer, isRecording]);
+  const stopRecording = react.useCallback(() => {
+    if (recognitionRef.current) {
+      try {
+        recognitionRef.current.stop();
+      } catch (error) {
+        console.warn("Error stopping speech recognition:", error);
+      }
+    }
+    clearAutoStopTimer();
+    setIsRecording(false);
+    setVoiceState("idle");
+  }, [clearAutoStopTimer]);
+  const startRecording = react.useCallback(async () => {
+    const SpeechRecognitionAPI = getSpeechRecognition();
+    if (!SpeechRecognitionAPI) {
+      onError?.("Speech recognition not supported in this browser");
+      return;
+    }
+    try {
+      try {
+        await navigator.mediaDevices.getUserMedia({ audio: true });
+      } catch (permError) {
+        onError?.("Microphone access denied. Please allow microphone access in your browser settings.");
+        return;
+      }
+      const recognition = new SpeechRecognitionAPI();
+      recognition.continuous = continuous;
+      recognition.interimResults = interimResults;
+      recognition.lang = lang;
+      recognition.maxAlternatives = maxAlternatives;
+      recognition.onstart = () => {
+        setVoiceState("listening");
+        setIsRecording(true);
+        onStart?.();
+        resetAutoStopTimer();
+      };
+      recognition.onend = () => {
+        setVoiceState("idle");
+        setIsRecording(false);
+        clearAutoStopTimer();
+        onEnd?.();
+      };
+      recognition.onresult = (event) => {
+        const results = event.results;
+        let transcript = "";
+        for (let i = 0; i < results.length; i++) {
+          const result = results[i];
+          if (result && result[0]) {
+            const text = result[0].transcript;
+            if (transcript && !transcript.endsWith(" ") && !text.startsWith(" ")) {
+              transcript += " " + text;
+            } else {
+              transcript += text;
+            }
+          }
+        }
+        transcript = transcript.trim();
+        if (transcript) {
+          setTranscribedText(transcript);
+          onResult?.(transcript);
+          resetAutoStopTimer();
+        }
+      };
+      recognition.onerror = (event) => {
+        setVoiceState("error");
+        setIsRecording(false);
+        clearAutoStopTimer();
+        let errorMessage = event.error;
+        if (event.error === "not-allowed") {
+          errorMessage = "Microphone access denied. Please allow microphone access in your browser settings.";
+        } else if (event.error === "no-speech") {
+          errorMessage = "No speech detected. Please try again.";
+        } else if (event.error === "audio-capture") {
+          errorMessage = "No microphone found or microphone is in use.";
+        } else if (event.error === "network") {
+          errorMessage = "Network error occurred. Please check your connection.";
+        }
+        onError?.(errorMessage);
+      };
+      recognitionRef.current = recognition;
+      setTranscribedText("");
+      recognition.start();
+    } catch (error) {
+      setVoiceState("error");
+      setIsRecording(false);
+      onError?.(
+        error instanceof Error ? error.message : "Failed to start recording"
+      );
+    }
+  }, [
+    lang,
+    interimResults,
+    continuous,
+    maxAlternatives,
+    onStart,
+    onEnd,
+    onResult,
+    onError,
+    getPermissions,
+    resetAutoStopTimer,
+    clearAutoStopTimer
+  ]);
+  const clearTranscript = react.useCallback(() => {
+    setTranscribedText("");
+  }, []);
+  const reset = react.useCallback(() => {
+    stopRecording();
+    setTranscribedText("");
+    setVoiceState("idle");
+  }, [stopRecording]);
+  react.useEffect(() => {
+    return () => {
+      if (recognitionRef.current) {
+        try {
+          recognitionRef.current.stop();
+        } catch {
+        }
+      }
+      clearAutoStopTimer();
+    };
+  }, [clearAutoStopTimer]);
+  return {
+    voiceState,
+    transcribedText,
+    isAvailable,
+    isRecording,
+    startRecording,
+    stopRecording,
+    requestPermissions,
+    getPermissions,
+    clearTranscript,
+    reset
+  };
+}
+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;
+}
+function migrateActiveStream(oldUserId, newUserId) {
+  activeStreamStore.rename(oldUserId, newUserId);
 }
-
-var Sentry__namespace = /*#__PURE__*/_interopNamespace(Sentry);
-var ReactMarkdown__default = /*#__PURE__*/_interopDefault(ReactMarkdown);
-var remarkGfm__default = /*#__PURE__*/_interopDefault(remarkGfm);
-var remarkBreaks__default = /*#__PURE__*/_interopDefault(remarkBreaks);
-
 var PaymanChatContext = react.createContext(void 0);
 function usePaymanChat() {
   const context = react.useContext(PaymanChatContext);
@@ -258,7 +2277,7 @@ var NEGATIVE_FEEDBACK_REASONS = [
   { value: "REPORT_CONTENT", label: "Report content" },
   { value: "OTHER", label: "Other" }
 ];
-var DEFAULT_STREAM_ENDPOINT = "/api/playground/ask/stream";
+var DEFAULT_STREAM_ENDPOINT2 = "/api/playground/ask/stream";
 async function submitFeedback({
   baseUrl,
   streamEndpoint,
@@ -272,7 +2291,7 @@ async function submitFeedback({
   signal
 }) {
   const base = baseUrl.replace(/\/+$/, "");
-  const endpointPath = (streamEndpoint || DEFAULT_STREAM_ENDPOINT).split("?")[0].replace(/\/+$/, "");
+  const endpointPath = (streamEndpoint || DEFAULT_STREAM_ENDPOINT2).split("?")[0].replace(/\/+$/, "");
   const basePath = endpointPath.endsWith("/stream") ? endpointPath.slice(0, -"/stream".length) : endpointPath;
   const query = new URLSearchParams();
   if (stage) query.set(stageQueryParam ?? "stage", stage);
@@ -584,7 +2603,7 @@ function ThinkingBlock({ text }) {
     ) })
   ] });
 }
-var FRIENDLY_ERROR_MESSAGE = "Oops, something went wrong. Please try again.";
+var FRIENDLY_ERROR_MESSAGE2 = "Oops, something went wrong. Please try again.";
 function looksLikeRawError(text) {
   if (!text || text.length < 10) return false;
   return text.includes("errorType=") || /failed:\s*\{/.test(text);
@@ -750,95 +2769,86 @@ function AgentMessage({
         /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-2.5 w-2.5 rounded-full payman-agent-avatar-dot animate-pulse" }),
         /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute inset-0 h-2.5 w-2.5 rounded-full payman-agent-avatar-dot-ping animate-ping" })
       ] }) }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-8 w-8 rounded-full payman-agent-avatar flex items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Sparkles, { className: "h-3.5 w-3.5 payman-agent-avatar-icon" }) }) }),
-      /* @__PURE__ */ jsxRuntime.jsxs(
+      /* @__PURE__ */ jsxRuntime.jsx(
         "div",
         {
           className: cn(
             "min-w-0",
             layout === "centered" ? "max-w-[85%]" : showAvatar ? "max-w-[85%]" : "max-w-[80%]"
           ),
-          children: [
-            message.userActionResult && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mb-2", children: message.userActionResult === "approved" ? /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "inline-flex items-center gap-1.5 px-4 py-1.5 text-xs font-semibold rounded-full payman-agent-approved shrink-0", children: [
-              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { className: "w-3.5 h-3.5 shrink-0", strokeWidth: 2.5 }),
-              "Verified"
-            ] }) : /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "inline-flex items-center gap-1.5 px-4 py-1.5 text-xs font-semibold rounded-full payman-agent-rejected shrink-0", children: [
-              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { className: "w-3.5 h-3.5 shrink-0", strokeWidth: 2.5 }),
-              "Rejected"
-            ] }) }),
-            /* @__PURE__ */ jsxRuntime.jsxs(
-              "div",
-              {
-                className: cn(
-                  "overflow-hidden w-full min-w-0 px-4 py-3 rounded-2xl rounded-tl-md transition-all duration-200",
-                  layout === "centered" ? cn(
-                    "payman-agent-bubble payman-agent-bubble--centered",
-                    isStreaming && "streaming",
-                    isError && "error"
-                  ) : cn(
-                    "payman-agent-bubble",
-                    isError && "payman-agent-bubble--error"
-                  )
+          children: /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              className: cn(
+                "overflow-hidden w-full min-w-0 px-4 py-3 rounded-2xl rounded-tl-md transition-all duration-200",
+                layout === "centered" ? cn(
+                  "payman-agent-bubble payman-agent-bubble--centered",
+                  isStreaming && "streaming",
+                  isError && "error"
+                ) : cn(
+                  "payman-agent-bubble",
+                  isError && "payman-agent-bubble--error"
+                )
+              ),
+              children: [
+                showAgentName && /* @__PURE__ */ jsxRuntime.jsx(
+                  "p",
+                  {
+                    className: cn(
+                      "text-sm font-semibold mb-1 leading-none payman-agent-name",
+                      isStreaming && !content && "animate-pulse"
+                    ),
+                    children: isStreaming && !content ? "Thought Process" : agentName
+                  }
                 ),
-                children: [
-                  showAgentName && /* @__PURE__ */ jsxRuntime.jsx(
-                    "p",
-                    {
-                      className: cn(
-                        "text-sm font-semibold mb-1 leading-none payman-agent-name",
-                        isStreaming && !content && "animate-pulse"
-                      ),
-                      children: isStreaming && !content ? "Thought Process" : agentName
-                    }
-                  ),
-                  /* @__PURE__ */ jsxRuntime.jsx(
-                    "div",
-                    {
-                      className: cn(
-                        "text-sm leading-relaxed min-w-0 w-full break-words overflow-wrap-anywhere",
-                        showAgentName && "mt-1"
-                      ),
-                      children: isStreaming && !content ? (
-                        // Streaming without content — show thinking/step indicator
-                        activeThinkingText ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2 items-start", children: [
-                          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "h-4 w-4 mt-0.5 payman-agent-thinking-spinner animate-spin shrink-0" }),
-                          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-sm leading-relaxed min-w-0 break-words payman-agent-thinking-text whitespace-pre-wrap flex-1", children: [
-                            activeThinkingText,
-                            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "inline-block w-0.5 h-3.5 payman-agent-thinking-cursor animate-pulse ml-0.5 align-text-bottom" })
-                          ] })
-                        ] }) : currentStep ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-1.5 items-start", children: [
-                          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-0.5 shrink-0", children: renderStepIcon(currentStep, true) }),
-                          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm leading-relaxed min-w-0 break-words shimmer-text font-medium flex-1", children: currentStep.message })
-                        ] }) : /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2.5 items-start", children: [
-                          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "w-4 h-4 mt-0.5 payman-agent-thinking-spinner animate-spin shrink-0" }),
-                          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm payman-agent-thinking-text flex-1", children: currentMessage || "Thinking..." })
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  "div",
+                  {
+                    className: cn(
+                      "text-sm leading-relaxed min-w-0 w-full break-words overflow-wrap-anywhere",
+                      showAgentName && "mt-1"
+                    ),
+                    children: isStreaming && !content ? (
+                      // Streaming without content — show thinking/step indicator
+                      activeThinkingText ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2 items-start", children: [
+                        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "h-4 w-4 mt-0.5 payman-agent-thinking-spinner animate-spin shrink-0" }),
+                        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-sm leading-relaxed min-w-0 break-words payman-agent-thinking-text whitespace-pre-wrap flex-1", children: [
+                          activeThinkingText,
+                          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "inline-block w-0.5 h-3.5 payman-agent-thinking-cursor animate-pulse ml-0.5 align-text-bottom" })
                         ] })
-                      ) : isCancelled && !content ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2.5 items-start", children: [
-                        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { className: "w-4 h-4 mt-0.5 payman-agent-cancelled-icon shrink-0" }),
-                        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm payman-agent-cancelled-text italic flex-1", children: currentMessage || "Request was stopped." })
-                      ] }) : /* @__PURE__ */ jsxRuntime.jsx(
-                        "div",
-                        {
-                          className: cn(
-                            "payman-markdown payman-agent-markdown prose prose-sm dark:prose-invert max-w-none min-w-0 w-full break-words overflow-wrap-anywhere",
-                            isError && "payman-agent-markdown--error",
-                            isStreaming && content && "streaming-cursor"
-                          ),
-                          children: /* @__PURE__ */ jsxRuntime.jsx(
-                            ReactMarkdown__default.default,
-                            {
-                              remarkPlugins: [remarkGfm__default.default],
-                              components: markdownRenderers,
-                              children: isError ? conflictErrorMessage ?? FRIENDLY_ERROR_MESSAGE : content || (isStreaming ? "Thinking..." : isCancelled ? "Request was stopped." : "")
-                            }
-                          )
-                        }
-                      )
-                    }
-                  )
-                ]
-              }
-            )
-          ]
+                      ] }) : currentStep ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-1.5 items-start", children: [
+                        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-0.5 shrink-0", children: renderStepIcon(currentStep, true) }),
+                        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm leading-relaxed min-w-0 break-words shimmer-text font-medium flex-1", children: currentStep.message })
+                      ] }) : /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2.5 items-start", children: [
+                        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "w-4 h-4 mt-0.5 payman-agent-thinking-spinner animate-spin shrink-0" }),
+                        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm payman-agent-thinking-text flex-1", children: currentMessage || "Thinking..." })
+                      ] })
+                    ) : isCancelled && !content ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2.5 items-start", children: [
+                      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { className: "w-4 h-4 mt-0.5 payman-agent-cancelled-icon shrink-0" }),
+                      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm payman-agent-cancelled-text italic flex-1", children: currentMessage || "Request was stopped." })
+                    ] }) : /* @__PURE__ */ jsxRuntime.jsx(
+                      "div",
+                      {
+                        className: cn(
+                          "payman-markdown payman-agent-markdown prose prose-sm dark:prose-invert max-w-none min-w-0 w-full break-words overflow-wrap-anywhere",
+                          isError && "payman-agent-markdown--error",
+                          isStreaming && content && "streaming-cursor"
+                        ),
+                        children: /* @__PURE__ */ jsxRuntime.jsx(
+                          ReactMarkdown__default.default,
+                          {
+                            remarkPlugins: [remarkGfm__default.default],
+                            components: markdownRenderers,
+                            children: isError ? conflictErrorMessage ?? FRIENDLY_ERROR_MESSAGE2 : content || (isStreaming ? "Thinking..." : isCancelled ? "Request was stopped." : "")
+                          }
+                        )
+                      }
+                    )
+                  }
+                )
+              ]
+            }
+          )
         }
       )
     ] }),
@@ -2509,56 +4519,61 @@ function OtpInputV2({
     i
   )) });
 }
+var DEFAULT_CODE_LEN = 6;
 var RESEND_COOLDOWN_S = 30;
-var OTP_LEN = 6;
-function VerificationCardV2({
-  messageId,
-  action,
-  status,
-  clearOtpTrigger = 0,
-  onApprove,
-  onReject,
+function codeLengthFromSchema(prompt) {
+  const field = prompt.requestedSchema?.properties?.verificationCode;
+  const max = typeof field?.maxLength === "number" ? field.maxLength : void 0;
+  const min = typeof field?.minLength === "number" ? field.minLength : void 0;
+  return max ?? min ?? DEFAULT_CODE_LEN;
+}
+function VerificationInline({
+  prompt,
+  secondsLeft,
+  expired,
+  onSubmit,
+  onCancel,
   onResend
 }) {
-  const [otp, setOtp] = react.useState("");
-  const [otpErrored, setOtpErrored] = react.useState(false);
+  const isNumeric = prompt.verificationType !== "ALPHANUMERIC_CODE";
+  const codeLen = react.useMemo(() => codeLengthFromSchema(prompt), [prompt]);
+  const [code, setCode] = react.useState("");
+  const [errored, setErrored] = react.useState(false);
   const [resendSec, setResendSec] = react.useState(0);
-  const [localPending, setLocalPending] = react.useState(false);
   const lastSubmittedRef = react.useRef(null);
   const resendTimerRef = react.useRef(void 0);
+  const status = prompt.status;
+  const busy = status === "submitting";
+  const stale = status === "stale";
+  const locked = busy || stale || expired;
   react.useEffect(() => {
-    if (clearOtpTrigger <= 0) return;
-    setOtpErrored(true);
-    const t = window.setTimeout(() => {
-      setOtp("");
-      setOtpErrored(false);
-      setLocalPending(false);
-      lastSubmittedRef.current = null;
-    }, 600);
-    return () => window.clearTimeout(t);
-  }, [clearOtpTrigger]);
-  react.useEffect(() => {
-    if (otp.length < OTP_LEN) {
+    if (prompt.subAction === "SubmissionInvalid") {
+      setErrored(true);
+      setCode("");
       lastSubmittedRef.current = null;
     }
-  }, [otp]);
+  }, [prompt.subAction, prompt.userActionId]);
   react.useEffect(() => {
-    if (status !== "pending") {
-      setLocalPending(false);
-    }
-  }, [status]);
+    if (code.length < codeLen) lastSubmittedRef.current = null;
+  }, [code, codeLen]);
+  const doSubmit = react.useCallback(
+    (value) => {
+      if (locked || !value) return;
+      if (lastSubmittedRef.current === value) return;
+      lastSubmittedRef.current = value;
+      void onSubmit(prompt.userActionId, { verificationCode: value }).catch(() => {
+        lastSubmittedRef.current = null;
+        setErrored(true);
+      });
+    },
+    [locked, onSubmit, prompt.userActionId]
+  );
   react.useEffect(() => {
-    if (otp.length !== OTP_LEN || !/^\d+$/.test(otp) || status !== "pending") {
-      return;
+    if (!isNumeric || locked) return;
+    if (code.length === codeLen && /^\d+$/.test(code)) {
+      doSubmit(code);
     }
-    if (lastSubmittedRef.current === otp) return;
-    lastSubmittedRef.current = otp;
-    setLocalPending(true);
-    void onApprove(messageId, otp).catch(() => {
-      lastSubmittedRef.current = null;
-      setLocalPending(false);
-    });
-  }, [messageId, onApprove, otp, status]);
+  }, [code, codeLen, doSubmit, isNumeric, locked]);
   react.useEffect(() => {
     return () => {
       if (typeof resendTimerRef.current === "number") {
@@ -2585,94 +4600,309 @@ function VerificationCardV2({
     }, 1e3);
   }, []);
   const handleResend = react.useCallback(async () => {
-    if (resendSec > 0 || status === "verifying" || localPending) return;
-    setLocalPending(true);
+    if (locked || resendSec > 0) return;
+    setErrored(false);
+    setCode("");
+    lastSubmittedRef.current = null;
     try {
-      await onResend(messageId);
+      await onResend(prompt.userActionId);
       startResendCooldown();
-    } finally {
-      setLocalPending(false);
-    }
-  }, [localPending, messageId, onResend, resendSec, startResendCooldown, status]);
-  const handleCancel = react.useCallback(async () => {
-    if (status === "verifying" || localPending) return;
-    setLocalPending(true);
-    try {
-      await onReject(messageId);
-    } finally {
-      setLocalPending(false);
+    } catch {
     }
-  }, [localPending, messageId, onReject, status]);
-  const busy = status === "verifying" || localPending;
-  if (status === "approved" || status === "rejected") {
-    return null;
-  }
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    framerMotion.motion.div,
-    {
-      className: "payman-v2-verification",
-      initial: { opacity: 0, y: 10 },
-      animate: { opacity: 1, y: 0 },
-      transition: { type: "spring", stiffness: 320, damping: 28 },
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsxs(
-          "div",
+  }, [locked, onResend, prompt.userActionId, resendSec, startResendCooldown]);
+  const handleCancel = react.useCallback(() => {
+    if (busy) return;
+    void onCancel(prompt.userActionId);
+  }, [busy, onCancel, prompt.userActionId]);
+  const description = prompt.message?.trim() || (isNumeric ? `Enter the ${codeLen}-digit code to continue` : "Enter the verification code to continue");
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "payman-v2-ua", role: "group", "aria-label": "Verification required", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "payman-v2-ua-head", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ShieldCheck, { className: "payman-v2-ua-icon", size: 15, strokeWidth: 1.75, "aria-hidden": true }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "payman-v2-ua-title", children: "Verification required" }),
+      typeof secondsLeft === "number" && !stale && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "payman-v2-ua-timer", children: expired ? "Expired" : `${secondsLeft}s` })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("p", { className: "payman-v2-ua-desc", children: description }),
+    stale ? /* @__PURE__ */ jsxRuntime.jsx("p", { className: "payman-v2-ua-stale", children: "This request is no longer available." }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      isNumeric ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "payman-v2-ua-field", children: /* @__PURE__ */ jsxRuntime.jsx(
+        OtpInputV2,
+        {
+          value: code,
+          onChange: (v) => {
+            setErrored(false);
+            setCode(v);
+          },
+          maxLength: codeLen,
+          disabled: locked,
+          error: errored
+        }
+      ) }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "payman-v2-ua-field", children: /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "text",
+          className: cn("payman-v2-ua-input", errored && "payman-v2-ua-input-error"),
+          value: code,
+          disabled: locked,
+          autoComplete: "one-time-code",
+          placeholder: "Verification code",
+          onChange: (e) => {
+            setErrored(false);
+            setCode(e.target.value);
+          },
+          onKeyDown: (e) => {
+            if (e.key === "Enter") {
+              e.preventDefault();
+              doSubmit(code.trim());
+            }
+          }
+        }
+      ) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "payman-v2-ua-actions", children: [
+        !isNumeric && /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
           {
-            className: cn(
-              "payman-v2-verification-card",
-              busy && "payman-v2-verification-card-busy"
-            ),
-            children: [
-              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "payman-v2-verification-header", children: [
-                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "payman-v2-verification-header-row", children: [
-                  /* @__PURE__ */ jsxRuntime.jsx(
-                    lucideReact.ShieldCheck,
-                    {
-                      className: "payman-v2-verification-icon",
-                      size: 18,
-                      strokeWidth: 1.75,
-                      "aria-hidden": true
-                    }
-                  ),
-                  /* @__PURE__ */ jsxRuntime.jsx("p", { className: "payman-v2-verification-title", children: "Verify" }),
-                  action.amount != null ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "payman-v2-verification-amount", children: action.amount }) : action.payeeName ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "payman-v2-verification-payee", children: action.payeeName }) : null
-                ] }),
-                /* @__PURE__ */ jsxRuntime.jsx("p", { className: "payman-v2-verification-description", children: "Enter the 6-digit code sent to your phone" }),
-                /* @__PURE__ */ jsxRuntime.jsx(
-                  OtpInputV2,
-                  {
-                    value: otp,
-                    onChange: setOtp,
-                    maxLength: OTP_LEN,
-                    disabled: busy,
-                    error: otpErrored
-                  }
-                )
-              ] }),
-              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "payman-v2-verification-actions", children: /* @__PURE__ */ jsxRuntime.jsx(
-                "button",
-                {
-                  type: "button",
-                  className: "payman-v2-verification-cancel-btn",
-                  disabled: busy,
-                  onClick: () => void handleCancel(),
-                  children: "Cancel"
-                }
-              ) })
-            ]
+            type: "button",
+            className: "payman-v2-ua-btn payman-v2-ua-btn-primary",
+            disabled: locked || !code.trim(),
+            onClick: () => doSubmit(code.trim()),
+            children: busy ? "Submitting\u2026" : "Submit"
           }
         ),
         /* @__PURE__ */ jsxRuntime.jsx(
           "button",
           {
             type: "button",
-            className: "payman-v2-verification-resend-link",
-            disabled: busy || resendSec > 0,
+            className: "payman-v2-ua-link",
+            disabled: locked || resendSec > 0,
             onClick: () => void handleResend(),
             children: resendSec > 0 ? `Resend (${resendSec}s)` : "Resend"
           }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            className: "payman-v2-ua-link payman-v2-ua-link-danger",
+            disabled: busy,
+            onClick: handleCancel,
+            children: "Cancel"
+          }
         )
-      ]
+      ] })
+    ] })
+  ] });
+}
+function SchemaFormInline({
+  prompt,
+  secondsLeft,
+  expired,
+  onSubmit,
+  onCancel
+}) {
+  const schema = prompt.requestedSchema;
+  const fields = react.useMemo(() => renderableFields(schema), [schema]);
+  const [values, setValues] = react.useState(() => {
+    const init2 = {};
+    for (const [key, field] of fields) init2[key] = defaultValueFor(field);
+    return init2;
+  });
+  const [errors, setErrors] = react.useState({});
+  const status = prompt.status;
+  const busy = status === "submitting";
+  const stale = status === "stale";
+  const locked = busy || stale || expired;
+  const setValue = (key, value) => {
+    setValues((prev) => ({ ...prev, [key]: value }));
+    setErrors((prev) => {
+      if (!prev[key]) return prev;
+      const next = { ...prev };
+      delete next[key];
+      return next;
+    });
+  };
+  const handleSubmit = () => {
+    if (locked) return;
+    const validation = validateForm(schema, values);
+    if (Object.keys(validation).length > 0) {
+      setErrors(validation);
+      return;
+    }
+    void onSubmit(prompt.userActionId, buildContent(schema, values)).catch(() => {
+    });
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "payman-v2-ua", role: "group", "aria-label": "Action required", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "payman-v2-ua-head", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Pencil, { className: "payman-v2-ua-icon", size: 14, strokeWidth: 1.75, "aria-hidden": true }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "payman-v2-ua-title", children: "Action required" }),
+      typeof secondsLeft === "number" && !stale && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "payman-v2-ua-timer", children: expired ? "Expired" : `${secondsLeft}s` })
+    ] }),
+    prompt.message?.trim() && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "payman-v2-ua-desc", children: prompt.message }),
+    stale ? /* @__PURE__ */ jsxRuntime.jsx("p", { className: "payman-v2-ua-stale", children: "This request is no longer available." }) : fields.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("p", { className: "payman-v2-ua-desc", children: "This action has no inputs to fill." }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "payman-v2-ua-form", children: fields.map(([key, field]) => {
+      const widget = classifyField(field);
+      const label = field.title || key;
+      const required = isRequired(schema, key);
+      const err = errors[key];
+      const fieldId = `ua-${prompt.userActionId}-${key}`;
+      if (widget === "boolean") {
+        return /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "payman-v2-ua-check", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              type: "checkbox",
+              checked: Boolean(values[key]),
+              disabled: locked,
+              onChange: (e) => setValue(key, e.target.checked)
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+            label,
+            required && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "payman-v2-ua-req", children: "*" })
+          ] })
+        ] }, key);
+      }
+      return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "payman-v2-ua-row", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("label", { htmlFor: fieldId, className: "payman-v2-ua-label", children: [
+          label,
+          required && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "payman-v2-ua-req", children: "*" })
+        ] }),
+        field.description && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "payman-v2-ua-hint", children: field.description }),
+        widget === "select" ? /* @__PURE__ */ jsxRuntime.jsxs(
+          "select",
+          {
+            id: fieldId,
+            className: cn("payman-v2-ua-input", err && "payman-v2-ua-input-error"),
+            value: String(values[key] ?? ""),
+            disabled: locked,
+            onChange: (e) => setValue(key, e.target.value),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", disabled: true, children: "Select\u2026" }),
+              getOptions(field).map((opt) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: opt.const, children: opt.title || opt.const }, opt.const))
+            ]
+          }
+        ) : /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            id: fieldId,
+            type: widget === "integer" || widget === "decimal" ? "number" : "text",
+            inputMode: widget === "integer" ? "numeric" : widget === "decimal" ? "decimal" : void 0,
+            step: widget === "decimal" ? "any" : widget === "integer" ? "1" : void 0,
+            className: cn("payman-v2-ua-input", err && "payman-v2-ua-input-error"),
+            value: String(values[key] ?? ""),
+            disabled: locked,
+            placeholder: field.description ? void 0 : label,
+            onChange: (e) => setValue(key, e.target.value),
+            onKeyDown: (e) => {
+              if (e.key === "Enter") {
+                e.preventDefault();
+                handleSubmit();
+              }
+            }
+          }
+        ),
+        err && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "payman-v2-ua-error", children: err })
+      ] }, key);
+    }) }),
+    !stale && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "payman-v2-ua-actions", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: "payman-v2-ua-btn payman-v2-ua-btn-primary",
+          disabled: locked,
+          onClick: handleSubmit,
+          children: busy ? "Submitting\u2026" : "Submit"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: "payman-v2-ua-link payman-v2-ua-link-danger",
+          disabled: busy,
+          onClick: () => void onCancel(prompt.userActionId),
+          children: "Cancel"
+        }
+      )
+    ] })
+  ] });
+}
+function NotificationInline({ notification, onDismiss }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "payman-v2-ua-note", role: "status", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Info, { className: "payman-v2-ua-note-icon", size: 14, strokeWidth: 1.75, "aria-hidden": true }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "payman-v2-ua-note-text", children: notification.message }),
+    onDismiss && /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "button",
+        className: "payman-v2-ua-note-dismiss",
+        "aria-label": "Dismiss notification",
+        onClick: () => onDismiss(notification.id),
+        children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { size: 13, strokeWidth: 2 })
+      }
+    )
+  ] });
+}
+function useExpiryCountdown(prompt) {
+  const initial = typeof prompt.expirySeconds === "number" && prompt.expirySeconds > 0 ? Math.floor(prompt.expirySeconds) : void 0;
+  const [secondsLeft, setSecondsLeft] = react.useState(initial);
+  react.useEffect(() => {
+    if (initial === void 0) {
+      setSecondsLeft(void 0);
+      return;
+    }
+    setSecondsLeft(initial);
+    const id = window.setInterval(() => {
+      setSecondsLeft((s) => {
+        if (s === void 0) return s;
+        if (s <= 1) {
+          window.clearInterval(id);
+          return 0;
+        }
+        return s - 1;
+      });
+    }, 1e3);
+    return () => window.clearInterval(id);
+  }, [prompt.userActionId, prompt.subAction, initial]);
+  const expired = initial !== void 0 && secondsLeft === 0;
+  return [secondsLeft, expired];
+}
+function UserActionInline({ prompt, onSubmit, onCancel, onResend }) {
+  const [secondsLeft, expired] = useExpiryCountdown(prompt);
+  let body;
+  if (prompt.kind === "verification") {
+    body = /* @__PURE__ */ jsxRuntime.jsx(
+      VerificationInline,
+      {
+        prompt,
+        secondsLeft,
+        expired,
+        onSubmit,
+        onCancel,
+        onResend
+      }
+    );
+  } else if (prompt.kind === "notification") {
+    const note = { id: prompt.userActionId, message: prompt.message ?? "" };
+    body = /* @__PURE__ */ jsxRuntime.jsx(NotificationInline, { notification: note });
+  } else {
+    body = /* @__PURE__ */ jsxRuntime.jsx(
+      SchemaFormInline,
+      {
+        prompt,
+        secondsLeft,
+        expired,
+        onSubmit,
+        onCancel
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    framerMotion.motion.div,
+    {
+      className: "payman-v2-ua-wrap",
+      initial: { opacity: 0, y: 8 },
+      animate: { opacity: 1, y: 0 },
+      transition: { type: "spring", stiffness: 320, damping: 28 },
+      children: body
     }
   );
 }
@@ -2688,13 +4918,17 @@ var MessageListV2 = react.forwardRef(
     onExecutionTraceClick,
     messageActions,
     retryDisabled = false,
-    userAction,
-    onApproveAction,
-    onRejectAction,
-    onResendAction,
+    userActionPrompts,
+    notifications,
+    onSubmitUserAction,
+    onCancelUserAction,
+    onResendUserAction,
+    onDismissNotification,
     onSubmitFeedback,
     typingSpeed = 4
   }, ref) {
+    const noop = react.useCallback(async () => {
+    }, []);
     const scrollRef = react.useRef(null);
     const scrollInnerRef = react.useRef(null);
     const isNearBottomRef = react.useRef(true);
@@ -2837,20 +5071,24 @@ var MessageListV2 = react.forwardRef(
                     typingSpeed
                   }
                 ) }, message.id)),
-                userAction && userAction.status !== "approved" && userAction.status !== "rejected" && /* @__PURE__ */ jsxRuntime.jsx("div", { children: /* @__PURE__ */ jsxRuntime.jsx(
-                  VerificationCardV2,
+                notifications?.map((note) => /* @__PURE__ */ jsxRuntime.jsx(
+                  NotificationInline,
                   {
-                    messageId: userAction.messageId,
-                    action: userAction.action,
-                    status: userAction.status,
-                    onApprove: onApproveAction ?? (async () => {
-                    }),
-                    onReject: onRejectAction ?? (async () => {
-                    }),
-                    onResend: onResendAction ?? (async () => {
-                    })
-                  }
-                ) })
+                    notification: note,
+                    onDismiss: onDismissNotification
+                  },
+                  note.id
+                )),
+                userActionPrompts?.map((prompt) => /* @__PURE__ */ jsxRuntime.jsx(
+                  UserActionInline,
+                  {
+                    prompt,
+                    onSubmit: onSubmitUserAction ?? noop,
+                    onCancel: onCancelUserAction ?? noop,
+                    onResend: onResendUserAction ?? noop
+                  },
+                  prompt.toolCallId || prompt.userActionId
+                ))
               ]
             }
           )
@@ -3911,10 +6149,13 @@ function TimelineBars({
   ] });
 }
 var DEFAULT_USER_ACTION_STATE = {
-  request: null,
-  result: null};
+  prompts: [],
+  notifications: []
+};
 var NOOP_ASYNC = async () => {
 };
+var NOOP = () => {
+};
 function useSentryChatCallbacks(callbacks, config) {
   const sentryCtxRef = react.useRef({});
   const callbacksRef = react.useRef(callbacks);
@@ -3984,7 +6225,7 @@ function useSentryChatCallbacks(callbacks, config) {
       onAttachFileClick: () => callbacksRef.current?.onAttachFileClick?.(),
       onMessageFeedback: (data) => callbacksRef.current?.onMessageFeedback?.(data),
       onUserActionRequired: (req) => callbacksRef.current?.onUserActionRequired?.(req),
-      onUserActionEvent: (evType, msg) => callbacksRef.current?.onUserActionEvent?.(evType, msg),
+      onUserNotification: (note) => callbacksRef.current?.onUserNotification?.(note),
       onStatusMessage: (msg) => callbacksRef.current?.onStatusMessage?.(msg),
       onStepsUpdate: (steps) => callbacksRef.current?.onStepsUpdate?.(steps)
     }),
@@ -4052,10 +6293,11 @@ var PaymanChatInner = react.forwardRef(function PaymanChatInner2({
     }
   }, [editingMessageId, messages]);
   const userActionState = chat.userActionState ?? DEFAULT_USER_ACTION_STATE;
-  const approveUserAction = chat.approveUserAction ?? NOOP_ASYNC;
-  const rejectUserAction = chat.rejectUserAction ?? NOOP_ASYNC;
-  const resendOtp = chat.resendOtp ?? NOOP_ASYNC;
-  const isUserActionSupported = typeof chat.approveUserAction === "function" && typeof chat.rejectUserAction === "function" && typeof chat.resendOtp === "function";
+  const submitUserAction2 = chat.submitUserAction ?? NOOP_ASYNC;
+  const cancelUserAction2 = chat.cancelUserAction ?? NOOP_ASYNC;
+  const resendUserAction2 = chat.resendUserAction ?? NOOP_ASYNC;
+  const dismissNotification = chat.dismissNotification ?? NOOP;
+  const isUserActionSupported = typeof chat.submitUserAction === "function" && typeof chat.cancelUserAction === "function" && typeof chat.resendUserAction === "function";
   const {
     transcribedText,
     isAvailable: voiceAvailable,
@@ -4063,7 +6305,7 @@ var PaymanChatInner = react.forwardRef(function PaymanChatInner2({
     startRecording,
     stopRecording,
     clearTranscript
-  } = paymanTypescriptAskSdk.useVoice(
+  } = useVoice(
     {
       lang: config.voiceLang || "en-US",
       interimResults: config.voiceInterimResults !== false,
@@ -4296,23 +6538,8 @@ var PaymanChatInner = react.forwardRef(function PaymanChatInner2({
     setLightboxSrc(src);
     setLightboxAlt(alt);
   };
-  const v2UserAction = react.useMemo(() => {
-    if (!isUserActionSupported || !userActionState.request) return null;
-    const req = userActionState.request;
-    let status = "pending";
-    if (userActionState.result === "approved") status = "approved";
-    else if (userActionState.result === "rejected") status = "rejected";
-    return {
-      messageId: `ua-${req.userActionId || Date.now()}`,
-      action: {
-        type: req.userActionType || "generic",
-        message: req.message || "Verify this action",
-        amount: req.metadata?.amount,
-        payeeName: req.metadata?.payeeName
-      },
-      status
-    };
-  }, [isUserActionSupported, userActionState.request, userActionState.result]);
+  const userActionPrompts = isUserActionSupported ? userActionState.prompts : void 0;
+  const notifications = userActionState.notifications;
   const handleV2Send = (text) => {
     if (isRecording) stopRecording();
     if (text.trim() && !disableInput && isSessionParamsConfigured) {
@@ -4464,16 +6691,12 @@ var PaymanChatInner = react.forwardRef(function PaymanChatInner2({
                   messageActions,
                   retryDisabled: isWaitingForResponse,
                   typingSpeed: config.typingSpeed ?? 4,
-                  userAction: v2UserAction,
-                  onApproveAction: isUserActionSupported ? async (_msgId, otp) => {
-                    await approveUserAction(otp);
-                  } : void 0,
-                  onRejectAction: isUserActionSupported ? async () => {
-                    await rejectUserAction();
-                  } : void 0,
-                  onResendAction: isUserActionSupported ? async () => {
-                    await resendOtp();
-                  } : void 0,
+                  userActionPrompts,
+                  notifications,
+                  onSubmitUserAction: isUserActionSupported ? submitUserAction2 : void 0,
+                  onCancelUserAction: isUserActionSupported ? cancelUserAction2 : void 0,
+                  onResendUserAction: isUserActionSupported ? resendUserAction2 : void 0,
+                  onDismissNotification: dismissNotification,
                   onSubmitFeedback: handleSubmitFeedback
                 }
               ),
@@ -4551,56 +6774,39 @@ var PaymanChatInner = react.forwardRef(function PaymanChatInner2({
 var PaymanChat = react.forwardRef(
   function PaymanChat2(props, ref) {
     const mergedCallbacks = useSentryChatCallbacks(props.callbacks, props.config);
-    const chat = paymanTypescriptAskSdk.useChatV2(props.config, mergedCallbacks);
+    const chat = useChatV2(props.config, mergedCallbacks);
     return /* @__PURE__ */ jsxRuntime.jsx(PaymanChatInner, { ...props, chat, ref });
   }
 );
 
-Object.defineProperty(exports, "buildFormattedThinking", {
-  enumerable: true,
-  get: function () { return paymanTypescriptAskSdk.buildFormattedThinking; }
-});
-Object.defineProperty(exports, "cancelUserAction", {
-  enumerable: true,
-  get: function () { return paymanTypescriptAskSdk.cancelUserAction; }
-});
-Object.defineProperty(exports, "createInitialV2State", {
-  enumerable: true,
-  get: function () { return paymanTypescriptAskSdk.createInitialV2State; }
-});
-Object.defineProperty(exports, "generateId", {
-  enumerable: true,
-  get: function () { return paymanTypescriptAskSdk.generateId; }
-});
-Object.defineProperty(exports, "processStreamEventV2", {
-  enumerable: true,
-  get: function () { return paymanTypescriptAskSdk.processStreamEventV2; }
-});
-Object.defineProperty(exports, "resendUserAction", {
-  enumerable: true,
-  get: function () { return paymanTypescriptAskSdk.resendUserAction; }
-});
-Object.defineProperty(exports, "streamWorkflowEvents", {
-  enumerable: true,
-  get: function () { return paymanTypescriptAskSdk.streamWorkflowEvents; }
-});
-Object.defineProperty(exports, "submitUserAction", {
-  enumerable: true,
-  get: function () { return paymanTypescriptAskSdk.submitUserAction; }
-});
-Object.defineProperty(exports, "useChatV2", {
-  enumerable: true,
-  get: function () { return paymanTypescriptAskSdk.useChatV2; }
-});
-Object.defineProperty(exports, "useVoice", {
-  enumerable: true,
-  get: function () { return paymanTypescriptAskSdk.useVoice; }
-});
 exports.PaymanChat = PaymanChat;
 exports.PaymanChatContext = PaymanChatContext;
+exports.UserActionStaleError = UserActionStaleError;
+exports.buildContent = buildContent;
+exports.buildFormattedThinking = buildFormattedThinking;
+exports.cancelUserAction = cancelUserAction;
 exports.captureSentryError = captureSentryError;
+exports.classifyField = classifyField;
+exports.classifyUserActionKind = classifyUserActionKind;
 exports.cn = cn;
+exports.coerceValue = coerceValue;
+exports.createInitialV2State = createInitialV2State;
+exports.defaultValueFor = defaultValueFor;
 exports.formatDate = formatDate;
+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.usePaymanChat = usePaymanChat;
+exports.useVoice = useVoice;
+exports.validateField = validateField;
+exports.validateForm = validateForm;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map