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

package/dist/index.js

@@ -2,7 +2,7 @@
 
 var react = require('react');
 
-// src/hooks/useChat.ts
+// src/hooks/useChatV2.ts
 
 // src/utils/generateId.ts
 function generateId() {
@@ -147,13 +147,13 @@ function getEventMessage(event) {
     case "USER_ACTION_REQUIRED":
       return "Waiting for verification...";
     case "USER_ACTION_SUCCESS":
-      return "Verification successful";
+      return "Verification approved";
     case "USER_ACTION_EXPIRED":
       return "Verification expired";
     case "USER_ACTION_INVALID":
-      return "Invalid input, please try again";
+      return "Invalid code. Please try again.";
     case "USER_ACTION_REJECTED":
-      return "Verification rejected";
+      return "Verification cancelled";
     case "USER_ACTION_RESENT":
       return "Verification code resent";
     case "USER_ACTION_FAILED":
@@ -168,6 +168,31 @@ function getEventMessage(event) {
       return eventType;
   }
 }
+function isUserActionPrompt(text) {
+  return /\benter\b.+\b(code|otp)\b/i.test(text) || /\b(authorization|verification)\s+code\b/i.test(text) || /\bsent\s+to\s+your\b/i.test(text);
+}
+function getUserActionDisplayMessage(eventType, rawMessage) {
+  const raw = rawMessage?.trim();
+  const safeRaw = raw && !isUserActionPrompt(raw) ? raw : "";
+  switch (eventType) {
+    case "USER_ACTION_REQUIRED":
+      return raw || "Waiting for verification...";
+    case "USER_ACTION_SUCCESS":
+      return safeRaw || "Verification approved";
+    case "USER_ACTION_INVALID":
+      return safeRaw || "Invalid code. Please try again.";
+    case "USER_ACTION_REJECTED":
+      return safeRaw || "Verification cancelled";
+    case "USER_ACTION_EXPIRED":
+      return safeRaw || "Verification expired";
+    case "USER_ACTION_RESENT":
+      return safeRaw || "Verification code resent";
+    case "USER_ACTION_FAILED":
+      return safeRaw || "Verification failed";
+    default:
+      return safeRaw || raw || eventType;
+  }
+}
 function workingPhaseDetailForDisplay(raw) {
   const t = raw.trim();
   if (!t) return "";
@@ -198,290 +223,8 @@ function extractResponseContent(response) {
   }
   return "";
 }
-function completeLastInProgressStep(steps) {
-  for (let i = steps.length - 1; i >= 0; i--) {
-    if (steps[i].status === "in_progress") {
-      steps[i].status = "completed";
-      return;
-    }
-  }
-}
-function processStreamEvent(event, state) {
-  const eventType = event.eventType;
-  if (typeof eventType === "string" && eventType.toUpperCase() === "KEEP_ALIVE") {
-    return state;
-  }
-  const message = getEventMessage(event);
-  if (eventType !== "INTENT_THINKING" && eventType !== "INTENT_THINKING_CONT") {
-    if (state.currentThinkingStepId) {
-      const thinkingStep = state.steps.find((s) => s.id === state.currentThinkingStepId);
-      if (thinkingStep) {
-        thinkingStep.isThinking = false;
-      }
-      state.currentThinkingStepId = void 0;
-    }
-    state.activeThinkingText = void 0;
-  }
-  if (eventType === "COMPLETED" || eventType === "WORKFLOW_COMPLETED") {
-    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.accumulatedContent = content;
-      state.finalData = event.response ?? event.trace;
-      state.hasError = false;
-      state.errorMessage = "";
-    } else {
-      state.hasError = true;
-      state.errorMessage = "WORKFLOW_FAILED";
-    }
-  }
-  if (eventType === "STARTED" || eventType === "WORKFLOW_STARTED") ; else if (eventType === "COMPLETED" || eventType === "WORKFLOW_COMPLETED") {
-    state.steps.forEach((step) => {
-      if (step.status === "in_progress") {
-        step.status = "completed";
-      }
-    });
-  } else if (eventType === "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";
-    }
-  } else if (eventType === "ERROR" || eventType === "WORKFLOW_ERROR") {
-    state.hasError = true;
-    state.errorMessage = message || event.errorMessage || "An error occurred";
-  } else if (eventType === "ORCHESTRATOR_COMPLETED") {
-    state.inOrchestratorPhase = false;
-    const orchestratorStep = state.steps.find(
-      (s) => s.eventType === "ORCHESTRATOR_THINKING" && s.status === "in_progress"
-    );
-    if (orchestratorStep) {
-      orchestratorStep.status = "completed";
-      if (event.elapsedMs) {
-        orchestratorStep.elapsedMs = event.elapsedMs;
-      }
-      if (orchestratorStep.id === state.currentExecutingStepId) {
-        state.currentExecutingStepId = void 0;
-      }
-    }
-  } else if (eventType === "INTENT_COMPLETED") {
-    const intentStep = state.steps.find(
-      (s) => s.eventType === "INTENT_STARTED" && s.status === "in_progress"
-    );
-    if (intentStep) {
-      intentStep.status = "completed";
-      if (event.elapsedMs) {
-        intentStep.elapsedMs = event.elapsedMs;
-      }
-      if (intentStep.id === state.currentExecutingStepId) {
-        state.currentExecutingStepId = void 0;
-      }
-    }
-  } else if (eventType === "AGGREGATOR_COMPLETED") {
-    state.inAggregatorPhase = false;
-    const aggregatorStep = state.steps.find(
-      (s) => s.eventType === "AGGREGATOR_THINKING" && s.status === "in_progress"
-    );
-    if (aggregatorStep) {
-      aggregatorStep.status = "completed";
-      if (event.elapsedMs) {
-        aggregatorStep.elapsedMs = event.elapsedMs;
-      }
-      if (aggregatorStep.id === state.currentExecutingStepId) {
-        state.currentExecutingStepId = void 0;
-      }
-    }
-  } else if (eventType === "ORCHESTRATOR_THINKING" || eventType === "INTENT_STARTED" || eventType === "INTENT_PROGRESS" || eventType === "AGGREGATOR_THINKING") {
-    if (eventType === "ORCHESTRATOR_THINKING") {
-      state.inOrchestratorPhase = true;
-    }
-    if (eventType === "AGGREGATOR_THINKING") {
-      state.inAggregatorPhase = true;
-    }
-    if (eventType === "INTENT_PROGRESS") {
-      const intentStep = state.steps.find(
-        (s) => s.eventType === "INTENT_STARTED" && s.status === "in_progress"
-      );
-      if (intentStep) {
-        intentStep.message = message;
-        state.currentExecutingStepId = intentStep.id;
-      } else {
-        const stepId = `step-${state.stepCounter++}`;
-        state.steps.push({
-          id: stepId,
-          eventType: "INTENT_STARTED",
-          message,
-          status: "in_progress",
-          timestamp: Date.now(),
-          elapsedMs: event.elapsedMs
-        });
-        state.currentExecutingStepId = stepId;
-      }
-    } else {
-      const stepId = `step-${state.stepCounter++}`;
-      state.steps.push({
-        id: stepId,
-        eventType,
-        message,
-        status: "in_progress",
-        timestamp: Date.now(),
-        elapsedMs: event.elapsedMs
-      });
-      state.currentExecutingStepId = stepId;
-    }
-  } else if (eventType === "USER_ACTION_REQUIRED") {
-    completeLastInProgressStep(state.steps);
-    if (event.userActionRequest) {
-      state.userActionRequest = {
-        userActionId: event.userActionRequest.userActionId,
-        userActionType: event.userActionRequest.userActionType,
-        message: event.userActionRequest.message,
-        requestedSchema: event.userActionRequest.requestedSchema,
-        metadata: event.userActionRequest.metadata
-      };
-    }
-    state.userActionPending = true;
-    const stepId = `step-${state.stepCounter++}`;
-    state.steps.push({
-      id: stepId,
-      eventType,
-      message,
-      status: "in_progress",
-      timestamp: Date.now(),
-      elapsedMs: event.elapsedMs
-    });
-    state.currentExecutingStepId = stepId;
-  } else if (eventType === "USER_ACTION_SUCCESS") {
-    completeLastInProgressStep(state.steps);
-    state.userActionRequest = void 0;
-    state.userActionPending = false;
-    state.userActionResult = "approved";
-    const stepId = `step-${state.stepCounter++}`;
-    state.steps.push({
-      id: stepId,
-      eventType,
-      message,
-      status: "completed",
-      timestamp: Date.now(),
-      elapsedMs: event.elapsedMs
-    });
-  } else if (eventType === "USER_ACTION_INVALID") {
-    completeLastInProgressStep(state.steps);
-    const errorStepId = `step-${state.stepCounter++}`;
-    state.steps.push({
-      id: errorStepId,
-      eventType,
-      message,
-      status: "error",
-      timestamp: Date.now(),
-      elapsedMs: event.elapsedMs
-    });
-    const retryStepId = `step-${state.stepCounter++}`;
-    state.steps.push({
-      id: retryStepId,
-      eventType: "USER_ACTION_REQUIRED",
-      message: "Waiting for verification...",
-      status: "in_progress",
-      timestamp: Date.now()
-    });
-    state.currentExecutingStepId = retryStepId;
-  } else if (eventType === "USER_ACTION_EXPIRED") {
-    completeLastInProgressStep(state.steps);
-    state.userActionRequest = void 0;
-    state.userActionPending = false;
-    const stepId = `step-${state.stepCounter++}`;
-    state.steps.push({
-      id: stepId,
-      eventType,
-      message,
-      status: "error",
-      timestamp: Date.now(),
-      elapsedMs: event.elapsedMs
-    });
-  } else if (eventType === "USER_ACTION_REJECTED") {
-    completeLastInProgressStep(state.steps);
-    state.userActionRequest = void 0;
-    state.userActionPending = false;
-    state.userActionResult = "rejected";
-    const stepId = `step-${state.stepCounter++}`;
-    state.steps.push({
-      id: stepId,
-      eventType,
-      message,
-      status: "completed",
-      timestamp: Date.now(),
-      elapsedMs: event.elapsedMs
-    });
-  } else if (eventType === "USER_ACTION_RESENT") {
-    const stepId = `step-${state.stepCounter++}`;
-    state.steps.push({
-      id: stepId,
-      eventType,
-      message,
-      status: "completed",
-      timestamp: Date.now(),
-      elapsedMs: event.elapsedMs
-    });
-  } else if (eventType === "USER_ACTION_FAILED") {
-    completeLastInProgressStep(state.steps);
-    state.userActionRequest = void 0;
-    state.userActionPending = false;
-    const stepId = `step-${state.stepCounter++}`;
-    state.steps.push({
-      id: stepId,
-      eventType,
-      message,
-      status: "error",
-      timestamp: Date.now(),
-      elapsedMs: event.elapsedMs
-    });
-  } else if (eventType === "INTENT_THINKING") {
-    if (state.currentThinkingStepId) {
-      const prev = state.steps.find((s) => s.id === state.currentThinkingStepId);
-      if (prev) prev.isThinking = false;
-    }
-    const lastInProgress = [...state.steps].reverse().find((s) => s.status === "in_progress");
-    if (lastInProgress) {
-      lastInProgress.thinkingText = "";
-      lastInProgress.isThinking = true;
-      state.currentThinkingStepId = lastInProgress.id;
-    } else {
-      state.currentThinkingStepId = void 0;
-    }
-    if (state.allThinkingText) state.allThinkingText += "\n\n";
-    if (!state.inOrchestratorPhase && !state.inAggregatorPhase) {
-      state.activeThinkingText = "";
-    }
-  } else if (eventType === "INTENT_THINKING_CONT") {
-    const delta = event.message || "";
-    if (!delta) return state;
-    if (state.currentThinkingStepId) {
-      const step = state.steps.find((s) => s.id === state.currentThinkingStepId);
-      if (step) {
-        step.thinkingText = (step.thinkingText || "") + delta;
-      }
-    }
-    state.allThinkingText += delta;
-    if (!state.inOrchestratorPhase && !state.inAggregatorPhase) {
-      if (state.activeThinkingText == null) state.activeThinkingText = "";
-      state.activeThinkingText += delta;
-    }
-  }
-  return state;
-}
 
 // src/utils/messageStateManager.ts
