@paymanai/payman-typescript-ask-sdk 2.0.3 → 4.0.0

package/dist/index.native.js

@@ -136,7 +136,38 @@ async function streamWorkflowEvents(url, body, headers, options = {}) {
   });
 }
 
-// src/utils/eventProcessor.ts
+// src/utils/stageLabels.ts
+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}`;
+}
+
+// src/utils/v2EventProcessor.ts
+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();
@@ -146,54 +177,104 @@ function getEventMessage(event) {
   }
   const eventType = event.eventType;
   switch (eventType) {
-    case "STARTED":
-    case "WORKFLOW_STARTED":
-      return "Starting workflow...";
-    case "ORCHESTRATOR_THINKING":
-      return "Planning execution strategy...";
-    case "ORCHESTRATOR_COMPLETED":
-      return "Planning complete";
-    case "INTENT_STARTED":
-      return event.workerName ? `${event.workerName} started` : "Processing intent...";
-    case "INTENT_PROGRESS":
-      return event.workerName ? `${event.workerName} in progress` : "Thinking...";
-    case "INTENT_COMPLETED":
-      return event.workerName ? `${event.workerName} completed` : "Intent completed";
-    case "AGGREGATOR_THINKING":
-      return "Combining results...";
-    case "AGGREGATOR_COMPLETED":
-      return "Results combined";
-    case "COMPLETED":
-    case "WORKFLOW_COMPLETED":
-      return "Workflow completed successfully";
-    case "ERROR":
-    case "WORKFLOW_ERROR":
-    case "INTENT_ERROR":
-      return event.errorMessage || "An error occurred";
-    case "USER_ACTION_REQUIRED":
-      return "Waiting for verification...";
-    case "USER_ACTION_SUCCESS":
-      return "Verification approved";
-    case "USER_ACTION_EXPIRED":
-      return "Verification expired";
-    case "USER_ACTION_INVALID":
-      return "Invalid code. Please try again.";
-    case "USER_ACTION_REJECTED":
-      return "Verification cancelled";
-    case "USER_ACTION_RESENT":
-      return "Verification code resent";
-    case "USER_ACTION_FAILED":
-      return "Verification failed";
-    case "INTENT_THINKING":
-      return event.workerName ? `${event.workerName} thinking...` : "Thinking...";
-    case "INTENT_THINKING_CONT":
-      return event.message || "";
+    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 "";
+      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 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);
 }
@@ -227,306 +308,6 @@ function workingPhaseDetailForDisplay(raw) {
   }
   return t;
 }
-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 "";
-}
-
-// src/utils/messageStateManager.ts
-function buildFormattedThinking(steps, allThinkingText) {
-  const parts = [];
-  const safeSteps = steps ?? [];
-  const cleanAll = allThinkingText.replace(/^\s+/, "");
-  if (cleanAll) {
-    const firstStepWithThinking = safeSteps.find(
-      (s) => s.thinkingText && s.thinkingText.trim()
-    );
-    if (!firstStepWithThinking) {
-      parts.push("**Preflight**");
-      parts.push(cleanAll);
-    } else {
-      const stepText = firstStepWithThinking.thinkingText.trim();
-      const idx = cleanAll.indexOf(stepText);
-      if (idx > 0) {
-        const orphaned = cleanAll.substring(0, idx).replace(/\s+$/, "");
-        if (orphaned) {
-          parts.push("**Preflight**");
-          parts.push(orphaned);
-        }
-      }
-    }
-  }
-  for (const step of safeSteps) {
-    switch (step.eventType) {
-      case "ORCHESTRATOR_THINKING":
-        parts.push("**Planning**");
-        if (step.message) parts.push(step.message);
-        break;
-      case "WORKING": {
-        const detail = workingPhaseDetailForDisplay(step.message || "");
-        parts.push("**Working**");
-        if (detail) parts.push(detail);
-        break;
-      }
-      case "INTENT_STARTED": {
-        let label = step.message || "Processing";
-        const started = label.match(/^(.+?)\s+started$/i);
-        const progress = label.match(/^(.+?)\s+in progress$/i);
-        if (started) label = started[1];
-        else if (progress) label = progress[1];
-        parts.push(`**${label}**`);
-        if (step.thinkingText) parts.push(step.thinkingText);
-        break;
-      }
-      case "INTENT_PROGRESS": {
-        if (step.thinkingText) parts.push(step.thinkingText);
-        else if (step.message) parts.push(step.message);
-        break;
-      }
-      case "AGGREGATOR_THINKING":
-        parts.push("**Finalizing**");
-        if (step.message) parts.push(step.message);
-        break;
-      case "USER_ACTION_REQUIRED":
-        parts.push("**Verification Required**");
-        if (step.message) {
-          parts.push(getUserActionDisplayMessage(step.eventType, step.message));
-        }
-        break;
-      case "USER_ACTION_SUCCESS":
-        parts.push(`\u2713 ${getUserActionDisplayMessage(step.eventType, step.message)}`);
-        break;
-      case "USER_ACTION_REJECTED":
-        parts.push(getUserActionDisplayMessage(step.eventType, step.message));
-        break;
-      case "USER_ACTION_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 ${getUserActionDisplayMessage(step.eventType, 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..."
-  };
-}
-
-// src/utils/requestBuilder.ts
-function buildRequestBody(config, userMessage, sessionId) {
-  const owner = config.session?.owner;
-  const sessionAttributes = owner?.attributes && Object.keys(owner.attributes).length > 0 ? owner.attributes : void 0;
-  return {
-    workflowName: config.workflow.name,
-    userInput: userMessage,
-    sessionId,
-    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 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 deriveBasePath(config) {
-  const endpoint = config.api.streamEndpoint || "/api/workflows/ask/stream";
-  const [endpointPath] = endpoint.split("?");
-  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}`;
-}
-function buildResolveImagesUrl(config) {
-  if (config.api.resolveImagesEndpoint) {
-    return `${config.api.baseUrl}${config.api.resolveImagesEndpoint}`;
-  }
-  return `${config.api.baseUrl}${deriveBasePath(config)}/resolve-image-urls`;
-}
-function buildRequestHeaders(config) {
-  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) {
-  const url = buildUserActionUrl(config, userActionId, action);
-  const baseHeaders = buildRequestHeaders(config);
-  const hasBody = data !== void 0;
-  const headers = hasBody ? { "Content-Type": "application/json", ...baseHeaders } : baseHeaders;
-  const response = await fetch(url, {
-    method: "POST",
-    headers,
-    body: hasBody ? JSON.stringify(data) : void 0
-  });
-  if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`HTTP ${response.status}: ${errorText}`);
-  }
-  return await response.json();
-}
-async function submitUserAction(config, userActionId, data) {
-  return sendUserActionRequest(config, userActionId, "submit", data);
-}
-async function cancelUserAction(config, userActionId) {
-  return sendUserActionRequest(config, userActionId, "cancel");
-}
-async function resendUserAction(config, userActionId) {
-  return sendUserActionRequest(config, userActionId, "resend");
-}
-var storage = reactNativeMmkv.createMMKV({ id: "payman-chat-store" });
-var chatStore = {
-  get(key) {
-    const raw = storage.getString(key);
-    if (!raw) return [];
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return [];
-    }
-  },
-  set(key, messages) {
-    storage.set(key, JSON.stringify(messages));
-  },
-  delete(key) {
-    const s = storage;
-    if (typeof s.remove === "function") s.remove(key);
-    else if (typeof s.delete === "function") s.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) {
   const value = event[field];
   return typeof value === "string" ? value.trim() : "";
@@ -550,6 +331,16 @@ function addThinkingLine(state, header, 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") {
@@ -577,11 +368,31 @@ function createInitialV2State() {
     currentExecutingStepId: void 0
   };
 }
-function processStreamEventV2(event, state) {
+function processStreamEventV2(rawEvent, state) {
+  const event = normalizeEvent(rawEvent);
   const eventType = event.eventType;
   if (typeof eventType === "string" && eventType.toUpperCase() === "KEEP_ALIVE") {
     if (event.executionId) state.executionId = event.executionId;
     if (event.sessionId) state.sessionId = event.sessionId;
+    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;
@@ -592,6 +403,16 @@ function processStreamEventV2(event, state) {
     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...";
@@ -693,6 +514,7 @@ function processStreamEventV2(event, state) {
         elapsedMs: event.elapsedMs
       });
       state.currentExecutingStepId = stepId;
+      updateExecutionStageMessage(state, message);
       state.lastEventType = eventType;
       break;
     }
@@ -735,6 +557,10 @@ function processStreamEventV2(event, state) {
     }
     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") {
@@ -747,7 +573,9 @@ function processStreamEventV2(event, state) {
       }
       if (content) {
         state.finalResponse = content;
-        state.finalData = event.response ?? event.trace;
+        if (event.trace && typeof event.trace === "object") {
+          state.finalData = event.trace;
+        }
         state.hasError = false;
         state.errorMessage = "";
       } else {
@@ -929,12 +757,373 @@ function processStreamEventV2(event, state) {
       state.lastEventType = eventType;
       break;
     }
-    default:
-      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;
+}
+
+// src/utils/messageStateManager.ts
+function buildFormattedThinking(steps, allThinkingText) {
+  const parts = [];
+  const safeSteps = steps ?? [];
+  const cleanAll = allThinkingText.replace(/^\s+/, "");
+  if (cleanAll) {
+    const firstStepWithThinking = safeSteps.find(
+      (s) => s.thinkingText && s.thinkingText.trim()
+    );
+    if (!firstStepWithThinking) {
+      parts.push("**Preflight**");
+      parts.push(cleanAll);
+    } else {
+      const stepText = firstStepWithThinking.thinkingText.trim();
+      const idx = cleanAll.indexOf(stepText);
+      if (idx > 0) {
+        const orphaned = cleanAll.substring(0, idx).replace(/\s+$/, "");
+        if (orphaned) {
+          parts.push("**Preflight**");
+          parts.push(orphaned);
+        }
+      }
+    }
+  }
+  for (const step of safeSteps) {
+    switch (step.eventType) {
+      case "STAGE_STARTED": {
+        if (step.message) parts.push(`**${step.message}**`);
+        break;
+      }
+      case "ORCHESTRATOR_THINKING":
+        parts.push("**Planning**");
+        if (step.message) parts.push(step.message);
+        break;
+      case "INTENT_STARTED": {
+        let label = step.message || "Processing";
+        const started = label.match(/^(.+?)\s+started$/i);
+        const progress = label.match(/^(.+?)\s+in progress$/i);
+        if (started) label = started[1];
+        else if (progress) label = progress[1];
+        parts.push(`**${label}**`);
+        if (step.thinkingText) parts.push(step.thinkingText);
+        break;
+      }
+      case "INTENT_PROGRESS": {
+        if (step.thinkingText) parts.push(step.thinkingText);
+        else if (step.message) parts.push(step.message);
+        break;
+      }
+      case "AGGREGATOR_THINKING":
+        parts.push("**Finalizing**");
+        if (step.message) parts.push(step.message);
+        break;
+      case "USER_ACTION_REQUIRED":
+        parts.push("**Verification Required**");
+        if (step.message) parts.push(step.message);
+        break;
+      case "USER_ACTION_SUCCESS":
+        parts.push(`\u2713 ${step.message || "Verification successful"}`);
+        break;
+      case "USER_ACTION_REJECTED":
+        parts.push(`\u2717 ${step.message || "Verification rejected"}`);
+        break;
+      case "USER_ACTION_EXPIRED":
+        parts.push(`\u2717 ${step.message || "Verification expired"}`);
+        break;
+      case "USER_ACTION_FAILED":
+        parts.push(`\u2717 ${step.message || "Verification failed"}`);
+        break;
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : allThinkingText;
+}
+function createCancelledMessageUpdate(steps, currentMessage) {
+  const updatedSteps = steps.map((step) => {
+    if (step.status === "in_progress") {
+      return { ...step, status: "pending" };
+    }
+    return step;
+  });
+  return {
+    isStreaming: false,
+    isCancelled: true,
+    steps: updatedSteps,
+    currentExecutingStepId: void 0,
+    // Preserve currentMessage so UI can show it with X icon
+    currentMessage: currentMessage || "Thinking..."
+  };
+}
+
+// src/utils/requestBuilder.ts
+var DEFAULT_STREAM_ENDPOINT = "/api/playground/ask/stream";
+function buildRequestBody(config, userMessage, sessionId, options) {
+  const sessionOwner = config.sessionParams;
+  const sessionAttributes = sessionOwner?.attributes && Object.keys(sessionOwner.attributes).length > 0 ? sessionOwner.attributes : void 0;
+  return {
+    agentId: config.agentId,
+    userInput: userMessage,
+    sessionId,
+    sessionOwnerLabel: sessionOwner?.name || void 0,
+    sessionAttributes,
+    analysisMode: options?.analysisMode
+  };
+}
+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}`;
   }
-  return state;
+  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;
+}
+
+// src/utils/userActionClient.ts
+async function sendUserActionRequest(config, userActionId, action, data) {
+  const url = buildUserActionUrl(config, userActionId, action);
+  const baseHeaders = buildRequestHeaders(config);
+  const hasBody = data !== void 0;
+  const headers = hasBody ? { "Content-Type": "application/json", ...baseHeaders } : baseHeaders;
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: hasBody ? JSON.stringify(data) : void 0
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  return await response.json();
+}
+async function submitUserAction(config, userActionId, data) {
+  return sendUserActionRequest(config, userActionId, "submit", data);
+}
+async function cancelUserAction(config, userActionId) {
+  return sendUserActionRequest(config, userActionId, "cancel");
+}
+async function resendUserAction(config, userActionId) {
+  return sendUserActionRequest(config, userActionId, "resend");
 }
+var storage = reactNativeMmkv.createMMKV({ id: "payman-chat-store" });
+var chatStore = {
+  get(key) {
+    const raw = storage.getString(key);
+    if (!raw) return [];
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  },
+  set(key, messages) {
+    storage.set(key, JSON.stringify(messages));
+  },
+  delete(key) {
+    storage.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/;
@@ -995,12 +1184,11 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
   const callbacksRef = react.useRef(callbacks);
   callbacksRef.current = callbacks;
   const startStream = react.useCallback(
-    async (userMessage, streamingId, sessionId, externalAbortController) => {
+    async (userMessage, streamingId, sessionId, externalAbortController, options) => {
       abortControllerRef.current?.abort();
       const abortController = externalAbortController ?? new AbortController();
       abortControllerRef.current = abortController;
       const state = createInitialV2State();
-      const streamStartedAt = Date.now();
       const updateMessage = (update) => {
         if (abortController.signal.aborted) return;
         setMessages(
@@ -1010,7 +1198,12 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
         );
       };
       const currentConfig = configRef.current;
-      const requestBody = buildRequestBody(currentConfig, userMessage, sessionId);
+      const requestBody = buildRequestBody(
+        currentConfig,
+        userMessage,
+        sessionId,
+        options
+      );
       const url = buildStreamingUrl(currentConfig);
       const headers = buildRequestHeaders(currentConfig);
       try {
@@ -1018,11 +1211,6 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
           signal: abortController.signal,
           onEvent: (event) => {
             if (abortController.signal.aborted) return;
-            if (typeof event.eventType === "string" && event.eventType.toUpperCase() === "KEEP_ALIVE") {
-              if (event.executionId) state.executionId = event.executionId;
-              if (event.sessionId) state.sessionId = event.sessionId;
-              return;
-            }
             processStreamEventV2(event, state);
             const eventType = event.eventType;
             if (eventType === "USER_ACTION_REQUIRED" && state.userActionRequest) {
@@ -1036,7 +1224,18 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
             }
             const activeStep = state.steps.find((s) => s.id === state.currentExecutingStepId);
             const lastInProgressStep = [...state.steps].reverse().find((s) => s.status === "in_progress");
-            const currentMessage = activeStep?.message || lastInProgressStep?.message || getEventMessage(event);
+            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,
@@ -1052,7 +1251,7 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
               });
             } else {
               updateMessage({
-                streamingContent: "",
+                streamingContent: state.finalResponse,
                 content: "",
                 currentMessage,
                 streamProgress: "processing",
@@ -1069,6 +1268,7 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
           },
           onError: (error) => {
             setIsWaitingForResponse(false);
+            callbacksRef.current.onStatusMessage?.(null);
             if (error.name !== "AbortError") {
               callbacksRef.current.onError?.(error);
             }
@@ -1106,6 +1306,8 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
           },
           onComplete: () => {
             setIsWaitingForResponse(false);
+            callbacksRef.current.onStatusMessage?.(null);
+            callbacksRef.current.onStepsUpdate?.([]);
             if (state.userActionPending) {
               state.userActionPending = false;
               state.userActionRequest = void 0;
@@ -1129,14 +1331,18 @@ function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForRespo
               isError: state.hasError,
               errorDetails: state.hasError ? state.errorMessage : void 0,
               executionId: state.executionId,
-              tracingData: state.finalData,
+              // 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,
               userActionResult: state.userActionResult,
               formattedThinkingText: state.hasError ? void 0 : state.formattedThinkingText || void 0,
               isResolvingImages: needsImageResolve,
-              thinkingDurationSec: state.hasError ? void 0 : Math.max(0, Math.round((Date.now() - streamStartedAt) / 1e3))
+              totalElapsedMs: state.hasError ? void 0 : state.totalElapsedMs
             };
             setMessages(
               (prev) => prev.map(
@@ -1221,199 +1427,45 @@ 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(() => {
-    const stored = chatStore.get(scopeKey);
-    if (stored.length > 0) return stored;
-    return config.session?.initialMessages ?? [];
+    if (config.userId) return chatStore.get(config.userId);
+    return config.initialMessages ?? [];
   });
   const [isWaitingForResponse, setIsWaitingForResponse] = react.useState(false);
-  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 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 scopeKeyRef = react.useRef(scopeKey);
-  scopeKeyRef.current = scopeKey;
   const messagesRef = react.useRef(messages);
   messagesRef.current = messages;
   const storeAwareSetMessages = react.useCallback(
     (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;
+      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 scope = scopeKeyRef.current;
-    const streamSid = activeStreamSessionRef.current;
-    if (streamSid !== void 0) {
-      const streamKey = streamKeyFor(scope, streamSid);
-      if (activeStreamStore.has(streamKey)) {
-        activeStreamStore.setWaiting(streamKey, waiting);
+  const storeAwareSetIsWaiting = react.useCallback(
+    (waiting) => {
+      const { userId } = configRef.current;
+      if (userId && activeStreamStore.has(userId)) {
+        activeStreamStore.setWaiting(userId, waiting);
       }
-      if (sessionIdRef.current === streamSid) {
-        setIsWaitingForResponse(waiting);
-      }
-      return;
-    }
-    setIsWaitingForResponse(waiting);
-  }, []);
+      setIsWaitingForResponse(waiting);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
   const [userActionState, setUserActionState] = react.useState({
     request: null,
     result: null,
@@ -1421,43 +1473,38 @@ 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;
-        }
-        callbacksRef.current.onUserActionEvent?.(eventType, message);
+  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 } = useStreamManagerV2(
     config,
     wrappedCallbacks,
@@ -1465,12 +1512,10 @@ function useChatV2(config, callbacks = {}) {
     storeAwareSetIsWaiting
   );
   const sendMessage = react.useCallback(
-    async (userMessage) => {
+    async (userMessage, options) => {
       if (!userMessage.trim()) return;
-      const autoGen = configRef.current.session?.autoGenerateId;
-      if (!sessionIdRef.current && autoGen !== false) {
+      if (!sessionIdRef.current && configRef.current.autoGenerateSessionId !== false) {
         sessionIdRef.current = generateId();
-        setCurrentSessionId(sessionIdRef.current);
         callbacksRef.current.onSessionIdChange?.(sessionIdRef.current);
       }
       const userMessageId = `user-${Date.now()}`;
@@ -1502,40 +1547,39 @@ function useChatV2(config, callbacks = {}) {
       };
       setMessages((prev) => [...prev, streamingMsg]);
       const abortController = new AbortController();
-      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 { userId } = configRef.current;
+      if (userId) {
+        const initialMessages = [...messagesRef.current, userMsg, streamingMsg];
+        activeStreamStore.start(userId, abortController, initialMessages);
+      }
       const newSessionId = await startStream(
         userMessage,
         streamingId,
-        streamSessionId,
-        abortController
+        sessionIdRef.current,
+        abortController,
+        options
       );
-      activeStreamStore.complete(streamKey);
-      activeStreamSessionRef.current = void 0;
-      if (!abortController.signal.aborted && newSessionId && newSessionId !== streamSessionId && sessionIdRef.current === streamSessionId) {
+      if (userId) {
+        activeStreamStore.complete(userId);
+      }
+      if (!abortController.signal.aborted && newSessionId && newSessionId !== sessionIdRef.current) {
         sessionIdRef.current = newSessionId;
-        setCurrentSessionId(newSessionId);
       }
     },
     [startStream]
   );
   const clearMessages = react.useCallback(() => {
-    chatStore.delete(scopeKeyRef.current);
+    if (configRef.current.userId) {
+      chatStore.delete(configRef.current.userId);
+    }
     setMessages([]);
   }, []);
   const prependMessages = react.useCallback((msgs) => {
     setMessages((prev) => [...msgs, ...prev]);
   }, []);
   const cancelStream = react.useCallback(() => {
-    const scope = scopeKeyRef.current;
-    const viewSid = sessionIdRef.current;
-    const viewStreamKey = streamKeyFor(scope, viewSid);
-    if (activeStreamStore.has(viewStreamKey)) {
-      activeStreamStore.abort(viewStreamKey);
+    if (configRef.current.userId) {
+      activeStreamStore.abort(configRef.current.userId);
     }
     cancelStreamManager();
     setIsWaitingForResponse(false);
@@ -1545,7 +1589,10 @@ function useChatV2(config, callbacks = {}) {
         if (msg.isStreaming) {
           return {
             ...msg,
-            ...createCancelledMessageUpdate(msg.steps || [], msg.currentMessage)
+            ...createCancelledMessageUpdate(
+              msg.steps || [],
+              msg.currentMessage
+            )
           };
         }
         return msg;
@@ -1553,37 +1600,39 @@ function useChatV2(config, callbacks = {}) {
     );
   }, [cancelStreamManager]);
   const resetSession = react.useCallback(() => {
-    const scope = scopeKeyRef.current;
-    const viewSid = sessionIdRef.current;
-    const viewStreamKey = streamKeyFor(scope, viewSid);
-    if (activeStreamStore.has(viewStreamKey)) {
-      activeStreamStore.abort(viewStreamKey);
+    if (configRef.current.userId) {
+      activeStreamStore.abort(configRef.current.userId);
+      chatStore.delete(configRef.current.userId);
     }
-    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(() => 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 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;
@@ -1617,91 +1666,43 @@ 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 key = streamKeyFor(scopeKey, currentSessionId);
-    const unsubscribe = activeStreamStore.subscribe(key, (msgs, isWaiting) => {
+    const { userId } = config;
+    if (!userId) return;
+    const unsubscribe = activeStreamStore.subscribe(userId, (msgs, isWaiting) => {
       setMessages(msgs);
       setIsWaitingForResponse(isWaiting);
     });
-    const active = activeStreamStore.get(key);
+    const active = activeStreamStore.get(userId);
     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(scopeKey, toSave);
+      chatStore.set(config.userId, toSave);
     }
-  }, [messages, scopeKey]);
+  }, [messages, config.userId]);
   react.useEffect(() => {
-    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]);
+    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,
@@ -1712,13 +1713,11 @@ function useChatV2(config, callbacks = {}) {
     getSessionId,
     getMessages,
     isWaitingForResponse,
-    sessionId: currentSessionId,
+    sessionId: sessionIdRef.current,
     userActionState,
     approveUserAction,
     rejectUserAction,
-    resendOtp,
-    loadSession,
-    loadingSessionId
+    resendOtp
   };
 }
 function useVoice() {
@@ -1838,18 +1837,14 @@ function useVoice() {
 }
 
 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.useChatV2 = useChatV2;
 exports.useVoice = useVoice;
-exports.workingPhaseDetailForDisplay = workingPhaseDetailForDisplay;
 //# sourceMappingURL=index.native.js.map
 //# sourceMappingURL=index.native.js.map