-var FRIENDLY_ERROR_MESSAGE = "Oops, something went wrong. Please try again.";
 function buildFormattedThinking(steps, allThinkingText) {
   const parts = [];
   const safeSteps = steps ?? [];
@@ -538,91 +281,32 @@ function buildFormattedThinking(steps, allThinkingText) {
         break;
       case "USER_ACTION_REQUIRED":
         parts.push("**Verification Required**");
-        if (step.message) parts.push(step.message);
+        if (step.message) {
+          parts.push(getUserActionDisplayMessage(step.eventType, step.message));
+        }
         break;
       case "USER_ACTION_SUCCESS":
-        parts.push(`\u2713 ${step.message || "Verification successful"}`);
+        parts.push(`\u2713 ${getUserActionDisplayMessage(step.eventType, step.message)}`);
         break;
       case "USER_ACTION_REJECTED":
-        parts.push(`\u2717 ${step.message || "Verification rejected"}`);
+        parts.push(getUserActionDisplayMessage(step.eventType, step.message));
         break;
       case "USER_ACTION_EXPIRED":
-        parts.push(`\u2717 ${step.message || "Verification expired"}`);
+        parts.push(`\u2717 ${getUserActionDisplayMessage(step.eventType, step.message)}`);
+        break;
+      case "USER_ACTION_INVALID":
+        parts.push(`\u2717 ${getUserActionDisplayMessage(step.eventType, step.message)}`);
+        break;
+      case "USER_ACTION_RESENT":
+        parts.push(getUserActionDisplayMessage(step.eventType, step.message));
         break;
       case "USER_ACTION_FAILED":
-        parts.push(`\u2717 ${step.message || "Verification failed"}`);
+        parts.push(`\u2717 ${getUserActionDisplayMessage(step.eventType, step.message)}`);
         break;
     }
   }
   return parts.length > 0 ? parts.join("\n") : allThinkingText;
 }
-function createStreamingMessageUpdate(state) {
-  const hasCompletedContent = state.accumulatedContent && state.finalData !== void 0;
-  const steps = state.hasError ? [] : [...state.steps];
-  const allThinking = state.hasError ? void 0 : state.allThinkingText;
-  return {
-    streamingContent: state.hasError ? FRIENDLY_ERROR_MESSAGE : hasCompletedContent ? state.accumulatedContent : "",
-    content: state.hasError ? FRIENDLY_ERROR_MESSAGE : "",
-    currentMessage: state.hasError ? void 0 : state.currentMessage,
-    streamProgress: state.hasError ? "error" : "processing",
-    isError: state.hasError,
-    errorDetails: state.hasError ? state.errorMessage : void 0,
-    executionId: state.executionId,
-    sessionId: state.sessionId,
-    steps,
-    currentExecutingStepId: state.hasError ? void 0 : state.currentExecutingStepId,
-    isCancelled: false,
-    userActionResult: state.userActionResult,
-    activeThinkingText: state.hasError ? void 0 : state.activeThinkingText,
-    allThinkingText: allThinking,
-    formattedThinkingText: state.hasError ? void 0 : buildFormattedThinking(steps, allThinking || "")
-  };
-}
-function createErrorMessageUpdate(error, state) {
-  const isAborted = error.name === "AbortError";
-  return {
-    isStreaming: false,
-    streamProgress: isAborted ? "processing" : "error",
-    isError: !isAborted,
-    isCancelled: isAborted,
-    errorDetails: isAborted ? void 0 : error.message,
-    content: isAborted ? state.accumulatedContent || "" : state.accumulatedContent || FRIENDLY_ERROR_MESSAGE,
-    // Preserve currentMessage when cancelled so UI can show it
-    currentMessage: isAborted ? state.currentMessage || "Thinking..." : void 0,
-    steps: [...state.steps].map((step) => {
-      if (step.status === "in_progress" && isAborted) {
-        return { ...step, status: "pending" };
-      }
-      return step;
-    }),
-    currentExecutingStepId: void 0
-  };
-}
-function createFinalMessage(streamingId, state) {
-  const steps = state.hasError ? [] : [...state.steps];
-  const allThinking = state.hasError ? void 0 : state.allThinkingText;
-  return {
-    id: streamingId,
-    sessionId: state.sessionId,
-    role: "assistant",
-    content: state.hasError ? FRIENDLY_ERROR_MESSAGE : state.accumulatedContent || "",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    isStreaming: false,
-    streamProgress: state.hasError ? "error" : "completed",
-    isError: state.hasError,
-    errorDetails: state.hasError ? state.errorMessage : void 0,
-    executionId: state.executionId,
-    tracingData: state.finalData,
-    steps,
-    isCancelled: false,
-    currentExecutingStepId: void 0,
-    userActionResult: state.userActionResult,
-    activeThinkingText: void 0,
-    allThinkingText: allThinking,
-    formattedThinkingText: state.hasError ? void 0 : buildFormattedThinking(steps, allThinking || ""),
-    isResolvingImages: state.hasError ? void 0 : state.isResolvingImages
-  };
-}
 function createCancelledMessageUpdate(steps, currentMessage) {
   const updatedSteps = steps.map((step) => {
     if (step.status === "in_progress") {
@@ -642,35 +326,44 @@ function createCancelledMessageUpdate(steps, currentMessage) {
 
 // src/utils/requestBuilder.ts
 function buildRequestBody(config, userMessage, sessionId) {
-  const sessionOwner = config.sessionParams;
-  const sessionAttributes = sessionOwner?.attributes && Object.keys(sessionOwner.attributes).length > 0 ? sessionOwner.attributes : void 0;
+  const owner = config.session?.owner;
+  const sessionAttributes = owner?.attributes && Object.keys(owner.attributes).length > 0 ? owner.attributes : void 0;
   return {
-    workflowName: config.workflowName,
+    workflowName: config.workflow.name,
     userInput: userMessage,
     sessionId,
-    sessionOwnerId: sessionOwner?.id || "",
-    sessionOwnerLabel: sessionOwner?.name || "",
+    sessionOwnerId: owner?.id || "",
+    sessionOwnerLabel: owner?.name || "",
     sessionAttributes,
     options: {
       clientTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone
     }
   };
 }
+function getStageParamName(config) {
+  return config.api.stageQueryParam ?? "stage";
+}
+function getStage(config) {
+  return config.workflow.stage ?? "DEV";
+}
 function buildStreamingUrl(config) {
   const endpoint = config.api.streamEndpoint || "/api/workflows/ask/stream";
-  const stage = config.stage || "DEV";
-  const stageParamName = config.stageQueryParam ?? "stage";
-  const queryParams = new URLSearchParams({ [stageParamName]: stage });
-  if (config.workflowVersion !== void 0) {
-    queryParams.append("workflowVersion", String(config.workflowVersion));
+  const queryParams = new URLSearchParams({
+    [getStageParamName(config)]: getStage(config)
+  });
+  if (config.workflow.version !== void 0) {
+    queryParams.append("workflowVersion", String(config.workflow.version));
   }
   return `${config.api.baseUrl}${endpoint}?${queryParams.toString()}`;
 }
-function buildUserActionUrl(config, userActionId, action) {
+function deriveBasePath(config) {
   const endpoint = config.api.streamEndpoint || "/api/workflows/ask/stream";
   const [endpointPath] = endpoint.split("?");
-  const normalizedEndpointPath = endpointPath.replace(/\/+$/, "");
-  const basePath = normalizedEndpointPath.endsWith("/stream") ? normalizedEndpointPath.slice(0, -"/stream".length) : normalizedEndpointPath;
+  const normalized = endpointPath.replace(/\/+$/, "");
+  return normalized.endsWith("/stream") ? normalized.slice(0, -"/stream".length) : normalized;
+}
+function buildUserActionUrl(config, userActionId, action) {
+  const basePath = deriveBasePath(config);
   const encodedUserActionId = encodeURIComponent(userActionId);
   return `${config.api.baseUrl}${basePath}/user-action/${encodedUserActionId}/${action}`;
 }
@@ -678,21 +371,23 @@ function buildResolveImagesUrl(config) {
   if (config.api.resolveImagesEndpoint) {
     return `${config.api.baseUrl}${config.api.resolveImagesEndpoint}`;
   }
-  const streamEndpoint = config.api.streamEndpoint || "/api/workflows/ask/stream";
-  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`;
+  return `${config.api.baseUrl}${deriveBasePath(config)}/resolve-image-urls`;
 }
 function buildRequestHeaders(config) {
-  const headers = {
-    ...config.api.headers
-  };
+  const headers = { ...config.api.headers };
   if (config.api.authToken) {
     headers.Authorization = `Bearer ${config.api.authToken}`;
   }
   return headers;
 }
+function buildScopeKey(config) {
+  return [
+    config.session?.userId ?? "",
+    config.workflow.id ?? "",
+    config.workflow.version ?? "",
+    config.workflow.stage ?? ""
+  ].join("|");
+}
 
 // src/utils/userActionClient.ts
 async function sendUserActionRequest(config, userActionId, action, data) {
@@ -708,683 +403,96 @@ async function sendUserActionRequest(config, userActionId, action, data) {
   if (!response.ok) {
     const errorText = await response.text();
     throw new Error(`HTTP ${response.status}: ${errorText}`);
-  }
-  return await response.json();
-}
-async function submitUserAction(config, userActionId, data) {
-  return sendUserActionRequest(config, userActionId, "submit", data);
-}
-async function cancelUserAction(config, userActionId) {
-  return sendUserActionRequest(config, userActionId, "cancel");
-}
-async function resendUserAction(config, userActionId) {
-  return sendUserActionRequest(config, userActionId, "resend");
-}
-
-// src/utils/chatStore.ts
-var memoryStore = /* @__PURE__ */ new Map();
-var chatStore = {
-  get(key) {
-    return memoryStore.get(key) ?? [];
-  },
-  set(key, messages) {
-    memoryStore.set(key, messages);
-  },
-  delete(key) {
-    memoryStore.delete(key);
-  }
-};
-
-// src/utils/activeStreamStore.ts
-var streams = /* @__PURE__ */ new Map();
-var activeStreamStore = {
-  has(key) {
-    return streams.has(key);
-  },
-  get(key) {
-    const entry = streams.get(key);
-    if (!entry) return null;
-    return { messages: entry.messages, isWaiting: entry.isWaiting };
-  },
-  // Called before startStream — registers the controller and initial messages
-  start(key, abortController, initialMessages) {
-    const existing = streams.get(key);
-    streams.set(key, {
-      messages: initialMessages,
-      isWaiting: true,
-      abortController,
-      listeners: existing?.listeners ?? /* @__PURE__ */ new Set()
-    });
-  },
-  // Called by the stream on every event — applies the same updater pattern React uses
-  applyMessages(key, updater) {
-    const entry = streams.get(key);
-    if (!entry) return;
-    const next = typeof updater === "function" ? updater(entry.messages) : updater;
-    entry.messages = next;
-    entry.listeners.forEach((l) => l(next, entry.isWaiting));
-  },
-  setWaiting(key, waiting) {
-    const entry = streams.get(key);
-    if (!entry) return;
-    entry.isWaiting = waiting;
-    entry.listeners.forEach((l) => l(entry.messages, waiting));
-  },
-  // Called when stream completes — persists to chatStore and cleans up
-  complete(key) {
-    const entry = streams.get(key);
-    if (!entry) return;
-    entry.isWaiting = false;
-    entry.listeners.forEach((l) => l(entry.messages, false));
-    const toSave = entry.messages.filter((m) => !m.isStreaming);
-    if (toSave.length > 0) chatStore.set(key, toSave);
-    streams.delete(key);
-  },
-  // Subscribe — returns unsubscribe fn. Component calls this on mount, cleanup on unmount.
-  subscribe(key, listener) {
-    const entry = streams.get(key);
-    if (!entry) return () => {
-    };
-    entry.listeners.add(listener);
-    return () => {
-      streams.get(key)?.listeners.delete(listener);
-    };
-  },
-  // Explicit user cancel — aborts the controller and removes the entry
-  abort(key) {
-    const entry = streams.get(key);
-    if (!entry) return;
-    entry.abortController.abort();
-    streams.delete(key);
-  }
-};
-
-// src/utils/ragImageResolver.ts
-var RAG_IMAGE_REGEX = /\/api\/rag\/chunks\/[^"'\s]+\/image/;
-function hasRagImages(content) {
-  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;
-}
-
-// src/hooks/useStreamManager.ts
-function useStreamManager(config, callbacks, setMessages, setIsWaitingForResponse) {
-  const abortControllerRef = react.useRef(null);
-  const configRef = react.useRef(config);
-  configRef.current = config;
-  const callbacksRef = react.useRef(callbacks);
-  callbacksRef.current = callbacks;
-  const startStream = react.useCallback(
-    async (userMessage, streamingId, sessionId, externalAbortController) => {
-      abortControllerRef.current?.abort();
-      const abortController = externalAbortController ?? new AbortController();
-      abortControllerRef.current = abortController;
-      const state = {
-        accumulatedContent: "",
-        executionId: void 0,
-        currentSessionId: void 0,
-        finalData: void 0,
-        steps: [],
-        stepCounter: 0,
-        currentExecutingStepId: void 0,
-        currentThinkingStepId: void 0,
-        hasError: false,
-        errorMessage: "",
-        userActionRequest: void 0,
-        userActionPending: false,
-        userActionResult: void 0,
-        allThinkingText: "",
-        inOrchestratorPhase: false,
-        inAggregatorPhase: false
-      };
-      const THROTTLE_MS = 120;
-      const CHARS_PER_TICK = 10;
-      const displayedLengthRef = { current: 0 };
-      let throttleIntervalId = null;
-      const getActiveStepMessage = () => state.steps.find((s) => s.id === state.currentExecutingStepId)?.message || [...state.steps].reverse().find((s) => s.status === "in_progress")?.message;
-      const advanceDisplayLength = (full) => {
-        let newLen = Math.min(displayedLengthRef.current + CHARS_PER_TICK, full.length);
-        if (newLen > 0 && newLen < full.length) {
-          const code = full.charCodeAt(newLen - 1);
-          if (code >= 55296 && code <= 56319) {
-            newLen = Math.min(newLen + 1, full.length);
-          }
-        }
-        displayedLengthRef.current = newLen;
-      };
-      const clearThrottle = () => {
-        if (throttleIntervalId != null) {
-          clearInterval(throttleIntervalId);
-          throttleIntervalId = null;
-        }
-      };
-      abortController.signal.addEventListener("abort", clearThrottle, { once: true });
-      const ensureThrottle = () => {
-        if (throttleIntervalId != null) return;
-        throttleIntervalId = setInterval(() => {
-          if (abortController.signal.aborted) {
-            clearThrottle();
-            return;
-          }
-          const full = state.activeThinkingText ?? "";
-          if (displayedLengthRef.current < full.length) {
-            advanceDisplayLength(full);
-            const displayText = full.slice(0, displayedLengthRef.current);
-            setMessages(
-              (prev) => prev.map(
-                (msg) => msg.id === streamingId ? {
-                  ...msg,
-                  ...createStreamingMessageUpdate({
-                    ...state,
-                    activeThinkingText: displayText,
-                    currentMessage: getActiveStepMessage() || "Thinking..."
-                  })
-                } : msg
-              )
-            );
-          }
-        }, THROTTLE_MS);
-      };
-      const currentConfig = configRef.current;
-      const requestBody = buildRequestBody(currentConfig, userMessage, sessionId);
-      const url = buildStreamingUrl(currentConfig);
-      const headers = buildRequestHeaders(currentConfig);
-      try {
-        await streamWorkflowEvents(url, requestBody, headers, {
-          signal: abortController.signal,
-          onEvent: (event) => {
-            if (abortController.signal.aborted) {
-              return;
-            }
-            if (typeof event.eventType === "string" && event.eventType.toUpperCase() === "KEEP_ALIVE") {
-              if (event.executionId) state.executionId = event.executionId;
-              if (event.sessionId) state.currentSessionId = event.sessionId;
-              return;
-            }
-            if (event.executionId) state.executionId = event.executionId;
-            if (event.sessionId) state.currentSessionId = event.sessionId;
-            const activeThinkingLengthBeforeProcess = state.activeThinkingText?.length ?? 0;
-            processStreamEvent(event, state);
-            const eventType = event.eventType;
-            if (eventType === "INTENT_THINKING") {
-              displayedLengthRef.current = 0;
-              ensureThrottle();
-            } else if (eventType !== "INTENT_THINKING_CONT") {
-              displayedLengthRef.current = activeThinkingLengthBeforeProcess;
-              clearThrottle();
-            }
-            if (eventType === "USER_ACTION_REQUIRED" && state.userActionRequest) {
-              callbacksRef.current.onUserActionRequired?.(state.userActionRequest);
-            } else if (eventType.startsWith("USER_ACTION_") && eventType !== "USER_ACTION_REQUIRED") {
-              const msg = event.message?.trim() || event.errorMessage?.trim() || getEventMessage(event);
-              callbacksRef.current.onUserActionEvent?.(eventType, msg);
-            }
-            const isIntentThinkingEvent = eventType === "INTENT_THINKING" || eventType === "INTENT_THINKING_CONT";
-            const rawMessage = event.message?.trim() || event.errorMessage?.trim();
-            const currentMessage = isIntentThinkingEvent ? getActiveStepMessage() || "Thinking..." : rawMessage || (event.eventType?.startsWith("USER_ACTION_") ? getEventMessage(event) : getActiveStepMessage() || getEventMessage(event));
-            const displayThinking = state.activeThinkingText != null ? state.activeThinkingText.slice(0, displayedLengthRef.current) : state.activeThinkingText;
-            setMessages(
-              (prev) => prev.map(
-                (msg) => msg.id === streamingId ? {
-                  ...msg,
-                  ...createStreamingMessageUpdate({
-                    ...state,
-                    activeThinkingText: displayThinking,
-                    currentMessage
-                  })
-                } : msg
-              )
-            );
-          },
-          onError: (error) => {
-            clearThrottle();
-            setIsWaitingForResponse(false);
-            if (error.name !== "AbortError") {
-              callbacksRef.current.onError?.(error);
-            }
-            if (state.userActionPending) {
-              state.userActionPending = false;
-              state.userActionRequest = void 0;
-              callbacksRef.current.onUserActionEvent?.(
-                "USER_ACTION_FAILED",
-                "Connection lost. Please try again."
-              );
-            }
-            setMessages(
-              (prev) => prev.map(
-                (msg) => msg.id === streamingId ? {
-                  ...msg,
-                  ...createErrorMessageUpdate(error, state)
-                } : msg
-              )
-            );
-          },
-          onComplete: () => {
-            clearThrottle();
-            setIsWaitingForResponse(false);
-            if (state.userActionPending) {
-              state.userActionPending = false;
-              state.userActionRequest = void 0;
-              callbacksRef.current.onUserActionEvent?.(
-                "USER_ACTION_FAILED",
-                "Verification could not be completed."
-              );
-            }
-            if (state.currentSessionId && state.currentSessionId !== sessionId) {
-              callbacksRef.current.onSessionIdChange?.(state.currentSessionId);
-            }
-            const needsImageResolve = !state.hasError && !abortController.signal.aborted && hasRagImages(state.accumulatedContent);
-            const finalMessage = createFinalMessage(streamingId, {
-              ...state,
-              sessionId: state.currentSessionId || sessionId,
-              isResolvingImages: needsImageResolve
-            });
-            setMessages(
-              (prev) => prev.map(
-                (msg) => msg.id === streamingId ? finalMessage : msg
-              )
-            );
-            callbacksRef.current.onStreamComplete?.(finalMessage);
-          }
-        });
-        clearThrottle();
-        const shouldResolveImages = !abortController.signal.aborted && !state.hasError && hasRagImages(state.accumulatedContent);
-        if (shouldResolveImages) {
-          await waitForNextPaint(abortController.signal);
-        }
-        if (shouldResolveImages && !abortController.signal.aborted) {
-          try {
-            const resolvedContent = await resolveRagImageUrls(
-              currentConfig,
-              state.accumulatedContent,
-              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.currentSessionId;
-      } catch (error) {
-        clearThrottle();
-        setIsWaitingForResponse(false);
-        if (error.name !== "AbortError") {
-          callbacksRef.current.onError?.(error);
-        }
-        if (state.userActionPending) {
-          state.userActionPending = false;
-          state.userActionRequest = void 0;
-          callbacksRef.current.onUserActionEvent?.(
-            "USER_ACTION_FAILED",
-            "Connection lost. Please try again."
-          );
-        }
-        setMessages(
-          (prev) => prev.map(
-            (msg) => msg.id === streamingId ? {
-              ...msg,
-              ...createErrorMessageUpdate(error, state)
-            } : msg
-          )
-        );
-        return state.currentSessionId;
-      }
-    },
-    [setMessages, setIsWaitingForResponse]
-  );
-  const cancelStream = react.useCallback(() => {
-    abortControllerRef.current?.abort();
-  }, []);
-  return {
-    startStream,
-    cancelStream,
-    abortControllerRef
-  };
-}
-
-// src/hooks/useChat.ts
-function useChat(config, callbacks = {}) {
-  const [messages, setMessages] = react.useState(() => {
-    if (config.userId) return chatStore.get(config.userId);
-    return config.initialMessages ?? [];
-  });
-  const [isWaitingForResponse, setIsWaitingForResponse] = react.useState(false);
-  const sessionIdRef = react.useRef(
-    config.userId ? chatStore.get(config.userId).find((m) => m.sessionId)?.sessionId ?? config.initialSessionId ?? void 0 : config.initialSessionId ?? void 0
-  );
-  const prevUserIdRef = 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 { userId } = configRef.current;
-      if (userId && activeStreamStore.has(userId)) {
-        activeStreamStore.applyMessages(userId, updater);
-      }
-      setMessages(updater);
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    []
-  );
-  const storeAwareSetIsWaiting = react.useCallback(
-    (waiting) => {
-      const { userId } = configRef.current;
-      if (userId && activeStreamStore.has(userId)) {
-        activeStreamStore.setWaiting(userId, waiting);
-      }
-      setIsWaitingForResponse(waiting);
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    []
-  );
-  const [userActionState, setUserActionState] = react.useState({
-    request: null,
-    result: null,
-    clearOtpTrigger: 0
-  });
-  const userActionStateRef = react.useRef(userActionState);
-  userActionStateRef.current = userActionState;
-  const wrappedCallbacks = react.useMemo(() => ({
-    ...callbacksRef.current,
-    onMessageSent: (message) => callbacksRef.current.onMessageSent?.(message),
-    onStreamStart: () => callbacksRef.current.onStreamStart?.(),
-    onStreamComplete: (message) => callbacksRef.current.onStreamComplete?.(message),
-    onError: (error) => callbacksRef.current.onError?.(error),
-    onExecutionTraceClick: (data) => callbacksRef.current.onExecutionTraceClick?.(data),
-    onSessionIdChange: (sessionId) => callbacksRef.current.onSessionIdChange?.(sessionId),
-    onUserActionRequired: (request) => {
-      setUserActionState((prev) => ({ ...prev, request, result: null }));
-      callbacksRef.current.onUserActionRequired?.(request);
-    },
-    onUserActionEvent: (eventType, message) => {
-      switch (eventType) {
-        case "USER_ACTION_SUCCESS":
-          setUserActionState((prev) => ({ ...prev, request: null, result: "approved" }));
-          break;
-        case "USER_ACTION_REJECTED":
-          setUserActionState((prev) => ({ ...prev, request: null, result: "rejected" }));
-          break;
-        case "USER_ACTION_EXPIRED":
-        case "USER_ACTION_FAILED":
-          setUserActionState((prev) => ({ ...prev, request: null }));
-          break;
-        case "USER_ACTION_INVALID":
-          setUserActionState((prev) => ({ ...prev, clearOtpTrigger: prev.clearOtpTrigger + 1 }));
-          break;
-      }
-      callbacksRef.current.onUserActionEvent?.(eventType, message);
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }), []);
-  const { startStream, cancelStream: cancelStreamManager, abortControllerRef } = useStreamManager(
-    config,
-    wrappedCallbacks,
-    storeAwareSetMessages,
-    storeAwareSetIsWaiting
-  );
-  const sendMessage = react.useCallback(
-    async (userMessage) => {
-      if (!userMessage.trim()) return;
-      if (!sessionIdRef.current && configRef.current.autoGenerateSessionId !== false) {
-        sessionIdRef.current = generateId();
-        callbacksRef.current.onSessionIdChange?.(sessionIdRef.current);
-      }
-      const userMessageId = `user-${Date.now()}`;
-      const userMsg = {
-        id: userMessageId,
-        sessionId: sessionIdRef.current,
-        role: "user",
-        content: userMessage,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      setMessages((prev) => [...prev, userMsg]);
-      callbacksRef.current.onMessageSent?.(userMessage);
-      setIsWaitingForResponse(true);
-      callbacksRef.current.onStreamStart?.();
-      const streamingId = `assistant-${Date.now()}`;
-      const streamingMsg = {
-        id: streamingId,
-        sessionId: sessionIdRef.current,
-        role: "assistant",
-        content: "",
-        streamingContent: "",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        isStreaming: true,
-        streamProgress: "started",
-        steps: [],
-        currentExecutingStepId: void 0,
-        isCancelled: false,
-        currentMessage: void 0
-      };
-      setMessages((prev) => [...prev, streamingMsg]);
-      const abortController = new AbortController();
-      const { userId } = configRef.current;
-      if (userId) {
-        const initialMessages = [...messagesRef.current, userMsg, streamingMsg];
-        activeStreamStore.start(userId, abortController, initialMessages);
-      }
-      const newSessionId = await startStream(
-        userMessage,
-        streamingId,
-        sessionIdRef.current,
-        abortController
-      );
-      if (userId) {
-        activeStreamStore.complete(userId);
-      }
-      if (!abortController.signal.aborted && newSessionId && newSessionId !== sessionIdRef.current) {
-        sessionIdRef.current = newSessionId;
-      }
-    },
-    [startStream]
-  );
-  const clearMessages = 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(() => {
-    if (configRef.current.userId) {
-      activeStreamStore.abort(configRef.current.userId);
-    }
-    cancelStreamManager();
-    setIsWaitingForResponse(false);
-    setUserActionState((prev) => ({ ...prev, request: null, result: null }));
-    setMessages(
-      (prev) => prev.map((msg) => {
-        if (msg.isStreaming) {
-          return {
-            ...msg,
-            ...createCancelledMessageUpdate(
-              msg.steps || [],
-              msg.currentMessage
-            )
-          };
-        }
-        return msg;
-      })
-    );
-  }, [cancelStreamManager]);
-  const resetSession = react.useCallback(() => {
-    if (configRef.current.userId) {
-      activeStreamStore.abort(configRef.current.userId);
-      chatStore.delete(configRef.current.userId);
-    }
-    setMessages([]);
-    sessionIdRef.current = void 0;
-    abortControllerRef.current?.abort();
-    setIsWaitingForResponse(false);
-    setUserActionState({ request: null, result: null, clearOtpTrigger: 0 });
-  }, []);
-  const getSessionId = react.useCallback(() => {
-    return sessionIdRef.current;
-  }, []);
-  const getMessages = react.useCallback(() => {
-    return messages;
-  }, [messages]);
-  const approveUserAction = react.useCallback(
-    async (otp) => {
-      const request = userActionStateRef.current.request;
-      if (!request) return;
-      try {
-        await submitUserAction(configRef.current, request.userActionId, { otp });
-      } catch (error) {
-        setUserActionState((prev) => ({
-          ...prev,
-          clearOtpTrigger: prev.clearOtpTrigger + 1
-        }));
-        callbacksRef.current.onError?.(error);
-        throw error;
-      }
-    },
-    []
-  );
-  const rejectUserAction = react.useCallback(async () => {
-    const request = userActionStateRef.current.request;
-    if (!request) return;
-    try {
-      setMessages((prev) => {
-        let lastStreamingIdx = -1;
-        for (let i = prev.length - 1; i >= 0; i--) {
-          if (prev[i].role === "assistant" && prev[i].isStreaming) {
-            lastStreamingIdx = i;
-            break;
-          }
-        }
-        if (lastStreamingIdx === -1) return prev;
-        return prev.map(
-          (msg, i) => i === lastStreamingIdx ? { ...msg, currentMessage: "Rejecting..." } : msg
-        );
-      });
-      await cancelUserAction(configRef.current, request.userActionId);
-    } catch (error) {
-      callbacksRef.current.onError?.(error);
-      throw error;
-    }
-  }, []);
-  const resendOtp = react.useCallback(async () => {
-    const request = userActionStateRef.current.request;
-    if (!request) return;
-    try {
-      await resendUserAction(configRef.current, request.userActionId);
-    } catch (error) {
-      callbacksRef.current.onError?.(error);
-      throw error;
-    }
-  }, []);
-  react.useEffect(() => {
-    const { userId } = config;
-    if (!userId) return;
-    const unsubscribe = activeStreamStore.subscribe(userId, (msgs, isWaiting) => {
-      setMessages(msgs);
-      setIsWaitingForResponse(isWaiting);
-    });
-    const active = activeStreamStore.get(userId);
-    if (active) {
-      setMessages(active.messages);
-      setIsWaitingForResponse(active.isWaiting);
-    }
-    return unsubscribe;
-  }, []);
-  react.useEffect(() => {
-    if (!config.userId) return;
-    const toSave = messages.filter((m) => !m.isStreaming);
-    if (toSave.length > 0) {
-      chatStore.set(config.userId, toSave);
-    }
-  }, [messages, 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({ request: null, result: null, clearOtpTrigger: 0 });
-    } else if (config.userId) {
-      const stored = chatStore.get(config.userId);
-      setMessages(stored);
-      sessionIdRef.current = stored.find((m) => m.sessionId)?.sessionId;
-    }
-  }, [config.userId]);
-  return {
-    messages,
-    sendMessage,
-    clearMessages,
-    prependMessages,
-    cancelStream,
-    resetSession,
-    getSessionId,
-    getMessages,
-    isWaitingForResponse,
-    sessionId: sessionIdRef.current,
-    // User action (OTP) state and methods
-    userActionState,
-    approveUserAction,
-    rejectUserAction,
-    resendOtp
-  };
+  }
+  return await response.json();
+}
+async function submitUserAction(config, userActionId, data) {
+  return sendUserActionRequest(config, userActionId, "submit", data);
+}
+async function cancelUserAction(config, userActionId) {
+  return sendUserActionRequest(config, userActionId, "cancel");
 }
+async function resendUserAction(config, userActionId) {
+  return sendUserActionRequest(config, userActionId, "resend");
+}
+
+// src/utils/chatStore.ts
+var memoryStore = /* @__PURE__ */ new Map();
+var chatStore = {
+  get(key) {
+    return memoryStore.get(key) ?? [];
+  },
+  set(key, messages) {
+    memoryStore.set(key, messages);
+  },
+  delete(key) {
+    memoryStore.delete(key);
+  }
+};
+
+// src/utils/activeStreamStore.ts
+var streams = /* @__PURE__ */ new Map();
+var activeStreamStore = {
+  has(key) {
+    return streams.has(key);
+  },
+  get(key) {
+    const entry = streams.get(key);
+    if (!entry) return null;
+    return { messages: entry.messages, isWaiting: entry.isWaiting };
+  },
+  // Called before startStream — registers the controller and initial messages
+  start(key, abortController, initialMessages) {
+    const existing = streams.get(key);
+    streams.set(key, {
+      messages: initialMessages,
+      isWaiting: true,
+      abortController,
+      listeners: existing?.listeners ?? /* @__PURE__ */ new Set()
+    });
+  },
+  // Called by the stream on every event — applies the same updater pattern React uses
+  applyMessages(key, updater) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    const next = typeof updater === "function" ? updater(entry.messages) : updater;
+    entry.messages = next;
+    entry.listeners.forEach((l) => l(next, entry.isWaiting));
+  },
+  setWaiting(key, waiting) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.isWaiting = waiting;
+    entry.listeners.forEach((l) => l(entry.messages, waiting));
+  },
+  // Called when stream completes — persists to chatStore and cleans up
+  complete(key) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.isWaiting = false;
+    entry.listeners.forEach((l) => l(entry.messages, false));
+    const toSave = entry.messages.filter((m) => !m.isStreaming);
+    if (toSave.length > 0) chatStore.set(key, toSave);
+    streams.delete(key);
+  },
+  // Subscribe — returns unsubscribe fn. Component calls this on mount, cleanup on unmount.
+  subscribe(key, listener) {
+    const entry = streams.get(key);
+    if (!entry) return () => {
+    };
+    entry.listeners.add(listener);
+    return () => {
+      streams.get(key)?.listeners.delete(listener);
+    };
+  },
+  // Explicit user cancel — aborts the controller and removes the entry
+  abort(key) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.abortController.abort();
+    streams.delete(key);
+  }
+};
 
 // src/utils/v2EventProcessor.ts
 function getEventText(event, field) {
@@ -1410,7 +518,7 @@ function addThinkingLine(state, header, detail) {
 function appendThinkingText(state, text) {
   state.formattedThinkingText += text;
 }
-function completeLastInProgressStep2(steps) {
+function completeLastInProgressStep(steps) {
   for (let i = steps.length - 1; i >= 0; i--) {
     if (steps[i].status === "in_progress") {
       steps[i].status = "completed";
@@ -1624,7 +732,7 @@ function processStreamEventV2(event, state) {
       break;
     }
     case "USER_ACTION_REQUIRED": {
-      completeLastInProgressStep2(state.steps);
+      completeLastInProgressStep(state.steps);
       if (event.userActionRequest) {
         state.userActionRequest = {
           userActionId: event.userActionRequest.userActionId,
@@ -1636,14 +744,18 @@ function processStreamEventV2(event, state) {
       }
       state.userActionPending = true;
       const req = event.userActionRequest;
+      const displayMessage = getUserActionDisplayMessage(
+        eventType,
+        req?.message || message
+      );
       if (req) {
-        addThinkingLine(state, "**Verification Required**", req.message || "Waiting for authorization...");
+        addThinkingLine(state, "**Verification Required**", displayMessage);
       }
       const stepId = `step-${state.stepCounter++}`;
       state.steps.push({
         id: stepId,
         eventType,
-        message,
+        message: displayMessage,
         status: "in_progress",
         timestamp: Date.now(),
         elapsedMs: event.elapsedMs
@@ -1653,8 +765,9 @@ function processStreamEventV2(event, state) {
       break;
     }
     case "USER_ACTION_SUCCESS": {
-      appendThinkingText(state, "\n\u2713 " + (event.message || "Verification successful"));
-      completeLastInProgressStep2(state.steps);
+      const displayMessage = getUserActionDisplayMessage(eventType, event.message);
+      appendThinkingText(state, "\n\u2713 " + displayMessage);
+      completeLastInProgressStep(state.steps);
       state.userActionRequest = void 0;
       state.userActionPending = false;
       state.userActionResult = "approved";
@@ -1662,7 +775,7 @@ function processStreamEventV2(event, state) {
       state.steps.push({
         id: stepId,
         eventType,
-        message,
+        message: displayMessage,
         status: "completed",
         timestamp: Date.now(),
         elapsedMs: event.elapsedMs
@@ -1671,12 +784,14 @@ function processStreamEventV2(event, state) {
       break;
     }
     case "USER_ACTION_INVALID": {
-      completeLastInProgressStep2(state.steps);
+      const displayMessage = getUserActionDisplayMessage(eventType, event.message);
+      appendThinkingText(state, "\n\u2717 " + displayMessage);
+      completeLastInProgressStep(state.steps);
       const errorStepId = `step-${state.stepCounter++}`;
       state.steps.push({
         id: errorStepId,
         eventType,
-        message,
+        message: displayMessage,
         status: "error",
         timestamp: Date.now(),
         elapsedMs: event.elapsedMs
@@ -1694,8 +809,9 @@ function processStreamEventV2(event, state) {
       break;
     }
     case "USER_ACTION_REJECTED": {
-      appendThinkingText(state, "\n\u2717 " + (event.message || "Verification rejected"));
-      completeLastInProgressStep2(state.steps);
+      const displayMessage = getUserActionDisplayMessage(eventType, event.message);
+      appendThinkingText(state, "\n" + displayMessage);
+      completeLastInProgressStep(state.steps);
       state.userActionRequest = void 0;
       state.userActionPending = false;
       state.userActionResult = "rejected";
@@ -1703,7 +819,7 @@ function processStreamEventV2(event, state) {
       state.steps.push({
         id: stepId,
         eventType,
-        message,
+        message: displayMessage,
         status: "completed",
         timestamp: Date.now(),
         elapsedMs: event.elapsedMs
@@ -1712,15 +828,16 @@ function processStreamEventV2(event, state) {
       break;
     }
     case "USER_ACTION_EXPIRED": {
-      appendThinkingText(state, "\n\u2717 " + (event.message || "Verification expired"));
-      completeLastInProgressStep2(state.steps);
+      const displayMessage = getUserActionDisplayMessage(eventType, event.message);
+      appendThinkingText(state, "\n\u2717 " + displayMessage);
+      completeLastInProgressStep(state.steps);
       state.userActionRequest = void 0;
       state.userActionPending = false;
       const stepId = `step-${state.stepCounter++}`;
       state.steps.push({
         id: stepId,
         eventType,
-        message,
+        message: displayMessage,
         status: "error",
         timestamp: Date.now(),
         elapsedMs: event.elapsedMs
@@ -1729,11 +846,13 @@ function processStreamEventV2(event, state) {
       break;
     }
     case "USER_ACTION_RESENT": {
+      const displayMessage = getUserActionDisplayMessage(eventType, event.message);
+      appendThinkingText(state, "\n" + displayMessage);
       const stepId = `step-${state.stepCounter++}`;
       state.steps.push({
         id: stepId,
         eventType,
-        message,
+        message: displayMessage,
         status: "completed",
         timestamp: Date.now(),
         elapsedMs: event.elapsedMs
@@ -1742,15 +861,19 @@ function processStreamEventV2(event, state) {
       break;
     }
     case "USER_ACTION_FAILED": {
-      appendThinkingText(state, "\n\u2717 " + (event.message || "Verification failed"));
-      completeLastInProgressStep2(state.steps);
+      const displayMessage = getUserActionDisplayMessage(
+        eventType,
+        event.message || event.errorMessage
+      );
+      appendThinkingText(state, "\n\u2717 " + displayMessage);
+      completeLastInProgressStep(state.steps);
       state.userActionRequest = void 0;
       state.userActionPending = false;
       const stepId = `step-${state.stepCounter++}`;
       state.steps.push({
         id: stepId,
         eventType,
-        message,
+        message: displayMessage,
         status: "error",
         timestamp: Date.now(),
         elapsedMs: event.elapsedMs
@@ -1781,8 +904,58 @@ function processStreamEventV2(event, state) {
   return state;
 }
 
+// src/utils/ragImageResolver.ts
+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;
+}
+
 // src/hooks/useStreamManagerV2.ts
-var FRIENDLY_ERROR_MESSAGE2 = "Oops, something went wrong. Please try again.";
+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);
@@ -1822,7 +995,10 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
             if (eventType === "USER_ACTION_REQUIRED" && state.userActionRequest) {
               callbacksRef.current.onUserActionRequired?.(state.userActionRequest);
             } else if (eventType.startsWith("USER_ACTION_") && eventType !== "USER_ACTION_REQUIRED") {
-              const msg = event.message?.trim() || event.errorMessage?.trim() || getEventMessage(event);
+              const msg = getUserActionDisplayMessage(
+                eventType,
+                event.message?.trim() || event.errorMessage?.trim() || getEventMessage(event)
+              );
               callbacksRef.current.onUserActionEvent?.(eventType, msg);
             }
             const activeStep = state.steps.find((s) => s.id === state.currentExecutingStepId);
@@ -1830,8 +1006,8 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
             const currentMessage = activeStep?.message || lastInProgressStep?.message || getEventMessage(event);
             if (state.hasError) {
               updateMessage({
-                streamingContent: FRIENDLY_ERROR_MESSAGE2,
-                content: FRIENDLY_ERROR_MESSAGE2,
+                streamingContent: FRIENDLY_ERROR_MESSAGE,
+                content: FRIENDLY_ERROR_MESSAGE,
                 streamProgress: "error",
                 isError: true,
                 errorDetails: state.errorMessage,
@@ -1881,7 +1057,7 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
                   isError: !isAborted,
                   isCancelled: isAborted,
                   errorDetails: isAborted ? void 0 : error.message,
-                  content: isAborted ? state.finalResponse || "" : state.finalResponse || FRIENDLY_ERROR_MESSAGE2,
+                  content: isAborted ? state.finalResponse || "" : state.finalResponse || FRIENDLY_ERROR_MESSAGE,
                   currentMessage: isAborted ? "Thinking..." : void 0,
                   formattedThinkingText: state.formattedThinkingText || void 0,
                   steps: [...state.steps].map((step) => {
@@ -1913,7 +1089,7 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
               id: streamingId,
               sessionId: state.sessionId || sessionId,
               role: "assistant",
-              content: state.hasError ? FRIENDLY_ERROR_MESSAGE2 : state.finalResponse || "",
+              content: state.hasError ? FRIENDLY_ERROR_MESSAGE : state.finalResponse || "",
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               isStreaming: false,
               streamProgress: state.hasError ? "error" : "completed",
@@ -1984,7 +1160,7 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
               isError: !isAborted,
               isCancelled: isAborted,
               errorDetails: isAborted ? void 0 : error.message,
-              content: isAborted ? state.finalResponse || "" : state.finalResponse || FRIENDLY_ERROR_MESSAGE2,
+              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) {
@@ -2011,45 +1187,199 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
   };
 }
 
+// src/utils/workflowUsersClient.ts
+var DEFAULT_SESSION_PAGE_SIZE = 20;
+var DEFAULT_CONVERSATION_PAGE_SIZE = 50;
+function getStageParamName2(config) {
+  return config.api.stageQueryParam ?? "stage";
+}
+function requireOwnerId(config) {
+  const ownerId = config.session?.owner?.id;
+  if (!ownerId) {
+    throw new Error(
+      "workflowUsersClient: session.owner.id is required to call this endpoint."
+    );
+  }
+  return ownerId;
+}
+function requireWorkflowName(config) {
+  const workflowName = config.workflow.name;
+  if (!workflowName) {
+    throw new Error(
+      "workflowUsersClient: workflow.name is required to call this endpoint."
+    );
+  }
+  return workflowName;
+}
+function requireWorkflowId(config) {
+  const workflowId = config.workflow.id;
+  if (!workflowId) {
+    throw new Error(
+      "workflowUsersClient: workflow.id is required to call this endpoint."
+    );
+  }
+  return workflowId;
+}
+function isPlaygroundYaakAuth(config) {
+  if (config.api.authToken) return false;
+  const headers = config.api.headers;
+  if (!headers) return false;
+  for (const key of Object.keys(headers)) {
+    const lower = key.toLowerCase();
+    if (lower === "yaak-api-key" || lower === "x-yaak-api-key") return true;
+  }
+  return false;
+}
+async function fetchJson(url, headers, signal) {
+  const response = await fetch(url, {
+    method: "GET",
+    headers,
+    signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  return await response.json();
+}
+async function listSessions(config, opts = {}) {
+  const ownerId = requireOwnerId(config);
+  const useYaakEndpoint = isPlaygroundYaakAuth(config);
+  const params = new URLSearchParams({
+    page: String(opts.page ?? 0),
+    size: String(opts.size ?? DEFAULT_SESSION_PAGE_SIZE)
+  });
+  if (useYaakEndpoint) {
+    params.set("workflowUserId", ownerId);
+    params.set("workflowName", requireWorkflowName(config));
+  } else {
+    params.set("workflowId", requireWorkflowId(config));
+  }
+  if (config.workflow.stage) {
+    params.set(getStageParamName2(config), config.workflow.stage);
+  }
+  const url = useYaakEndpoint ? `${config.api.baseUrl}/api/workflows/ask/sessions?${params.toString()}` : `${config.api.baseUrl}/api/workflow-users/${encodeURIComponent(
+    ownerId
+  )}/sessions?${params.toString()}`;
+  return fetchJson(
+    url,
+    buildRequestHeaders(config),
+    opts.signal
+  );
+}
+async function listConversations(config, opts) {
+  const ownerId = requireOwnerId(config);
+  const useYaakEndpoint = isPlaygroundYaakAuth(config);
+  const params = new URLSearchParams({
+    sessionId: opts.sessionId,
+    page: String(opts.page ?? 0),
+    size: String(opts.size ?? DEFAULT_CONVERSATION_PAGE_SIZE)
+  });
+  if (useYaakEndpoint) {
+    params.set("workflowUserId", ownerId);
+    params.set("workflowName", requireWorkflowName(config));
+  }
+  if (config.workflow.stage) {
+    params.set(getStageParamName2(config), config.workflow.stage);
+  }
+  const url = useYaakEndpoint ? `${config.api.baseUrl}/api/workflows/ask/conversations?${params.toString()}` : `${config.api.baseUrl}/api/workflow-users/${encodeURIComponent(
+    ownerId
+  )}/conversations?${params.toString()}`;
+  return fetchJson(
+    url,
+    buildRequestHeaders(config),
+    opts.signal
+  );
+}
+
 // src/hooks/useChatV2.ts
+function conversationEntryToMessages(entry, sessionId) {
+  return [
+    {
+      id: `history-user-${entry.executionId}`,
+      sessionId,
+      role: "user",
+      content: entry.query,
+      timestamp: entry.createdAt,
+      isHistorical: true
+    },
+    {
+      id: `history-assistant-${entry.executionId}`,
+      sessionId,
+      role: "assistant",
+      content: entry.response,
+      timestamp: entry.createdAt,
+      executionId: entry.executionId,
+      isHistorical: true
+    }
+  ];
+}
+function streamKeyFor(scopeKey, sessionId) {
+  return `${scopeKey}|sid:${sessionId ?? ""}`;
+}
 function useChatV2(config, callbacks = {}) {
+  const scopeKey = react.useMemo(() => buildScopeKey(config), [
+    config.session?.userId,
+    config.workflow.id,
+    config.workflow.version,
+    config.workflow.stage
+  ]);
+  const initialSessionId = chatStore.get(scopeKey).find((m) => m.sessionId)?.sessionId ?? config.session?.initialId ?? void 0;
   const [messages, setMessages] = react.useState(() => {
-    if (config.userId) return chatStore.get(config.userId);
-    return config.initialMessages ?? [];
+    const stored = chatStore.get(scopeKey);
+    if (stored.length > 0) return stored;
+    return config.session?.initialMessages ?? [];
   });
   const [isWaitingForResponse, setIsWaitingForResponse] = react.useState(false);
-  const sessionIdRef = react.useRef(
-    config.userId ? chatStore.get(config.userId).find((m) => m.sessionId)?.sessionId ?? config.initialSessionId ?? void 0 : config.initialSessionId ?? void 0
-  );
-  const prevUserIdRef = react.useRef(config.userId);
+  const [loadingSessionId, setLoadingSessionId] = react.useState(void 0);
+  const [currentSessionId, setCurrentSessionId] = react.useState(initialSessionId);
+  const sessionIdRef = react.useRef(initialSessionId);
+  const prevScopeKeyRef = react.useRef(scopeKey);
+  const activeStreamSessionRef = react.useRef(void 0);
   const callbacksRef = react.useRef(callbacks);
   callbacksRef.current = callbacks;
   const configRef = react.useRef(config);
   configRef.current = config;
+  const scopeKeyRef = react.useRef(scopeKey);
+  scopeKeyRef.current = scopeKey;
   const messagesRef = react.useRef(messages);
   messagesRef.current = messages;
   const storeAwareSetMessages = react.useCallback(
     (updater) => {
-      const { userId } = configRef.current;
-      if (userId && activeStreamStore.has(userId)) {
-        activeStreamStore.applyMessages(userId, updater);
+      const scope = scopeKeyRef.current;
+      const streamSid = activeStreamSessionRef.current;
+      if (streamSid !== void 0) {
+        const streamKey = streamKeyFor(scope, streamSid);
+        if (activeStreamStore.has(streamKey)) {
+          activeStreamStore.applyMessages(
+            streamKey,
+            updater
+          );
+        }
+        if (sessionIdRef.current === streamSid) {
+          setMessages(updater);
+        }
+        return;
       }
       setMessages(updater);
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     []
   );
-  const storeAwareSetIsWaiting = react.useCallback(
-    (waiting) => {
-      const { userId } = configRef.current;
-      if (userId && activeStreamStore.has(userId)) {
-        activeStreamStore.setWaiting(userId, waiting);
+  const storeAwareSetIsWaiting = react.useCallback((waiting) => {
+    const scope = scopeKeyRef.current;
+    const streamSid = activeStreamSessionRef.current;
+    if (streamSid !== void 0) {
+      const streamKey = streamKeyFor(scope, streamSid);
+      if (activeStreamStore.has(streamKey)) {
+        activeStreamStore.setWaiting(streamKey, waiting);
       }
-      setIsWaitingForResponse(waiting);
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    []
-  );
+      if (sessionIdRef.current === streamSid) {
+        setIsWaitingForResponse(waiting);
+      }
+      return;
+    }
+    setIsWaitingForResponse(waiting);
+  }, []);
   const [userActionState, setUserActionState] = react.useState({
     request: null,
     result: null,
@@ -2057,38 +1387,43 @@ function useChatV2(config, callbacks = {}) {
   });
   const userActionStateRef = react.useRef(userActionState);
   userActionStateRef.current = userActionState;
-  const wrappedCallbacks = react.useMemo(() => ({
-    ...callbacksRef.current,
-    onMessageSent: (message) => callbacksRef.current.onMessageSent?.(message),
-    onStreamStart: () => callbacksRef.current.onStreamStart?.(),
-    onStreamComplete: (message) => callbacksRef.current.onStreamComplete?.(message),
-    onError: (error) => callbacksRef.current.onError?.(error),
-    onExecutionTraceClick: (data) => callbacksRef.current.onExecutionTraceClick?.(data),
-    onSessionIdChange: (sessionId) => callbacksRef.current.onSessionIdChange?.(sessionId),
-    onUserActionRequired: (request) => {
-      setUserActionState((prev) => ({ ...prev, request, result: null }));
-      callbacksRef.current.onUserActionRequired?.(request);
-    },
-    onUserActionEvent: (eventType, message) => {
-      switch (eventType) {
-        case "USER_ACTION_SUCCESS":
-          setUserActionState((prev) => ({ ...prev, request: null, result: "approved" }));
-          break;
-        case "USER_ACTION_REJECTED":
-          setUserActionState((prev) => ({ ...prev, request: null, result: "rejected" }));
-          break;
-        case "USER_ACTION_EXPIRED":
-        case "USER_ACTION_FAILED":
-          setUserActionState((prev) => ({ ...prev, request: null }));
-          break;
-        case "USER_ACTION_INVALID":
-          setUserActionState((prev) => ({ ...prev, clearOtpTrigger: prev.clearOtpTrigger + 1 }));
-          break;
+  const wrappedCallbacks = react.useMemo(
+    () => ({
+      ...callbacksRef.current,
+      onMessageSent: (message) => callbacksRef.current.onMessageSent?.(message),
+      onStreamStart: () => callbacksRef.current.onStreamStart?.(),
+      onStreamComplete: (message) => callbacksRef.current.onStreamComplete?.(message),
+      onError: (error) => callbacksRef.current.onError?.(error),
+      onExecutionTraceClick: (data) => callbacksRef.current.onExecutionTraceClick?.(data),
+      onSessionIdChange: (sessionId) => callbacksRef.current.onSessionIdChange?.(sessionId),
+      onUserActionRequired: (request) => {
+        setUserActionState((prev) => ({ ...prev, request, result: null }));
+        callbacksRef.current.onUserActionRequired?.(request);
+      },
+      onUserActionEvent: (eventType, message) => {
+        switch (eventType) {
+          case "USER_ACTION_SUCCESS":
+            setUserActionState((prev) => ({ ...prev, request: null, result: "approved" }));
+            break;
+          case "USER_ACTION_REJECTED":
+            setUserActionState((prev) => ({ ...prev, request: null, result: "rejected" }));
+            break;
+          case "USER_ACTION_EXPIRED":
+          case "USER_ACTION_FAILED":
+            setUserActionState((prev) => ({ ...prev, request: null }));
+            break;
+          case "USER_ACTION_INVALID":
+            setUserActionState((prev) => ({
+              ...prev,
+              clearOtpTrigger: prev.clearOtpTrigger + 1
+            }));
+            break;
+        }
+        callbacksRef.current.onUserActionEvent?.(eventType, message);
       }
-      callbacksRef.current.onUserActionEvent?.(eventType, message);
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }), []);
+    }),
+    []
+  );
   const { startStream, cancelStream: cancelStreamManager, abortControllerRef } = useStreamManagerV2(
     config,
     wrappedCallbacks,
@@ -2098,8 +1433,10 @@ function useChatV2(config, callbacks = {}) {
   const sendMessage = react.useCallback(
     async (userMessage) => {
       if (!userMessage.trim()) return;
-      if (!sessionIdRef.current && configRef.current.autoGenerateSessionId !== false) {
+      const autoGen = configRef.current.session?.autoGenerateId;
+      if (!sessionIdRef.current && autoGen !== false) {
         sessionIdRef.current = generateId();
+        setCurrentSessionId(sessionIdRef.current);
         callbacksRef.current.onSessionIdChange?.(sessionIdRef.current);
       }
       const userMessageId = `user-${Date.now()}`;
@@ -2131,38 +1468,40 @@ function useChatV2(config, callbacks = {}) {
       };
       setMessages((prev) => [...prev, streamingMsg]);
       const abortController = new AbortController();
-      const { userId } = configRef.current;
-      if (userId) {
-        const initialMessages = [...messagesRef.current, userMsg, streamingMsg];
-        activeStreamStore.start(userId, abortController, initialMessages);
-      }
+      const scope = scopeKeyRef.current;
+      const streamSessionId = sessionIdRef.current;
+      const streamKey = streamKeyFor(scope, streamSessionId);
+      activeStreamSessionRef.current = streamSessionId;
+      const initialMessages = [...messagesRef.current, userMsg, streamingMsg];
+      activeStreamStore.start(streamKey, abortController, initialMessages);
       const newSessionId = await startStream(
         userMessage,
         streamingId,
-        sessionIdRef.current,
+        streamSessionId,
         abortController
       );
-      if (userId) {
-        activeStreamStore.complete(userId);
-      }
-      if (!abortController.signal.aborted && newSessionId && newSessionId !== sessionIdRef.current) {
+      activeStreamStore.complete(streamKey);
+      activeStreamSessionRef.current = void 0;
+      if (!abortController.signal.aborted && newSessionId && newSessionId !== streamSessionId && sessionIdRef.current === streamSessionId) {
         sessionIdRef.current = newSessionId;
+        setCurrentSessionId(newSessionId);
       }
     },
     [startStream]
   );
   const clearMessages = react.useCallback(() => {
-    if (configRef.current.userId) {
-      chatStore.delete(configRef.current.userId);
-    }
+    chatStore.delete(scopeKeyRef.current);
     setMessages([]);
   }, []);
   const prependMessages = react.useCallback((msgs) => {
     setMessages((prev) => [...msgs, ...prev]);
   }, []);
   const cancelStream = react.useCallback(() => {
-    if (configRef.current.userId) {
-      activeStreamStore.abort(configRef.current.userId);
+    const scope = scopeKeyRef.current;
+    const viewSid = sessionIdRef.current;
+    const viewStreamKey = streamKeyFor(scope, viewSid);
+    if (activeStreamStore.has(viewStreamKey)) {
+      activeStreamStore.abort(viewStreamKey);
     }
     cancelStreamManager();
     setIsWaitingForResponse(false);
@@ -2172,10 +1511,7 @@ function useChatV2(config, callbacks = {}) {
         if (msg.isStreaming) {
           return {
             ...msg,
-            ...createCancelledMessageUpdate(
-              msg.steps || [],
-              msg.currentMessage
-            )
+            ...createCancelledMessageUpdate(msg.steps || [], msg.currentMessage)
           };
         }
         return msg;
@@ -2183,39 +1519,37 @@ function useChatV2(config, callbacks = {}) {
     );
   }, [cancelStreamManager]);
   const resetSession = react.useCallback(() => {
-    if (configRef.current.userId) {
-      activeStreamStore.abort(configRef.current.userId);
-      chatStore.delete(configRef.current.userId);
+    const scope = scopeKeyRef.current;
+    const viewSid = sessionIdRef.current;
+    const viewStreamKey = streamKeyFor(scope, viewSid);
+    if (activeStreamStore.has(viewStreamKey)) {
+      activeStreamStore.abort(viewStreamKey);
     }
+    chatStore.delete(scope);
     setMessages([]);
     sessionIdRef.current = void 0;
+    setCurrentSessionId(void 0);
+    activeStreamSessionRef.current = void 0;
     abortControllerRef.current?.abort();
     setIsWaitingForResponse(false);
     setUserActionState({ request: null, result: null, clearOtpTrigger: 0 });
   }, []);
-  const getSessionId = react.useCallback(() => {
-    return sessionIdRef.current;
+  const getSessionId = react.useCallback(() => sessionIdRef.current, []);
+  const getMessages = react.useCallback(() => messages, [messages]);
+  const approveUserAction = react.useCallback(async (otp) => {
+    const request = userActionStateRef.current.request;
+    if (!request) return;
+    try {
+      await submitUserAction(configRef.current, request.userActionId, { otp });
+    } catch (error) {
+      setUserActionState((prev) => ({
+        ...prev,
+        clearOtpTrigger: prev.clearOtpTrigger + 1
+      }));
+      callbacksRef.current.onError?.(error);
+      throw error;
+    }
   }, []);
-  const getMessages = react.useCallback(() => {
-    return messages;
-  }, [messages]);
-  const approveUserAction = react.useCallback(
-    async (otp) => {
-      const request = userActionStateRef.current.request;
-      if (!request) return;
-      try {
-        await submitUserAction(configRef.current, request.userActionId, { otp });
-      } catch (error) {
-        setUserActionState((prev) => ({
-          ...prev,
-          clearOtpTrigger: prev.clearOtpTrigger + 1
-        }));
-        callbacksRef.current.onError?.(error);
-        throw error;
-      }
-    },
-    []
-  );
   const rejectUserAction = react.useCallback(async () => {
     const request = userActionStateRef.current.request;
     if (!request) return;
@@ -2249,43 +1583,91 @@ function useChatV2(config, callbacks = {}) {
       throw error;
     }
   }, []);
+  const inFlightLoadRef = react.useRef(null);
+  const loadingSessionIdRef = react.useRef(void 0);
+  loadingSessionIdRef.current = loadingSessionId;
+  const loadSession = react.useCallback(async (sessionId) => {
+    const inFlight = inFlightLoadRef.current;
+    if (inFlight && inFlight.sessionId === sessionId) {
+      return inFlight.promise;
+    }
+    if (sessionIdRef.current === sessionId && loadingSessionIdRef.current !== sessionId) {
+      return;
+    }
+    const run = async () => {
+      const scope = scopeKeyRef.current;
+      setUserActionState({ request: null, result: null, clearOtpTrigger: 0 });
+      sessionIdRef.current = sessionId;
+      setCurrentSessionId(sessionId);
+      callbacksRef.current.onSessionIdChange?.(sessionId);
+      const streamKey = streamKeyFor(scope, sessionId);
+      const active = activeStreamStore.get(streamKey);
+      if (active) {
+        setMessages(active.messages);
+        setIsWaitingForResponse(active.isWaiting);
+        setLoadingSessionId(void 0);
+        return;
+      }
+      setIsWaitingForResponse(false);
+      setMessages([]);
+      chatStore.delete(scope);
+      setLoadingSessionId(sessionId);
+      try {
+        const response = await listConversations(configRef.current, { sessionId });
+        const entries = response.data ?? [];
+        const historical = entries.flatMap((entry) => conversationEntryToMessages(entry, sessionId));
+        if (sessionIdRef.current === sessionId) {
+          setMessages(historical);
+        }
+        if (historical.length > 0) {
+          chatStore.set(scope, historical);
+        }
+      } catch (error) {
+        callbacksRef.current.onError?.(error);
+        throw error;
+      } finally {
+        setLoadingSessionId((current) => current === sessionId ? void 0 : current);
+      }
+    };
+    const promise = run().finally(() => {
+      if (inFlightLoadRef.current?.sessionId === sessionId) {
+        inFlightLoadRef.current = null;
+      }
+    });
+    inFlightLoadRef.current = { sessionId, promise };
+    return promise;
+  }, []);
   react.useEffect(() => {
-    const { userId } = config;
-    if (!userId) return;
-    const unsubscribe = activeStreamStore.subscribe(userId, (msgs, isWaiting) => {
+    const key = streamKeyFor(scopeKey, currentSessionId);
+    const unsubscribe = activeStreamStore.subscribe(key, (msgs, isWaiting) => {
       setMessages(msgs);
       setIsWaitingForResponse(isWaiting);
     });
-    const active = activeStreamStore.get(userId);
+    const active = activeStreamStore.get(key);
     if (active) {
       setMessages(active.messages);
       setIsWaitingForResponse(active.isWaiting);
     }
     return unsubscribe;
-  }, []);
+  }, [scopeKey, currentSessionId]);
   react.useEffect(() => {
-    if (!config.userId) return;
     const toSave = messages.filter((m) => !m.isStreaming);
     if (toSave.length > 0) {
-      chatStore.set(config.userId, toSave);
+      chatStore.set(scopeKey, toSave);
     }
-  }, [messages, config.userId]);
+  }, [messages, scopeKey]);
   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({ request: null, result: null, clearOtpTrigger: 0 });
-    } else if (config.userId) {
-      const stored = chatStore.get(config.userId);
-      setMessages(stored);
-      sessionIdRef.current = stored.find((m) => m.sessionId)?.sessionId;
-    }
-  }, [config.userId]);
+    const prevKey = prevScopeKeyRef.current;
+    prevScopeKeyRef.current = scopeKey;
+    if (prevKey === scopeKey) return;
+    const stored = chatStore.get(scopeKey);
+    setMessages(stored);
+    const restoredSessionId = stored.find((m) => m.sessionId)?.sessionId ?? configRef.current.session?.initialId ?? void 0;
+    sessionIdRef.current = restoredSessionId;
+    setCurrentSessionId(restoredSessionId);
+    setIsWaitingForResponse(false);
+    setUserActionState({ request: null, result: null, clearOtpTrigger: 0 });
+  }, [scopeKey]);
   return {
     messages,
     sendMessage,
@@ -2296,11 +1678,13 @@ function useChatV2(config, callbacks = {}) {
     getSessionId,
     getMessages,
     isWaitingForResponse,
-    sessionId: sessionIdRef.current,
+    sessionId: currentSessionId,
     userActionState,
     approveUserAction,
     rejectUserAction,
-    resendOtp
+    resendOtp,
+    loadSession,
+    loadingSessionId
   };
 }
 function getSpeechRecognition() {
@@ -2520,14 +1904,16 @@ function useVoice(config = {}, callbacks = {}) {
 }
 
 exports.buildFormattedThinking = buildFormattedThinking;
+exports.buildScopeKey = buildScopeKey;
 exports.cancelUserAction = cancelUserAction;
 exports.createInitialV2State = createInitialV2State;
 exports.generateId = generateId;
+exports.listConversations = listConversations;
+exports.listSessions = listSessions;
 exports.processStreamEventV2 = processStreamEventV2;
 exports.resendUserAction = resendUserAction;
 exports.streamWorkflowEvents = streamWorkflowEvents;
 exports.submitUserAction = submitUserAction;
-exports.useChat = useChat;
 exports.useChatV2 = useChatV2;
 exports.useVoice = useVoice;
 exports.workingPhaseDetailForDisplay = workingPhaseDetailForDisplay;