@paymanai/payman-ask-sdk 4.0.20 → 4.0.21

package/dist/index.native.js

@@ -0,0 +1,3826 @@
+'use strict';
+
+var lucideReactNative = require('lucide-react-native');
+var react = require('react');
+var reactNative = require('react-native');
+var Markdown = require('react-native-markdown-display');
+var jsxRuntime = require('react/jsx-runtime');
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+var Sentry = require('@sentry/react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Markdown__default = /*#__PURE__*/_interopDefault(Markdown);
+var Sentry__namespace = /*#__PURE__*/_interopNamespace(Sentry);
+
+// src/components/PaymanChat/index.native.tsx
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "", value);
+function generateId() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var memoryStore = /* @__PURE__ */ new Map();
+var chatStore = {
+  get(key) {
+    return memoryStore.get(key) ?? [];
+  },
+  set(key, messages) {
+    memoryStore.set(key, messages);
+  },
+  delete(key) {
+    memoryStore.delete(key);
+  }
+};
+var streams = /* @__PURE__ */ new Map();
+var activeStreamStore = {
+  has(key) {
+    return streams.has(key);
+  },
+  get(key) {
+    const entry = streams.get(key);
+    if (!entry) return null;
+    return { messages: entry.messages, isWaiting: entry.isWaiting };
+  },
+  // Called before startStream — registers the controller and initial messages
+  start(key, abortController, initialMessages) {
+    const existing = streams.get(key);
+    streams.set(key, {
+      messages: initialMessages,
+      isWaiting: true,
+      abortController,
+      listeners: existing?.listeners ?? /* @__PURE__ */ new Set()
+    });
+  },
+  // Called by the stream on every event — applies the same updater pattern React uses
+  applyMessages(key, updater) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    const next = typeof updater === "function" ? updater(entry.messages) : updater;
+    entry.messages = next;
+    entry.listeners.forEach((l) => l(next, entry.isWaiting));
+  },
+  setWaiting(key, waiting) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.isWaiting = waiting;
+    entry.listeners.forEach((l) => l(entry.messages, waiting));
+  },
+  // Called when stream completes — persists to chatStore and cleans up
+  complete(key) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.isWaiting = false;
+    entry.listeners.forEach((l) => l(entry.messages, false));
+    const toSave = entry.messages.filter((m) => !m.isStreaming);
+    if (toSave.length > 0) chatStore.set(key, toSave);
+    streams.delete(key);
+  },
+  // Subscribe — returns unsubscribe fn. Component calls this on mount, cleanup on unmount.
+  subscribe(key, listener) {
+    const entry = streams.get(key);
+    if (!entry) return () => {
+    };
+    entry.listeners.add(listener);
+    return () => {
+      streams.get(key)?.listeners.delete(listener);
+    };
+  },
+  // Rename an entry — used when the server assigns a new session ID mid-stream
+  rename(oldKey, newKey) {
+    const entry = streams.get(oldKey);
+    if (!entry) return;
+    streams.set(newKey, entry);
+    streams.delete(oldKey);
+  },
+  // Explicit user cancel — aborts the controller and removes the entry
+  abort(key) {
+    const entry = streams.get(key);
+    if (!entry) return;
+    entry.abortController.abort();
+    streams.delete(key);
+  }
+};
+function yieldAfterProgressEvent(event) {
+  const t = event.eventType;
+  if (t === "RUN_IN_PROGRESS" || t === "INTENT_PROGRESS" || t === "THINKING_DELTA") {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  return Promise.resolve();
+}
+function parseJSONBuffer(buffer) {
+  const events = [];
+  let braceCount = 0;
+  let startIndex = 0;
+  let inString = false;
+  let escapeNext = false;
+  let lastParsedIndex = -1;
+  for (let i = 0; i < buffer.length; i++) {
+    const char = buffer[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (char === '"' && !escapeNext) {
+      inString = !inString;
+      continue;
+    }
+    if (inString) {
+      continue;
+    }
+    if (char === "{") {
+      if (braceCount === 0) {
+        startIndex = i;
+      }
+      braceCount++;
+    } else if (char === "}") {
+      braceCount--;
+      if (braceCount === 0) {
+        const jsonStr = buffer.substring(startIndex, i + 1);
+        try {
+          const parsed = JSON.parse(jsonStr);
+          const event = parsed;
+          events.push(event);
+          lastParsedIndex = i;
+        } catch (err) {
+          console.error("Failed to parse JSON event:", jsonStr, err);
+        }
+      }
+    }
+  }
+  const remaining = lastParsedIndex >= 0 ? buffer.substring(lastParsedIndex + 1) : buffer;
+  return { events, remaining };
+}
+async function streamWorkflowEvents(url, body, headers, options = {}) {
+  const { signal, onEvent, onError, onComplete } = options;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        if (buffer.trim()) {
+          const { events: events2 } = parseJSONBuffer(buffer);
+          for (const event of events2) {
+            onEvent?.(event);
+            await yieldAfterProgressEvent(event);
+          }
+        }
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const { events, remaining } = parseJSONBuffer(buffer);
+      for (const event of events) {
+        onEvent?.(event);
+        await yieldAfterProgressEvent(event);
+      }
+      buffer = remaining;
+    }
+    onComplete?.();
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    onError?.(error);
+  }
+}
+var STAGE_LABELS = {
+  sanitizer: "Checking your request",
+  analyzer: "Understanding what you're asking",
+  prefetcher: "Gathering context",
+  planner: "Planning how to handle this",
+  execution: "Working on it",
+  formatter: "Writing the response"
+};
+function stageLabel(stage) {
+  const label = STAGE_LABELS[stage];
+  if (label) return label;
+  const pretty = stage.replace(/[_-]/g, " ");
+  return `Running ${pretty}`;
+}
+function isBlandStatus(message) {
+  if (!message) return true;
+  const normalized = message.trim().toLowerCase().replace(/[…\.]+$/, "").trim();
+  return BLAND_STATUS_LABELS.has(normalized);
+}
+var BLAND_STATUS_LABELS = /* @__PURE__ */ new Set([
+  "executing",
+  "working on it",
+  "thinking",
+  "processing",
+  "reviewing your request",
+  "composing response",
+  "checking your request",
+  "polishing the response"
+]);
+function getEventMessage(event) {
+  if (event.message?.trim()) {
+    return event.message.trim();
+  }
+  if (event.errorMessage?.trim()) {
+    return event.errorMessage.trim();
+  }
+  const eventType = event.eventType;
+  switch (eventType) {
+    case "RUN_STARTED":
+      return "Starting agent run...";
+    case "TOOL_CALL_STARTED": {
+      const description = typeof event.description === "string" ? event.description.trim() : "";
+      if (description) return description;
+      const toolName = typeof event.toolName === "string" ? event.toolName : "";
+      return toolName ? `Calling ${toolName}...` : "Calling tool...";
+    }
+    case "TOOL_CALL_COMPLETED": {
+      const description = typeof event.description === "string" ? event.description.trim() : "";
+      if (description) return description;
+      const toolName = typeof event.toolName === "string" ? event.toolName : "";
+      return toolName ? `${toolName} completed` : "Tool call completed";
+    }
+    case "RUN_IN_PROGRESS":
+      return event.partialText || "Thinking...";
+    case "RUN_COMPLETED":
+      return "Agent run completed";
+    case "RUN_FAILED":
+      return event.errorMessage || "Agent run failed";
+    case "KEEP_ALIVE":
+      return event.description || "";
+    case "THINKING_DELTA":
+      return event.text || "";
+    default:
+      return eventType;
+  }
+}
+function extractResponseContent(response) {
+  if (typeof response === "string") {
+    return response;
+  }
+  if (typeof response === "object" && response !== null) {
+    const resp = response;
+    if ("text" in resp && typeof resp.text === "string") {
+      return resp.text;
+    }
+    if ("content" in resp && typeof resp.content === "string") {
+      return resp.content;
+    }
+    if ("message" in resp && typeof resp.message === "string") {
+      return resp.message;
+    }
+    if ("answer" in resp && typeof resp.answer === "string") {
+      return resp.answer;
+    }
+    return JSON.stringify(response);
+  }
+  return "";
+}
+function normalizeEvent(event) {
+  const type = event.eventType;
+  switch (type) {
+    case "RUN_STARTED":
+      return { ...event, eventType: "WORKFLOW_STARTED" };
+    case "TOOL_CALL_STARTED": {
+      const toolName = typeof event.toolName === "string" ? event.toolName : void 0;
+      const description = typeof event.description === "string" ? event.description.trim() : "";
+      return {
+        ...event,
+        eventType: "INTENT_STARTED",
+        workerName: toolName ?? event.workerName,
+        message: description || event.message
+      };
+    }
+    case "TOOL_CALL_COMPLETED": {
+      const toolName = typeof event.toolName === "string" ? event.toolName : void 0;
+      const description = typeof event.description === "string" ? event.description.trim() : "";
+      return {
+        ...event,
+        eventType: "INTENT_COMPLETED",
+        workerName: toolName ?? event.workerName,
+        message: description || event.message
+      };
+    }
+    case "RUN_IN_PROGRESS":
+      return {
+        ...event,
+        eventType: "INTENT_PROGRESS",
+        message: event.partialText ?? event.message
+      };
+    case "RUN_COMPLETED":
+      return {
+        ...event,
+        eventType: "WORKFLOW_COMPLETED",
+        // state machine reads event.response for the final content
+        response: event.response ?? event.message
+      };
+    case "RUN_FAILED":
+      return {
+        ...event,
+        eventType: "WORKFLOW_ERROR",
+        errorMessage: event.errorMessage ?? event.message
+      };
+    default:
+      return event;
+  }
+}
+function isVerificationSchema(schema) {
+  const props = schema?.properties;
+  if (!props) return false;
+  const keys = Object.keys(props);
+  return keys.length === 1 && keys[0] === "verificationCode";
+}
+function classifyUserActionKind(action, schema) {
+  switch ((action || "").toLowerCase()) {
+    case "userverificationrequest":
+      return "verification";
+    case "usernotificationrequest":
+      return "notification";
+    case "userformrequest":
+      return isVerificationSchema(schema) ? "verification" : "form";
+    default:
+      return isVerificationSchema(schema) ? "verification" : "form";
+  }
+}
+function getEventText(event, field) {
+  const value = event[field];
+  return typeof value === "string" ? value.trim() : "";
+}
+function updateExecutionStageMessage(state, msg) {
+  if (!msg) return;
+  for (let i = state.steps.length - 1; i >= 0; i--) {
+    const s2 = state.steps[i];
+    if (s2.eventType === "STAGE_STARTED" && (s2.stage === "executor" || s2.stage === "execution") && s2.status === "in_progress") {
+      s2.message = msg;
+      return;
+    }
+  }
+}
+function completeLastInProgressStep(steps) {
+  for (let i = steps.length - 1; i >= 0; i--) {
+    if (steps[i].status === "in_progress") {
+      steps[i].status = "completed";
+      return;
+    }
+  }
+}
+function createInitialV2State() {
+  return {
+    finalResponse: "",
+    lastEventType: "",
+    sessionId: void 0,
+    executionId: void 0,
+    hasError: false,
+    errorMessage: "",
+    userActions: [],
+    notifications: [],
+    lastUserAction: void 0,
+    lastNotification: void 0,
+    finalData: void 0,
+    steps: [],
+    stepCounter: 0,
+    currentExecutingStepId: void 0
+  };
+}
+function upsertUserAction(state, req) {
+  const active = { ...req, status: "pending" };
+  const matchIdx = state.userActions.findIndex(
+    (p) => req.toolCallId ? p.toolCallId === req.toolCallId : p.userActionId === req.userActionId
+  );
+  if (matchIdx >= 0) {
+    state.userActions[matchIdx] = active;
+  } else {
+    state.userActions.push(active);
+  }
+}
+function processStreamEventV2(rawEvent, state) {
+  const event = normalizeEvent(rawEvent);
+  const eventType = event.eventType;
+  state.lastUserAction = void 0;
+  state.lastNotification = void 0;
+  if (typeof eventType === "string" && eventType.toUpperCase() === "KEEP_ALIVE") {
+    if (event.executionId) state.executionId = event.executionId;
+    if (event.sessionId) state.sessionId = event.sessionId;
+    const description = typeof event.description === "string" ? event.description : "";
+    if (description) {
+      for (let i = state.steps.length - 1; i >= 0; i--) {
+        if (state.steps[i].status === "in_progress") {
+          state.steps[i].message = description;
+          break;
+        }
+      }
+    }
+    return state;
+  }
+  if (typeof eventType === "string" && eventType.toUpperCase() === "THINKING_DELTA") {
+    if (event.executionId) state.executionId = event.executionId;
+    if (event.sessionId) state.sessionId = event.sessionId;
+    state.lastEventType = "THINKING_DELTA";
+    return state;
+  }
+  if (event.executionId) state.executionId = event.executionId;
+  if (event.sessionId) state.sessionId = event.sessionId;
+  const message = getEventMessage(event);
+  switch (eventType) {
+    case "WORKFLOW_STARTED":
+      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_STARTED": {
+      const stepId = `step-${state.stepCounter++}`;
+      state.steps.push({
+        id: stepId,
+        eventType,
+        message,
+        status: "in_progress",
+        timestamp: Date.now(),
+        elapsedMs: event.elapsedMs
+      });
+      state.currentExecutingStepId = stepId;
+      updateExecutionStageMessage(state, message);
+      state.lastEventType = eventType;
+      break;
+    }
+    case "INTENT_COMPLETED": {
+      const intentStep = state.steps.find((s2) => s2.eventType === "INTENT_STARTED" && s2.status === "in_progress");
+      if (intentStep) {
+        intentStep.status = "completed";
+        if (event.elapsedMs) intentStep.elapsedMs = event.elapsedMs;
+        if (intentStep.id === state.currentExecutingStepId) state.currentExecutingStepId = void 0;
+      }
+      state.lastEventType = eventType;
+      break;
+    }
+    case "WORKFLOW_COMPLETED": {
+      const totalTime = Number(event.totalTimeMs);
+      if (Number.isFinite(totalTime) && totalTime > 0) {
+        state.totalElapsedMs = totalTime;
+      }
+      const content = extractResponseContent(event.response);
+      if (content) {
+        state.finalResponse = content;
+        if (event.trace && typeof event.trace === "object") {
+          state.finalData = event.trace;
+        }
+        state.hasError = false;
+        state.errorMessage = "";
+      } else {
+        state.hasError = true;
+        state.errorMessage = "WORKFLOW_FAILED";
+      }
+      state.steps.forEach((step) => {
+        if (step.status === "in_progress") {
+          step.status = "completed";
+        }
+      });
+      state.lastEventType = eventType;
+      break;
+    }
+    case "USER_ACTION_REQUIRED": {
+      const rawAction = typeof event.action === "string" ? event.action : void 0;
+      const schema = event.requestedSchema;
+      const kind = classifyUserActionKind(rawAction, schema);
+      const promptMessage = typeof event.message === "string" && event.message.trim() || message || "";
+      const userActionId = typeof event.userActionId === "string" ? event.userActionId : "";
+      if (kind === "notification") {
+        const notification = {
+          id: userActionId || `note-${state.stepCounter++}`,
+          message: promptMessage
+        };
+        state.notifications.push(notification);
+        state.lastNotification = notification;
+        state.lastEventType = eventType;
+        break;
+      }
+      if (!userActionId) {
+        state.lastEventType = eventType;
+        break;
+      }
+      completeLastInProgressStep(state.steps);
+      const verificationType = event.verificationType === "ALPHANUMERIC_CODE" || event.verificationType === "NUMERIC_CODE" ? event.verificationType : void 0;
+      const request = {
+        userActionId,
+        kind,
+        rawAction,
+        subAction: typeof event.subAction === "string" ? event.subAction : void 0,
+        verificationType,
+        expirySeconds: typeof event.expirySeconds === "number" ? event.expirySeconds : void 0,
+        message: promptMessage || void 0,
+        requestedSchema: schema,
+        metadata: event.metadata,
+        toolCallId: typeof event.toolCallId === "string" ? event.toolCallId : void 0,
+        executionId: state.executionId,
+        sessionId: state.sessionId
+      };
+      upsertUserAction(state, request);
+      state.lastUserAction = request;
+      const stepId = `step-${state.stepCounter++}`;
+      state.steps.push({
+        id: stepId,
+        eventType,
+        message: promptMessage || (kind === "verification" ? "Waiting for verification..." : "Waiting for your input..."),
+        status: "in_progress",
+        timestamp: Date.now(),
+        elapsedMs: event.elapsedMs
+      });
+      state.currentExecutingStepId = stepId;
+      state.lastEventType = eventType;
+      break;
+    }
+    case "USER_NOTIFICATION": {
+      const noteMessage = typeof event.message === "string" && event.message.trim() || message || "";
+      const userActionId = typeof event.userActionId === "string" ? event.userActionId : "";
+      if (noteMessage || userActionId) {
+        const notification = {
+          id: userActionId || `note-${state.stepCounter++}`,
+          message: noteMessage
+        };
+        state.notifications.push(notification);
+        state.lastNotification = notification;
+      }
+      state.lastEventType = eventType;
+      break;
+    }
+    case "WORKFLOW_ERROR":
+      state.hasError = true;
+      state.errorMessage = event.errorMessage || event.message || "Workflow error";
+      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 s2 = state.steps[i];
+          if (s2.eventType === "STAGE_STARTED" && s2.stage === "analyzer" && s2.status === "completed" && s2.message) {
+            initialMessage = s2.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 s2 = state.steps[i];
+        if (s2.eventType === "STAGE_STARTED" && s2.stage === stage && s2.status === "in_progress") {
+          if (serverMessage) s2.message = serverMessage;
+          s2.status = "completed";
+          const durationMs = Number(event.durationMs);
+          if (Number.isFinite(durationMs)) s2.elapsedMs = durationMs;
+          if (s2.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 s2 = state.steps[i];
+        if (s2.eventType === "STAGE_STARTED" && s2.stage === stage && s2.status === "in_progress") {
+          if (serverMessage) s2.message = serverMessage;
+          s2.status = "error";
+          const durationMs = Number(event.durationMs);
+          if (Number.isFinite(durationMs)) s2.elapsedMs = durationMs;
+          if (s2.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 s2 = state.steps[i];
+        if (s2.eventType === "STAGE_STARTED" && s2.stage === stage && s2.status === "in_progress") {
+          if (s2.id === state.currentExecutingStepId) {
+            state.currentExecutingStepId = void 0;
+          }
+          s2.status = "skipped";
+          break;
+        }
+      }
+      state.lastEventType = eventType;
+      break;
+    }
+    default:
+      state.lastEventType = eventType;
+      break;
+  }
+  return state;
+}
+var DEFAULT_STREAM_ENDPOINT = "/api/playground/ask/stream";
+function buildRequestBody(config, userMessage, sessionId, options) {
+  const sessionOwner = config.sessionParams;
+  const sessionOwnerId = sessionOwner?.id?.trim();
+  if (!sessionOwnerId) {
+    throw new Error("ChatConfig.sessionParams.id is required to send ask requests.");
+  }
+  const sessionAttributes = sessionOwner?.attributes && Object.keys(sessionOwner.attributes).length > 0 ? sessionOwner.attributes : void 0;
+  return {
+    agentId: config.agentId,
+    userInput: userMessage,
+    sessionId,
+    sessionOwnerId,
+    sessionOwnerLabel: sessionOwner?.name || void 0,
+    sessionAttributes,
+    analysisMode: options?.analysisMode,
+    locale: resolveLocale(config.locale),
+    timezone: resolveTimezone(config.timezone),
+    ...options?.attachments?.length ? { attachments: options.attachments } : {}
+  };
+}
+function resolveLocale(configured) {
+  if (configured && configured.trim().length > 0) return configured.trim();
+  if (typeof navigator !== "undefined") {
+    const navLocale = navigator.language;
+    if (navLocale && navLocale.length > 0) return navLocale;
+  }
+  return "en-US";
+}
+function resolveTimezone(configured) {
+  if (configured && configured.trim().length > 0) return configured.trim();
+  try {
+    const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (zone && zone.length > 0) return zone;
+  } catch {
+  }
+  return "UTC";
+}
+function buildStreamingUrl(config) {
+  const endpoint = config.api.streamEndpoint || DEFAULT_STREAM_ENDPOINT;
+  const stage = config.stage || "DEV";
+  const stageParamName = config.stageQueryParam ?? "stage";
+  const queryParams = new URLSearchParams({ [stageParamName]: stage });
+  return `${config.api.baseUrl}${endpoint}?${queryParams.toString()}`;
+}
+function buildUserActionUrl(config, userActionId, action) {
+  const endpoint = config.api.streamEndpoint || DEFAULT_STREAM_ENDPOINT;
+  const [endpointPath] = endpoint.split("?");
+  const normalizedEndpointPath = endpointPath.replace(/\/+$/, "");
+  const basePath = normalizedEndpointPath.endsWith("/stream") ? normalizedEndpointPath.slice(0, -"/stream".length) : normalizedEndpointPath;
+  const encodedUserActionId = encodeURIComponent(userActionId);
+  return `${config.api.baseUrl}${basePath}/user-action/${encodedUserActionId}/${action}`;
+}
+function buildResolveImagesUrl(config) {
+  if (config.api.resolveImagesEndpoint) {
+    return `${config.api.baseUrl}${config.api.resolveImagesEndpoint}`;
+  }
+  const streamEndpoint = config.api.streamEndpoint || DEFAULT_STREAM_ENDPOINT;
+  const [endpointPath] = streamEndpoint.split("?");
+  const normalizedEndpointPath = endpointPath.replace(/\/+$/, "");
+  const basePath = normalizedEndpointPath.endsWith("/stream") ? normalizedEndpointPath.slice(0, -"/stream".length) : normalizedEndpointPath;
+  return `${config.api.baseUrl}${basePath}/resolve-image-urls`;
+}
+var NGROK_SKIP_BROWSER_WARNING = "ngrok-skip-browser-warning";
+function buildRequestHeaders(config) {
+  const headers = {
+    ...config.api.headers
+  };
+  if (config.api.authToken) {
+    headers.Authorization = `Bearer ${config.api.authToken}`;
+  }
+  if (!headers[NGROK_SKIP_BROWSER_WARNING]) {
+    headers[NGROK_SKIP_BROWSER_WARNING] = "true";
+  }
+  return headers;
+}
+var RAG_IMAGE_REGEX = /\/api\/rag\/chunks\/[^"'\s]+\/image/;
+function hasRagImages(content) {
+  return RAG_IMAGE_REGEX.test(content);
+}
+async function waitForNextPaint(signal) {
+  if (signal?.aborted) return;
+  await new Promise((resolve) => {
+    let isSettled = false;
+    const finish = () => {
+      if (isSettled) return;
+      isSettled = true;
+      signal?.removeEventListener("abort", finish);
+      resolve();
+    };
+    signal?.addEventListener("abort", finish, { once: true });
+    if (typeof requestAnimationFrame === "function") {
+      requestAnimationFrame(() => {
+        setTimeout(finish, 0);
+      });
+      return;
+    }
+    setTimeout(finish, 0);
+  });
+}
+async function resolveRagImageUrls(config, content, signal) {
+  const url = buildResolveImagesUrl(config);
+  const baseHeaders = buildRequestHeaders(config);
+  const headers = { "Content-Type": "application/json", ...baseHeaders };
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ input: content }),
+    signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  const text = await response.text();
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed === "string") return parsed;
+    if (typeof parsed.output === "string") return parsed.output;
+    if (typeof parsed.result === "string") return parsed.result;
+  } catch {
+  }
+  return text;
+}
+var FRIENDLY_ERROR_MESSAGE = "Oops, something went wrong. Please try again.";
+function useStreamManagerV2(config, callbacks, setMessages, setIsWaitingForResponse) {
+  const abortControllerRef = react.useRef(null);
+  const configRef = react.useRef(config);
+  configRef.current = config;
+  const callbacksRef = react.useRef(callbacks);
+  callbacksRef.current = callbacks;
+  const startStream = react.useCallback(
+    async (userMessage, streamingId, sessionId, externalAbortController, options) => {
+      abortControllerRef.current?.abort();
+      const abortController = externalAbortController ?? new AbortController();
+      abortControllerRef.current = abortController;
+      const state = createInitialV2State();
+      const updateMessage = (update) => {
+        if (abortController.signal.aborted) return;
+        setMessages(
+          (prev) => prev.map(
+            (msg) => msg.id === streamingId ? { ...msg, ...update } : msg
+          )
+        );
+      };
+      try {
+        const currentConfig = configRef.current;
+        const requestBody = buildRequestBody(
+          currentConfig,
+          userMessage,
+          sessionId,
+          options
+        );
+        const url = buildStreamingUrl(currentConfig);
+        const headers = buildRequestHeaders(currentConfig);
+        await streamWorkflowEvents(url, requestBody, headers, {
+          signal: abortController.signal,
+          onEvent: (event) => {
+            if (abortController.signal.aborted) return;
+            processStreamEventV2(event, state);
+            if (state.lastUserAction) {
+              callbacksRef.current.onUserActionRequired?.(state.lastUserAction);
+            }
+            if (state.lastNotification) {
+              callbacksRef.current.onUserNotification?.(state.lastNotification);
+            }
+            const activeStep = state.steps.find((s2) => s2.id === state.currentExecutingStepId);
+            const lastInProgressStep = [...state.steps].reverse().find((s2) => s2.status === "in_progress");
+            const useful = (m) => m && !isBlandStatus(m) ? m : void 0;
+            const latestUsefulStep = [...state.steps].reverse().find(
+              (s2) => s2.message && !isBlandStatus(s2.message)
+            );
+            const currentMessage = useful(activeStep?.message) ?? useful(lastInProgressStep?.message) ?? latestUsefulStep?.message ?? useful(getEventMessage(event)) ?? // Last-resort: every candidate is bland (very first event,
+            // nothing useful seen yet). Render the bland label so the
+            // bubble isn't blank.
+            activeStep?.message ?? lastInProgressStep?.message ?? getEventMessage(event);
+            if (currentMessage) {
+              callbacksRef.current.onStatusMessage?.(currentMessage);
+            }
+            callbacksRef.current.onStepsUpdate?.([...state.steps]);
+            if (state.hasError) {
+              updateMessage({
+                streamingContent: FRIENDLY_ERROR_MESSAGE,
+                content: FRIENDLY_ERROR_MESSAGE,
+                streamProgress: "error",
+                isError: true,
+                errorDetails: state.errorMessage,
+                steps: [...state.steps],
+                currentExecutingStepId: void 0,
+                executionId: state.executionId,
+                sessionId: state.sessionId
+              });
+            } else {
+              updateMessage({
+                streamingContent: state.finalResponse,
+                content: "",
+                currentMessage,
+                streamProgress: "processing",
+                isError: false,
+                steps: [...state.steps],
+                currentExecutingStepId: state.currentExecutingStepId,
+                executionId: state.executionId,
+                sessionId: state.sessionId,
+                isCancelled: false
+              });
+            }
+          },
+          onError: (error) => {
+            setIsWaitingForResponse(false);
+            callbacksRef.current.onStatusMessage?.(null);
+            if (error.name !== "AbortError") {
+              callbacksRef.current.onError?.(error);
+            }
+            const isAborted = error.name === "AbortError";
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? {
+                  ...msg,
+                  isStreaming: false,
+                  streamProgress: isAborted ? "processing" : "error",
+                  isError: !isAborted,
+                  isCancelled: isAborted,
+                  errorDetails: isAborted ? void 0 : error.message,
+                  content: isAborted ? state.finalResponse || "" : state.finalResponse || FRIENDLY_ERROR_MESSAGE,
+                  currentMessage: isAborted ? "Thinking..." : void 0,
+                  steps: [...state.steps].map((step) => {
+                    if (step.status === "in_progress" && isAborted) {
+                      return { ...step, status: "pending" };
+                    }
+                    return step;
+                  }),
+                  currentExecutingStepId: void 0
+                } : msg
+              )
+            );
+          },
+          onComplete: () => {
+            setIsWaitingForResponse(false);
+            callbacksRef.current.onStatusMessage?.(null);
+            callbacksRef.current.onStepsUpdate?.([]);
+            if (state.sessionId && state.sessionId !== sessionId) {
+              callbacksRef.current.onSessionIdChange?.(state.sessionId);
+            }
+            const needsImageResolve = !state.hasError && !abortController.signal.aborted && hasRagImages(state.finalResponse);
+            const finalMessage = {
+              id: streamingId,
+              sessionId: state.sessionId || sessionId,
+              role: "assistant",
+              content: state.hasError ? FRIENDLY_ERROR_MESSAGE : state.finalResponse || "",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              isStreaming: false,
+              streamProgress: state.hasError ? "error" : "completed",
+              isError: state.hasError,
+              errorDetails: state.hasError ? state.errorMessage : void 0,
+              executionId: state.executionId,
+              // Defensive: tracingData must be an object (or undefined)
+              // so the JSON viewer doesn't char-iterate a string. The
+              // event processor already drops bare strings; this is
+              // the last stop before the message leaves the SDK.
+              tracingData: state.finalData != null && typeof state.finalData === "object" ? state.finalData : void 0,
+              steps: state.hasError ? [] : [...state.steps],
+              isCancelled: false,
+              currentExecutingStepId: void 0,
+              isResolvingImages: needsImageResolve,
+              totalElapsedMs: state.hasError ? void 0 : state.totalElapsedMs
+            };
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? finalMessage : msg
+              )
+            );
+            callbacksRef.current.onStreamComplete?.(finalMessage);
+          }
+        });
+        const shouldResolveImages = !abortController.signal.aborted && !state.hasError && hasRagImages(state.finalResponse);
+        if (shouldResolveImages) {
+          await waitForNextPaint(abortController.signal);
+        }
+        if (shouldResolveImages && !abortController.signal.aborted) {
+          try {
+            const resolvedContent = await resolveRagImageUrls(
+              currentConfig,
+              state.finalResponse,
+              abortController.signal
+            );
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? { ...msg, content: resolvedContent, isResolvingImages: false } : msg
+              )
+            );
+          } catch {
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? { ...msg, isResolvingImages: false } : msg
+              )
+            );
+          }
+        }
+        return state.sessionId;
+      } catch (error) {
+        setIsWaitingForResponse(false);
+        if (error.name !== "AbortError") {
+          callbacksRef.current.onError?.(error);
+        }
+        const isAborted = error.name === "AbortError";
+        setMessages(
+          (prev) => prev.map(
+            (msg) => msg.id === streamingId ? {
+              ...msg,
+              isStreaming: false,
+              streamProgress: isAborted ? "processing" : "error",
+              isError: !isAborted,
+              isCancelled: isAborted,
+              errorDetails: isAborted ? void 0 : error.message,
+              content: isAborted ? state.finalResponse || "" : state.finalResponse || FRIENDLY_ERROR_MESSAGE,
+              steps: [...state.steps].map((step) => {
+                if (step.status === "in_progress" && isAborted) {
+                  return { ...step, status: "pending" };
+                }
+                return step;
+              }),
+              currentExecutingStepId: void 0
+            } : msg
+          )
+        );
+        return state.sessionId;
+      }
+    },
+    [setMessages, setIsWaitingForResponse]
+  );
+  const cancelStream = react.useCallback(() => {
+    abortControllerRef.current?.abort();
+  }, []);
+  return {
+    startStream,
+    cancelStream,
+    abortControllerRef
+  };
+}
+function createCancelledMessageUpdate(steps, currentMessage) {
+  const updatedSteps = steps.map((step) => {
+    if (step.status === "in_progress") {
+      return { ...step, status: "pending" };
+    }
+    return step;
+  });
+  return {
+    isStreaming: false,
+    isCancelled: true,
+    steps: updatedSteps,
+    currentExecutingStepId: void 0,
+    currentMessage: currentMessage || "Thinking..."
+  };
+}
+var DEFAULT_SIGNED_URL_ENDPOINT = "/api/files/signed-url";
+function fileExtension(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase().replace(/^\./, "");
+  return ext && ext.length > 0 ? ext : "bin";
+}
+function resolveMimeType(file) {
+  if (file.type && file.type.trim().length > 0) return file.type;
+  const ext = fileExtension(file.name);
+  const byExt = {
+    pdf: "application/pdf",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp"
+  };
+  return byExt[ext] ?? "application/octet-stream";
+}
+function buildSignedUrlEndpoint(config, ext) {
+  const endpoint = config.api.signedUrlEndpoint || DEFAULT_SIGNED_URL_ENDPOINT;
+  const queryParams = new URLSearchParams({ extn: ext.replace(/^\./, "") });
+  return `${config.api.baseUrl}${endpoint}?${queryParams.toString()}`;
+}
+async function requestSignedUrl(config, ext, signal) {
+  const url = buildSignedUrlEndpoint(config, ext);
+  const headers = buildRequestHeaders(config);
+  const response = await fetch(url, {
+    method: "GET",
+    headers,
+    signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "");
+    throw new Error(
+      errorText ? `Failed to get upload URL (${response.status}): ${errorText}` : `Failed to get upload URL (${response.status})`
+    );
+  }
+  const data = await response.json();
+  if (!data.key || !data.url) {
+    throw new Error("Signed URL response missing key or url");
+  }
+  return { key: data.key, url: data.url };
+}
+async function uploadToSignedUrl(signedUrl, file, mimeType, signal) {
+  const response = await fetch(signedUrl, {
+    method: "PUT",
+    headers: {
+      "Content-Type": mimeType,
+      "x-ms-blob-type": "BlockBlob"
+    },
+    body: file,
+    signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "");
+    throw new Error(
+      errorText ? `Failed to upload file (${response.status}): ${errorText}` : `Failed to upload file (${response.status})`
+    );
+  }
+}
+async function uploadAttachment(config, file, signal) {
+  const ext = fileExtension(file.name);
+  const mimeType = resolveMimeType(file);
+  const { key, url } = await requestSignedUrl(config, ext, signal);
+  await uploadToSignedUrl(url, file, mimeType, signal);
+  return {
+    tempKey: key,
+    filename: file.name,
+    mimeType
+  };
+}
+async function uploadAttachments(config, files, signal) {
+  const uploads = files.map((file) => uploadAttachment(config, file, signal));
+  return Promise.all(uploads);
+}
+var UserActionStaleError = class extends Error {
+  constructor(userActionId, message = "User action is no longer actionable") {
+    super(message);
+    __publicField(this, "userActionId");
+    this.name = "UserActionStaleError";
+    this.userActionId = userActionId;
+  }
+};
+async function sendUserActionRequest(config, userActionId, action, data) {
+  const url = buildUserActionUrl(config, userActionId, action);
+  const baseHeaders = buildRequestHeaders(config);
+  const hasBody = data !== void 0;
+  const headers = hasBody ? { "Content-Type": "application/json", ...baseHeaders } : baseHeaders;
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: hasBody ? JSON.stringify(data) : void 0
+  });
+  if (response.status === 404) {
+    throw new UserActionStaleError(userActionId);
+  }
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  return await response.json();
+}
+async function submitUserAction(config, userActionId, content) {
+  return sendUserActionRequest(config, userActionId, "submit", content ?? {});
+}
+async function cancelUserAction(config, userActionId) {
+  return sendUserActionRequest(config, userActionId, "cancel");
+}
+async function resendUserAction(config, userActionId) {
+  return sendUserActionRequest(config, userActionId, "resend");
+}
+var EMPTY_USER_ACTION_STATE = { prompts: [], notifications: [] };
+function upsertPrompt(prompts, req) {
+  const active = { ...req, status: "pending" };
+  const idx = prompts.findIndex(
+    (p) => req.toolCallId ? p.toolCallId === req.toolCallId : p.userActionId === req.userActionId
+  );
+  if (idx >= 0) {
+    const next = prompts.slice();
+    next[idx] = active;
+    return next;
+  }
+  return [...prompts, active];
+}
+function getStoredOrInitialMessages(config) {
+  if (!config.userId) return config.initialMessages ?? [];
+  const activeStream = activeStreamStore.get(config.userId);
+  if (activeStream) return activeStream.messages;
+  const stored = chatStore.get(config.userId);
+  if (stored.length > 0) return stored;
+  if (config.initialMessages?.length) {
+    chatStore.set(config.userId, config.initialMessages);
+    return config.initialMessages;
+  }
+  return [];
+}
+function getSessionIdFromMessages(messages) {
+  return messages.find((message) => message.sessionId)?.sessionId;
+}
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set(["jpg", "jpeg", "png", "gif", "webp", "avif"]);
+function attachmentKindFromFile(file) {
+  const ext = file.name.split(".").pop()?.toLowerCase() ?? "";
+  if (IMAGE_EXTENSIONS.has(ext) || file.type.startsWith("image/")) return "image";
+  return "file";
+}
+function buildMessageAttachments(files) {
+  return files.map((file, index) => {
+    const kind = attachmentKindFromFile(file);
+    return {
+      id: `att-${Date.now()}-${index}`,
+      filename: file.name,
+      mimeType: file.type || "application/octet-stream",
+      // Blob URL for all local files so PDFs/docs stay previewable after send.
+      previewUrl: URL.createObjectURL(file),
+      kind
+    };
+  });
+}
+function useChatV2(config, callbacks = {}) {
+  const [messages, setMessages] = react.useState(() => getStoredOrInitialMessages(config));
+  const [isWaitingForResponse, setIsWaitingForResponse] = react.useState(() => {
+    if (!config.userId) return false;
+    return activeStreamStore.get(config.userId)?.isWaiting ?? false;
+  });
+  const [isUploadingAttachments, setIsUploadingAttachments] = react.useState(false);
+  const sessionIdRef = react.useRef(
+    getSessionIdFromMessages(getStoredOrInitialMessages(config)) ?? config.initialSessionId ?? void 0
+  );
+  const prevUserIdRef = react.useRef(config.userId);
+  const streamUserIdRef = react.useRef(void 0);
+  const subscriptionPrevUserIdRef = react.useRef(config.userId);
+  const callbacksRef = react.useRef(callbacks);
+  callbacksRef.current = callbacks;
+  const configRef = react.useRef(config);
+  configRef.current = config;
+  const messagesRef = react.useRef(messages);
+  messagesRef.current = messages;
+  const storeAwareSetMessages = react.useCallback(
+    (updater) => {
+      const streamUserId = streamUserIdRef.current;
+      const currentUserId = configRef.current.userId;
+      const storeKey = streamUserId ?? currentUserId;
+      if (storeKey && activeStreamStore.has(storeKey)) {
+        activeStreamStore.applyMessages(storeKey, updater);
+      }
+      if (!streamUserId || streamUserId === currentUserId) {
+        setMessages(updater);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const storeAwareSetIsWaiting = react.useCallback(
+    (waiting) => {
+      const streamUserId = streamUserIdRef.current;
+      const currentUserId = configRef.current.userId;
+      const storeKey = streamUserId ?? currentUserId;
+      if (storeKey && activeStreamStore.has(storeKey)) {
+        activeStreamStore.setWaiting(storeKey, waiting);
+      }
+      if (!streamUserId || streamUserId === currentUserId) {
+        setIsWaitingForResponse(waiting);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const [userActionState, setUserActionState] = react.useState(EMPTY_USER_ACTION_STATE);
+  const wrappedCallbacks = react.useMemo(() => ({
+    ...callbacksRef.current,
+    onMessageSent: (message) => callbacksRef.current.onMessageSent?.(message),
+    onStreamStart: () => callbacksRef.current.onStreamStart?.(),
+    onStreamComplete: (message) => callbacksRef.current.onStreamComplete?.(message),
+    onError: (error) => callbacksRef.current.onError?.(error),
+    onExecutionTraceClick: (data) => callbacksRef.current.onExecutionTraceClick?.(data),
+    onSessionIdChange: (sessionId) => callbacksRef.current.onSessionIdChange?.(sessionId),
+    onUserActionRequired: (request) => {
+      setUserActionState((prev) => ({
+        ...prev,
+        prompts: upsertPrompt(prev.prompts, request)
+      }));
+      callbacksRef.current.onUserActionRequired?.(request);
+    },
+    onUserNotification: (notification) => {
+      setUserActionState(
+        (prev) => prev.notifications.some((n) => n.id === notification.id) ? prev : { ...prev, notifications: [...prev.notifications, notification] }
+      );
+      callbacksRef.current.onUserNotification?.(notification);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }), []);
+  const { startStream, cancelStream: cancelStreamManager, abortControllerRef } = useStreamManagerV2(
+    config,
+    wrappedCallbacks,
+    storeAwareSetMessages,
+    storeAwareSetIsWaiting
+  );
+  const sendMessage = react.useCallback(
+    async (userMessage, options) => {
+      const trimmedMessage = userMessage.trim();
+      const files = options?.files ?? [];
+      const hasPreuploadedAttachments = (options?.attachments?.length ?? 0) > 0;
+      if (!trimmedMessage && files.length === 0 && !hasPreuploadedAttachments) return;
+      let streamAttachments = options?.attachments;
+      if (!streamAttachments && files.length > 0) {
+        setIsUploadingAttachments(true);
+        try {
+          streamAttachments = await uploadAttachments(configRef.current, files);
+        } catch (error) {
+          if (error.name !== "AbortError") {
+            callbacksRef.current.onError?.(error);
+          }
+          throw error;
+        } finally {
+          setIsUploadingAttachments(false);
+        }
+      }
+      if (!sessionIdRef.current && configRef.current.autoGenerateSessionId !== false) {
+        sessionIdRef.current = generateId();
+        callbacksRef.current.onSessionIdChange?.(sessionIdRef.current);
+      }
+      const messageAttachments = files.length > 0 ? buildMessageAttachments(files) : streamAttachments?.length ? streamAttachments.map((attachment, index) => ({
+        id: `att-${Date.now()}-${index}`,
+        filename: attachment.filename,
+        mimeType: attachment.mimeType,
+        kind: attachment.mimeType.startsWith("image/") ? "image" : "file"
+      })) : void 0;
+      const userMessageId = `user-${Date.now()}`;
+      const userMsg = {
+        id: userMessageId,
+        sessionId: sessionIdRef.current,
+        role: "user",
+        content: trimmedMessage,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        attachments: messageAttachments
+      };
+      setMessages((prev) => [...prev, userMsg]);
+      callbacksRef.current.onMessageSent?.(trimmedMessage);
+      setIsWaitingForResponse(true);
+      callbacksRef.current.onStreamStart?.();
+      const streamingId = `assistant-${Date.now()}`;
+      const streamingMsg = {
+        id: streamingId,
+        sessionId: sessionIdRef.current,
+        role: "assistant",
+        content: "",
+        streamingContent: "",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        isStreaming: true,
+        streamProgress: "started",
+        steps: [],
+        currentExecutingStepId: void 0,
+        isCancelled: false,
+        currentMessage: void 0
+      };
+      setMessages((prev) => [...prev, streamingMsg]);
+      const abortController = new AbortController();
+      const { userId } = configRef.current;
+      if (userId) {
+        streamUserIdRef.current = userId;
+        const initialMessages = [...messagesRef.current, userMsg, streamingMsg];
+        activeStreamStore.start(userId, abortController, initialMessages);
+      }
+      const newSessionId = await startStream(
+        trimmedMessage,
+        streamingId,
+        sessionIdRef.current,
+        abortController,
+        {
+          analysisMode: options?.analysisMode,
+          attachments: streamAttachments
+        }
+      );
+      const finalStreamUserId = streamUserIdRef.current ?? userId;
+      if (finalStreamUserId) {
+        activeStreamStore.complete(finalStreamUserId);
+      }
+      streamUserIdRef.current = void 0;
+      if (!abortController.signal.aborted && newSessionId && newSessionId !== sessionIdRef.current) {
+        sessionIdRef.current = newSessionId;
+      }
+    },
+    [startStream]
+  );
+  const clearMessages = react.useCallback(() => {
+    if (configRef.current.userId) {
+      chatStore.delete(configRef.current.userId);
+    }
+    setMessages([]);
+  }, []);
+  const prependMessages = react.useCallback((msgs) => {
+    setMessages((prev) => [...msgs, ...prev]);
+  }, []);
+  const cancelStream = react.useCallback(() => {
+    const streamUserId = streamUserIdRef.current ?? configRef.current.userId;
+    if (streamUserId) {
+      activeStreamStore.abort(streamUserId);
+    }
+    streamUserIdRef.current = void 0;
+    cancelStreamManager();
+    setIsWaitingForResponse(false);
+    setUserActionState((prev) => ({ ...prev, prompts: [] }));
+    setMessages(
+      (prev) => prev.map((msg) => {
+        if (msg.isStreaming) {
+          return {
+            ...msg,
+            ...createCancelledMessageUpdate(
+              msg.steps || [],
+              msg.currentMessage
+            )
+          };
+        }
+        return msg;
+      })
+    );
+  }, [cancelStreamManager]);
+  const resetSession = react.useCallback(() => {
+    const streamUserId = streamUserIdRef.current ?? configRef.current.userId;
+    if (streamUserId) {
+      activeStreamStore.abort(streamUserId);
+    }
+    if (configRef.current.userId) {
+      chatStore.delete(configRef.current.userId);
+    }
+    streamUserIdRef.current = void 0;
+    setMessages([]);
+    sessionIdRef.current = void 0;
+    abortControllerRef.current?.abort();
+    setIsWaitingForResponse(false);
+    setUserActionState(EMPTY_USER_ACTION_STATE);
+  }, []);
+  const getSessionId = react.useCallback(() => {
+    return sessionIdRef.current;
+  }, []);
+  const getMessages = react.useCallback(() => {
+    return messages;
+  }, [messages]);
+  const setPromptStatus = react.useCallback(
+    (userActionId, status) => {
+      setUserActionState((prev) => ({
+        ...prev,
+        prompts: prev.prompts.map(
+          (p) => p.userActionId === userActionId ? { ...p, status } : p
+        )
+      }));
+    },
+    []
+  );
+  const removePrompt = react.useCallback((userActionId) => {
+    setUserActionState((prev) => ({
+      ...prev,
+      prompts: prev.prompts.filter((p) => p.userActionId !== userActionId)
+    }));
+  }, []);
+  const submitUserAction2 = react.useCallback(
+    async (userActionId, content) => {
+      setPromptStatus(userActionId, "submitting");
+      try {
+        await submitUserAction(configRef.current, userActionId, content);
+        removePrompt(userActionId);
+      } catch (error) {
+        if (error instanceof UserActionStaleError) {
+          setPromptStatus(userActionId, "stale");
+          return;
+        }
+        setPromptStatus(userActionId, "pending");
+        callbacksRef.current.onError?.(error);
+        throw error;
+      }
+    },
+    [removePrompt, setPromptStatus]
+  );
+  const cancelUserAction2 = react.useCallback(
+    async (userActionId) => {
+      setPromptStatus(userActionId, "submitting");
+      try {
+        await cancelUserAction(configRef.current, userActionId);
+        removePrompt(userActionId);
+      } catch (error) {
+        if (error instanceof UserActionStaleError) {
+          removePrompt(userActionId);
+          return;
+        }
+        setPromptStatus(userActionId, "pending");
+        callbacksRef.current.onError?.(error);
+        throw error;
+      }
+    },
+    [removePrompt, setPromptStatus]
+  );
+  const resendUserAction2 = react.useCallback(
+    async (userActionId) => {
+      setPromptStatus(userActionId, "submitting");
+      try {
+        await resendUserAction(configRef.current, userActionId);
+        setPromptStatus(userActionId, "pending");
+      } catch (error) {
+        if (error instanceof UserActionStaleError) {
+          setPromptStatus(userActionId, "stale");
+          return;
+        }
+        setPromptStatus(userActionId, "pending");
+        callbacksRef.current.onError?.(error);
+        throw error;
+      }
+    },
+    [setPromptStatus]
+  );
+  const dismissNotification = react.useCallback((id) => {
+    setUserActionState((prev) => ({
+      ...prev,
+      notifications: prev.notifications.filter((n) => n.id !== id)
+    }));
+  }, []);
+  react.useEffect(() => {
+    const prevSubscriptionUserId = subscriptionPrevUserIdRef.current;
+    subscriptionPrevUserIdRef.current = config.userId;
+    const { userId } = config;
+    if (!userId) return;
+    if (prevSubscriptionUserId && prevSubscriptionUserId !== userId && streamUserIdRef.current === prevSubscriptionUserId && !activeStreamStore.has(prevSubscriptionUserId) && activeStreamStore.has(userId)) {
+      streamUserIdRef.current = userId;
+    }
+    const unsubscribe = activeStreamStore.subscribe(userId, (msgs, isWaiting) => {
+      setMessages(msgs);
+      setIsWaitingForResponse(isWaiting);
+    });
+    const active = activeStreamStore.get(userId);
+    if (active) {
+      setMessages(active.messages);
+      setIsWaitingForResponse(active.isWaiting);
+    }
+    return unsubscribe;
+  }, [config.userId]);
+  react.useEffect(() => {
+    if (!config.userId) return;
+    if (prevUserIdRef.current !== config.userId) return;
+    const toSave = messages.filter((m) => !m.isStreaming);
+    if (toSave.length > 0) {
+      chatStore.set(config.userId, toSave);
+    }
+  }, [messages, config.userId]);
+  react.useEffect(() => {
+    if (!config.userId || activeStreamStore.has(config.userId)) return;
+    if (!config.initialMessages?.length || messagesRef.current.length > 0) return;
+    chatStore.set(config.userId, config.initialMessages);
+    setMessages(config.initialMessages);
+    sessionIdRef.current = getSessionIdFromMessages(config.initialMessages) ?? config.initialSessionId;
+  }, [config.initialMessages, config.initialSessionId, config.userId]);
+  const hydratedSessionIdRef = react.useRef(void 0);
+  react.useEffect(() => {
+    if (config.userId) return;
+    if (!config.initialMessages?.length) return;
+    const sessionId = config.initialSessionId;
+    if (hydratedSessionIdRef.current === sessionId && messagesRef.current.length > 0) {
+      return;
+    }
+    hydratedSessionIdRef.current = sessionId;
+    setMessages(config.initialMessages);
+    sessionIdRef.current = getSessionIdFromMessages(config.initialMessages) ?? sessionId;
+  }, [config.initialMessages, config.initialSessionId, config.userId]);
+  react.useEffect(() => {
+    const prevUserId = prevUserIdRef.current;
+    prevUserIdRef.current = config.userId;
+    if (prevUserId === config.userId) return;
+    if (prevUserId && !config.userId) {
+      chatStore.delete(prevUserId);
+      setMessages([]);
+      sessionIdRef.current = void 0;
+      setIsWaitingForResponse(false);
+      setUserActionState(EMPTY_USER_ACTION_STATE);
+    } else if (config.userId) {
+      const active = activeStreamStore.get(config.userId);
+      if (active) {
+        setMessages(active.messages);
+        setIsWaitingForResponse(active.isWaiting);
+        sessionIdRef.current = getSessionIdFromMessages(active.messages) ?? config.initialSessionId;
+        return;
+      }
+      const nextMessages = getStoredOrInitialMessages(config);
+      setMessages(nextMessages);
+      sessionIdRef.current = getSessionIdFromMessages(nextMessages) ?? config.initialSessionId;
+      setIsWaitingForResponse(false);
+    }
+  }, [config]);
+  return {
+    messages,
+    sendMessage,
+    clearMessages,
+    prependMessages,
+    cancelStream,
+    resetSession,
+    getSessionId,
+    getMessages,
+    isWaitingForResponse,
+    isUploadingAttachments,
+    sessionId: sessionIdRef.current,
+    userActionState,
+    submitUserAction: submitUserAction2,
+    cancelUserAction: cancelUserAction2,
+    resendUserAction: resendUserAction2,
+    dismissNotification
+  };
+}
+function getSpeechRecognition() {
+  if (typeof window === "undefined") return null;
+  return window.SpeechRecognition || window.webkitSpeechRecognition || null;
+}
+function useVoice(config = {}, callbacks = {}) {
+  const [voiceState, setVoiceState] = react.useState("idle");
+  const [transcribedText, setTranscribedText] = react.useState("");
+  const [isAvailable, setIsAvailable] = react.useState(false);
+  const [isRecording, setIsRecording] = react.useState(false);
+  const recognitionRef = react.useRef(null);
+  const autoStopTimerRef = react.useRef(null);
+  const {
+    lang = "en-US",
+    interimResults = true,
+    continuous = true,
+    maxAlternatives = 1,
+    autoStopAfterSilence
+  } = config;
+  const { onStart, onEnd, onResult, onError, onStateChange } = callbacks;
+  react.useEffect(() => {
+    const SpeechRecognitionAPI = getSpeechRecognition();
+    setIsAvailable(SpeechRecognitionAPI !== null);
+  }, []);
+  react.useEffect(() => {
+    onStateChange?.(voiceState);
+  }, [voiceState, onStateChange]);
+  const requestPermissions = react.useCallback(async () => {
+    try {
+      const result = await navigator.mediaDevices.getUserMedia({
+        audio: true
+      });
+      result.getTracks().forEach((track) => track.stop());
+      return {
+        granted: true,
+        status: "granted"
+      };
+    } catch (error) {
+      return {
+        granted: false,
+        status: "denied"
+      };
+    }
+  }, []);
+  const getPermissions = react.useCallback(async () => {
+    if (typeof navigator === "undefined" || !navigator.permissions) {
+      return {
+        granted: false,
+        status: "undetermined"
+      };
+    }
+    try {
+      const result = await navigator.permissions.query({
+        name: "microphone"
+      });
+      return {
+        granted: result.state === "granted",
+        status: result.state === "granted" ? "granted" : result.state === "denied" ? "denied" : "undetermined"
+      };
+    } catch {
+      return {
+        granted: false,
+        status: "undetermined"
+      };
+    }
+  }, []);
+  const clearAutoStopTimer = react.useCallback(() => {
+    if (autoStopTimerRef.current) {
+      clearTimeout(autoStopTimerRef.current);
+      autoStopTimerRef.current = null;
+    }
+  }, []);
+  const resetAutoStopTimer = react.useCallback(() => {
+    clearAutoStopTimer();
+    if (autoStopAfterSilence && autoStopAfterSilence > 0) {
+      autoStopTimerRef.current = setTimeout(() => {
+        if (recognitionRef.current && isRecording) {
+          recognitionRef.current.stop();
+        }
+      }, autoStopAfterSilence);
+    }
+  }, [autoStopAfterSilence, clearAutoStopTimer, isRecording]);
+  const stopRecording = react.useCallback(() => {
+    if (recognitionRef.current) {
+      try {
+        recognitionRef.current.stop();
+      } catch (error) {
+        console.warn("Error stopping speech recognition:", error);
+      }
+    }
+    clearAutoStopTimer();
+    setIsRecording(false);
+    setVoiceState("idle");
+  }, [clearAutoStopTimer]);
+  const startRecording = react.useCallback(async () => {
+    const SpeechRecognitionAPI = getSpeechRecognition();
+    if (!SpeechRecognitionAPI) {
+      onError?.("Speech recognition not supported in this browser");
+      return;
+    }
+    try {
+      try {
+        await navigator.mediaDevices.getUserMedia({ audio: true });
+      } catch (permError) {
+        onError?.("Microphone access denied. Please allow microphone access in your browser settings.");
+        return;
+      }
+      const recognition = new SpeechRecognitionAPI();
+      recognition.continuous = continuous;
+      recognition.interimResults = interimResults;
+      recognition.lang = lang;
+      recognition.maxAlternatives = maxAlternatives;
+      recognition.onstart = () => {
+        setVoiceState("listening");
+        setIsRecording(true);
+        onStart?.();
+        resetAutoStopTimer();
+      };
+      recognition.onend = () => {
+        setVoiceState("idle");
+        setIsRecording(false);
+        clearAutoStopTimer();
+        onEnd?.();
+      };
+      recognition.onresult = (event) => {
+        const results = event.results;
+        let transcript = "";
+        for (let i = 0; i < results.length; i++) {
+          const result = results[i];
+          if (result && result[0]) {
+            const text = result[0].transcript;
+            if (transcript && !transcript.endsWith(" ") && !text.startsWith(" ")) {
+              transcript += " " + text;
+            } else {
+              transcript += text;
+            }
+          }
+        }
+        transcript = transcript.trim();
+        if (transcript) {
+          setTranscribedText(transcript);
+          onResult?.(transcript);
+          resetAutoStopTimer();
+        }
+      };
+      recognition.onerror = (event) => {
+        setVoiceState("error");
+        setIsRecording(false);
+        clearAutoStopTimer();
+        let errorMessage = event.error;
+        if (event.error === "not-allowed") {
+          errorMessage = "Microphone access denied. Please allow microphone access in your browser settings.";
+        } else if (event.error === "no-speech") {
+          errorMessage = "No speech detected. Please try again.";
+        } else if (event.error === "audio-capture") {
+          errorMessage = "No microphone found or microphone is in use.";
+        } else if (event.error === "network") {
+          errorMessage = "Network error occurred. Please check your connection.";
+        }
+        onError?.(errorMessage);
+      };
+      recognitionRef.current = recognition;
+      setTranscribedText("");
+      recognition.start();
+    } catch (error) {
+      setVoiceState("error");
+      setIsRecording(false);
+      onError?.(
+        error instanceof Error ? error.message : "Failed to start recording"
+      );
+    }
+  }, [
+    lang,
+    interimResults,
+    continuous,
+    maxAlternatives,
+    onStart,
+    onEnd,
+    onResult,
+    onError,
+    getPermissions,
+    resetAutoStopTimer,
+    clearAutoStopTimer
+  ]);
+  const clearTranscript = react.useCallback(() => {
+    setTranscribedText("");
+  }, []);
+  const reset = react.useCallback(() => {
+    stopRecording();
+    setTranscribedText("");
+    setVoiceState("idle");
+  }, [stopRecording]);
+  react.useEffect(() => {
+    return () => {
+      if (recognitionRef.current) {
+        try {
+          recognitionRef.current.stop();
+        } catch {
+        }
+      }
+      clearAutoStopTimer();
+    };
+  }, [clearAutoStopTimer]);
+  return {
+    voiceState,
+    transcribedText,
+    isAvailable,
+    isRecording,
+    startRecording,
+    stopRecording,
+    requestPermissions,
+    getPermissions,
+    clearTranscript,
+    reset
+  };
+}
+function classifyField(field) {
+  if (!field) return "text";
+  if (Array.isArray(field.oneOf) && field.oneOf.length > 0) return "select";
+  switch (field.type) {
+    case "boolean":
+      return "boolean";
+    case "integer":
+      return "integer";
+    case "number":
+      return "decimal";
+    case "string":
+      return "text";
+    default:
+      return "text";
+  }
+}
+function isNestedOrUnsupported(field) {
+  if (!field) return false;
+  if (field.type === "object" || field.type === "array") return true;
+  if ("properties" in field && field.properties != null) return true;
+  if ("items" in field && field.items != null) return true;
+  return false;
+}
+function getOptions(field) {
+  if (!field || !Array.isArray(field.oneOf)) return [];
+  return field.oneOf.filter(
+    (o) => !!o && typeof o === "object" && typeof o.const === "string"
+  );
+}
+function isRequired(schema, key) {
+  return Array.isArray(schema?.required) && schema.required.includes(key);
+}
+function coerceValue(field, raw) {
+  const widget = classifyField(field);
+  if (widget === "boolean") {
+    if (typeof raw === "boolean") return raw;
+    if (raw === "true") return true;
+    if (raw === "false") return false;
+    return Boolean(raw);
+  }
+  if (widget === "integer" || widget === "decimal") {
+    if (raw === "" || raw == null) return void 0;
+    const num = typeof raw === "number" ? raw : Number(String(raw).trim());
+    if (Number.isNaN(num)) return void 0;
+    return widget === "integer" ? Math.trunc(num) : num;
+  }
+  if (raw == null) return void 0;
+  const str = String(raw);
+  return str === "" ? void 0 : str;
+}
+function defaultValueFor(field) {
+  if (!field || field.default === void 0) {
+    return classifyField(field) === "boolean" ? false : "";
+  }
+  return field.default;
+}
+function validateField(field, value, required) {
+  const widget = classifyField(field);
+  const label = field?.title || "This field";
+  const isEmpty = value === void 0 || value === null || typeof value === "string" && value.trim() === "";
+  if (isEmpty) {
+    if (required && widget !== "boolean") return `${label} is required.`;
+    return null;
+  }
+  if (widget === "integer" || widget === "decimal") {
+    const num = typeof value === "number" ? value : Number(value);
+    if (Number.isNaN(num)) return `${label} must be a number.`;
+    if (widget === "integer" && !Number.isInteger(num)) {
+      return `${label} must be a whole number.`;
+    }
+    if (typeof field?.minimum === "number" && num < field.minimum) {
+      return `${label} must be at least ${field.minimum}.`;
+    }
+    if (typeof field?.maximum === "number" && num > field.maximum) {
+      return `${label} must be at most ${field.maximum}.`;
+    }
+    return null;
+  }
+  if (widget === "select") {
+    const allowed = getOptions(field).map((o) => o.const);
+    if (allowed.length > 0 && !allowed.includes(String(value))) {
+      return `${label} has an invalid selection.`;
+    }
+    return null;
+  }
+  const str = String(value);
+  if (typeof field?.minLength === "number" && str.length < field.minLength) {
+    return `${label} must be at least ${field.minLength} characters.`;
+  }
+  if (typeof field?.maxLength === "number" && str.length > field.maxLength) {
+    return `${label} must be at most ${field.maxLength} characters.`;
+  }
+  return null;
+}
+function renderableFields(schema) {
+  const props = schema?.properties;
+  if (!props) return [];
+  return Object.entries(props).filter(([, field]) => !isNestedOrUnsupported(field));
+}
+function validateForm(schema, values) {
+  const errors = {};
+  for (const [key, field] of renderableFields(schema)) {
+    const coerced = coerceValue(field, values[key]);
+    const err = validateField(field, coerced, isRequired(schema, key));
+    if (err) errors[key] = err;
+  }
+  return errors;
+}
+function buildContent(schema, values) {
+  const content = {};
+  for (const [key, field] of renderableFields(schema)) {
+    const coerced = coerceValue(field, values[key]);
+    if (coerced !== void 0) content[key] = coerced;
+  }
+  return content;
+}
+var PaymanChatContext = react.createContext(void 0);
+function usePaymanChat() {
+  const context = react.useContext(PaymanChatContext);
+  if (!context) {
+    throw new Error("usePaymanChat must be used within a PaymanChat component");
+  }
+  return context;
+}
+if (reactNative.Platform.OS === "android" && reactNative.UIManager.setLayoutAnimationEnabledExperimental) {
+  reactNative.UIManager.setLayoutAnimationEnabledExperimental(true);
+}
+var DEFAULT_ACCENT = "#00858d";
+var VOICE_DOT_COUNT = 24;
+var VOICE_DOT_MIN_H = 5;
+var VOICE_DOT_MAX_H = 14;
+var SPEECH_ACTIVITY_MS = 1400;
+var VOICE_BAR_BG = "#f0f9f9";
+var AI_DISCLAIMER = "AI can make mistakes. Please double-check responses.";
+var VoiceWaveformBar = react.memo(function VoiceWaveformBar2({
+  index,
+  isActive,
+  accent
+}) {
+  const height = react.useRef(new reactNative.Animated.Value(VOICE_DOT_MIN_H)).current;
+  react.useEffect(() => {
+    if (isActive) {
+      const anim = reactNative.Animated.loop(
+        reactNative.Animated.sequence([
+          reactNative.Animated.timing(height, {
+            toValue: VOICE_DOT_MAX_H,
+            duration: 180 + index % 3 * 40,
+            delay: index * 25,
+            easing: reactNative.Easing.inOut(reactNative.Easing.ease),
+            useNativeDriver: false
+          }),
+          reactNative.Animated.timing(height, {
+            toValue: VOICE_DOT_MIN_H,
+            duration: 180 + index % 3 * 40,
+            easing: reactNative.Easing.inOut(reactNative.Easing.ease),
+            useNativeDriver: false
+          })
+        ])
+      );
+      anim.start();
+      return () => anim.stop();
+    }
+    reactNative.Animated.timing(height, { toValue: VOICE_DOT_MIN_H, duration: 200, useNativeDriver: false }).start();
+  }, [isActive, index, height]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Animated.View,
+    {
+      style: [s.voiceDot, { height, backgroundColor: accent + "99" }]
+    }
+  );
+});
+function formatDuration(sec) {
+  const m = Math.floor(sec / 60);
+  const s2 = sec % 60;
+  return `${m}:${s2.toString().padStart(2, "0")}`;
+}
+function InputBar({
+  value,
+  onChange,
+  onSend,
+  onCancel,
+  disabled,
+  placeholder,
+  isStreaming,
+  accent,
+  enableVoice,
+  voiceAvailable,
+  isRecording,
+  recordingSeconds,
+  transcribedText,
+  onVoicePress,
+  onConfirmRecording,
+  onCancelRecording,
+  onFocus,
+  insetBottom
+}) {
+  const canSend = !disabled && !isStreaming && value.trim().length > 0;
+  const voiceDisabled = !voiceAvailable || disabled || isStreaming;
+  const showVoiceBar = enableVoice && isRecording;
+  const showVoiceBtn = enableVoice && !isRecording;
+  const [keyboardOpen, setKeyboardOpen] = react.useState(false);
+  react.useEffect(() => {
+    const show = reactNative.Keyboard.addListener("keyboardWillShow", () => setKeyboardOpen(true));
+    const hide = reactNative.Keyboard.addListener("keyboardWillHide", () => setKeyboardOpen(false));
+    return () => {
+      show.remove();
+      hide.remove();
+    };
+  }, []);
+  const [isSpeaking, setIsSpeaking] = react.useState(false);
+  const prevTranscript = react.useRef("");
+  const speechTimeout = react.useRef(null);
+  react.useEffect(() => {
+    if (!showVoiceBar) {
+      setIsSpeaking(false);
+      prevTranscript.current = "";
+      if (speechTimeout.current) clearTimeout(speechTimeout.current);
+      return;
+    }
+    const changed = transcribedText !== prevTranscript.current;
+    prevTranscript.current = transcribedText;
+    if (changed) {
+      setIsSpeaking(true);
+      if (speechTimeout.current) clearTimeout(speechTimeout.current);
+      speechTimeout.current = setTimeout(() => setIsSpeaking(false), SPEECH_ACTIVITY_MS);
+    }
+    return () => {
+      if (speechTimeout.current) clearTimeout(speechTimeout.current);
+    };
+  }, [showVoiceBar, transcribedText]);
+  const animOpacity = react.useRef(new reactNative.Animated.Value(1)).current;
+  const animScale = react.useRef(new reactNative.Animated.Value(1)).current;
+  react.useEffect(() => {
+    reactNative.LayoutAnimation.configureNext(reactNative.LayoutAnimation.create(200, "easeInEaseOut", "opacity"));
+    if (showVoiceBar) {
+      animOpacity.setValue(0.92);
+      animScale.setValue(0.98);
+      reactNative.Animated.parallel([
+        reactNative.Animated.timing(animOpacity, { toValue: 1, duration: 200, useNativeDriver: true }),
+        reactNative.Animated.spring(animScale, { toValue: 1, useNativeDriver: true, speed: 12, bounciness: 4 })
+      ]).start();
+    } else {
+      animOpacity.setValue(1);
+      animScale.setValue(1);
+    }
+  }, [showVoiceBar, animOpacity, animScale]);
+  const accentLight = accent + "33";
+  const barBorderColor = accent + "59";
+  const bottomPad = keyboardOpen ? 8 : Math.max(insetBottom, 10);
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [s.outerBar, showVoiceBar && s.outerBarVoice, { paddingBottom: bottomPad }], children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: s.column, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [s.inputWrap, showVoiceBar && s.inputWrapRelative], children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.TextInput,
+          {
+            value,
+            onChangeText: onChange,
+            onFocus,
+            editable: !disabled,
+            placeholder,
+            placeholderTextColor: "#9CA3AF",
+            multiline: true,
+            style: [s.input, disabled && s.inputDisabled, showVoiceBar && s.inputHidden],
+            returnKeyType: "default",
+            blurOnSubmit: false,
+            onSubmitEditing: onSend
+          }
+        ),
+        showVoiceBar && /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Animated.View,
+          {
+            pointerEvents: "box-none",
+            style: [s.voiceBarContainer, { opacity: animOpacity, transform: [{ scale: animScale }] }],
+            children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [s.voiceBar, { backgroundColor: VOICE_BAR_BG, borderColor: barBorderColor }], children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                reactNative.Pressable,
+                {
+                  onPress: onCancelRecording,
+                  style: ({ pressed }) => [s.voiceBarCircle, { backgroundColor: accentLight }, pressed && s.pressed],
+                  accessibilityLabel: "Cancel recording",
+                  children: /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.X, { size: 20, color: accent, strokeWidth: 2.5 })
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: s.voiceBarCenter, children: [
+                /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: s.voiceDots, children: Array.from({ length: VOICE_DOT_COUNT }).map((_, i) => /* @__PURE__ */ jsxRuntime.jsx(VoiceWaveformBar, { index: i, isActive: isSpeaking, accent }, i)) }),
+                /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [s.voiceTimer, { color: accent }], children: formatDuration(recordingSeconds) })
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                reactNative.Pressable,
+                {
+                  onPress: onConfirmRecording,
+                  style: ({ pressed }) => [s.voiceBarCircle, s.voiceConfirm, { borderColor: accent }, pressed && s.pressed],
+                  accessibilityLabel: "Send recording",
+                  children: /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.Check, { size: 22, color: accent, strokeWidth: 2.5 })
+                }
+              )
+            ] })
+          }
+        )
+      ] }),
+      !showVoiceBar && /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: s.actionsRow, children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: s.rightActions, children: [
+        showVoiceBtn && /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Pressable,
+          {
+            onPress: onVoicePress,
+            disabled: voiceDisabled,
+            style: [s.iconBtn, voiceDisabled && s.btnDisabled],
+            accessibilityLabel: "Voice input",
+            children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: s.iconBtnInner, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.Mic, { size: 16, color: "#6B7280", strokeWidth: 2 }) })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Pressable,
+          {
+            onPress: onSend,
+            disabled: !canSend,
+            style: [s.sendBtn, !canSend && s.btnDisabled],
+            children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [s.sendBtnInner, { backgroundColor: accent }], children: /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.Send, { size: 14, color: "#FFFFFF" }) })
+          }
+        )
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: s.disclaimerWrap, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: s.disclaimerText, children: AI_DISCLAIMER }) })
+  ] });
+}
+var RESPONSE_SPEED = {
+  normal: [2, 4],
+  fast: 1,
+  punctuation: [8, 12],
+  newline: [4, 6],
+  idle: 15
+};
+function charDelay(char, speed, multiplier) {
+  const raw = (() => {
+    if (char === "*") return speed.fast;
+    if (char === "\n") return speed.newline[0] + Math.random() * speed.newline[1];
+    if (".!?,;:".includes(char)) return speed.punctuation[0] + Math.random() * speed.punctuation[1];
+    return speed.normal[0] + Math.random() * speed.normal[1];
+  })();
+  return raw / multiplier;
+}
+var TYPE_CHUNK = 2;
+function blockJumpLength(remaining, isStreaming) {
+  if (remaining.startsWith("```")) {
+    const closeIdx = remaining.indexOf("\n```", 3);
+    if (closeIdx === -1) return 0;
+    const afterFence = remaining.indexOf("\n", closeIdx + 1);
+    return afterFence === -1 ? remaining.length : afterFence + 1;
+  }
+  const lines = remaining.split("\n");
+  if (!/^\s*\|/.test(lines[0])) return 0;
+  let consumed = 0;
+  let tableLines = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^\s*\|/.test(lines[i])) {
+      tableLines++;
+      consumed += lines[i].length + 1;
+    } else {
+      break;
+    }
+  }
+  if (tableLines < 2) return 0;
+  if (consumed >= remaining.length && isStreaming) return 0;
+  return Math.min(consumed, remaining.length);
+}
+function useTypingEffect(targetText, enabled, isStreaming, speedMultiplier = 6) {
+  const instant = speedMultiplier === 0;
+  const multiplier = instant ? 1 : Math.max(speedMultiplier, 0.1);
+  const [displayedText, setDisplayedText] = react.useState("");
+  const displayedRef = react.useRef("");
+  const targetRef = react.useRef(targetText);
+  const enabledRef = react.useRef(enabled);
+  const streamingRef = react.useRef(isStreaming);
+  const timerRef = react.useRef(null);
+  const runningRef = react.useRef(false);
+  targetRef.current = targetText;
+  enabledRef.current = enabled;
+  streamingRef.current = isStreaming;
+  react.useEffect(() => {
+    if (!enabled || instant) {
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+      runningRef.current = false;
+      displayedRef.current = targetText;
+      setDisplayedText(targetText);
+      return;
+    }
+    if (displayedRef.current && !targetRef.current.startsWith(displayedRef.current)) {
+      displayedRef.current = targetRef.current;
+      setDisplayedText(targetRef.current);
+    }
+    if (runningRef.current) return;
+    runningRef.current = true;
+    const tick = () => {
+      if (!enabledRef.current) {
+        runningRef.current = false;
+        return;
+      }
+      if (displayedRef.current && !targetRef.current.startsWith(displayedRef.current)) {
+        displayedRef.current = targetRef.current;
+        setDisplayedText(targetRef.current);
+        timerRef.current = setTimeout(tick, RESPONSE_SPEED.idle / multiplier);
+        return;
+      }
+      if (displayedRef.current.length < targetRef.current.length) {
+        const remaining = targetRef.current.slice(displayedRef.current.length);
+        const atLineStart = displayedRef.current.length === 0 || targetRef.current[displayedRef.current.length - 1] === "\n";
+        if (atLineStart) {
+          const jump = blockJumpLength(remaining, streamingRef.current);
+          if (jump > 0) {
+            displayedRef.current += remaining.slice(0, jump);
+            setDisplayedText(displayedRef.current);
+            timerRef.current = setTimeout(tick, 0);
+            return;
+          }
+          if (streamingRef.current && /^(```|\s*\|)/.test(remaining)) {
+            timerRef.current = setTimeout(tick, RESPONSE_SPEED.idle / multiplier);
+            return;
+          }
+        }
+        let chunk = remaining.slice(0, TYPE_CHUNK);
+        const nl = chunk.indexOf("\n");
+        if (nl !== -1) chunk = chunk.slice(0, nl + 1);
+        displayedRef.current += chunk;
+        setDisplayedText(displayedRef.current);
+        const lastChar = chunk[chunk.length - 1];
+        timerRef.current = setTimeout(tick, charDelay(lastChar, RESPONSE_SPEED, multiplier));
+      } else {
+        timerRef.current = setTimeout(tick, RESPONSE_SPEED.idle / multiplier);
+      }
+    };
+    tick();
+    return () => {
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+      runningRef.current = false;
+    };
+  }, [enabled, instant]);
+  const isTyping = enabled && !instant && displayedRef.current.length < targetRef.current.length;
+  return { displayedText: enabled || instant ? displayedText : targetText, isTyping };
+}
+var PENDING_LABEL = "Thinking";
+var SHIMMER_DURATION = 2800;
+var SHIMMER_BAND = 0.55;
+var SHIMMER_LIGHT = { dim: "#b4b4b4", bright: "#1f2937" };
+var SHIMMER_DARK = { dim: "#5b6b6e", bright: "#eaf2f3" };
+function ShimmerChar({
+  ch,
+  pos,
+  progress,
+  dim,
+  bright
+}) {
+  const center = (pos + 0.4) / 1.8;
+  const half = SHIMMER_BAND / 1.8;
+  const color = progress.interpolate({
+    inputRange: [center - half, center, center + half],
+    outputRange: [dim, bright, dim],
+    extrapolate: "clamp"
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Animated.Text, { style: [ts.cursorLabel, { color }], children: ch });
+}
+function ShimmerText({ text, isDark }) {
+  const progress = react.useRef(new reactNative.Animated.Value(0)).current;
+  const { dim, bright } = isDark ? SHIMMER_DARK : SHIMMER_LIGHT;
+  react.useEffect(() => {
+    const loop = reactNative.Animated.loop(
+      reactNative.Animated.timing(progress, {
+        toValue: 1,
+        duration: SHIMMER_DURATION,
+        easing: reactNative.Easing.inOut(reactNative.Easing.ease),
+        // color interpolation isn't supported by the native driver
+        useNativeDriver: false
+      })
+    );
+    loop.start();
+    return () => loop.stop();
+  }, [progress]);
+  const chars = Array.from(text);
+  const n = Math.max(chars.length - 1, 1);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [ts.cursorLabel, { color: dim }], children: chars.map((ch, i) => /* @__PURE__ */ jsxRuntime.jsx(ShimmerChar, { ch, pos: i / n, progress, dim, bright }, i)) });
+}
+function FlipLabel({ label, isDark }) {
+  const opacity = react.useRef(new reactNative.Animated.Value(0)).current;
+  const translateY = react.useRef(new reactNative.Animated.Value(6)).current;
+  react.useEffect(() => {
+    opacity.setValue(0);
+    translateY.setValue(6);
+    reactNative.Animated.parallel([
+      reactNative.Animated.timing(opacity, { toValue: 1, duration: 300, easing: reactNative.Easing.out(reactNative.Easing.ease), useNativeDriver: true }),
+      reactNative.Animated.timing(translateY, { toValue: 0, duration: 320, easing: reactNative.Easing.out(reactNative.Easing.ease), useNativeDriver: true })
+    ]).start();
+  }, [label, opacity, translateY]);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Animated.View, { style: { opacity, transform: [{ translateY }] }, children: /* @__PURE__ */ jsxRuntime.jsx(ShimmerText, { text: label, isDark }) });
+}
+function StickyLabel({ label, isDark }) {
+  const opacity = react.useRef(new reactNative.Animated.Value(0)).current;
+  const translateY = react.useRef(new reactNative.Animated.Value(4)).current;
+  react.useEffect(() => {
+    reactNative.Animated.parallel([
+      reactNative.Animated.timing(opacity, { toValue: 1, duration: 400, easing: reactNative.Easing.out(reactNative.Easing.ease), useNativeDriver: true }),
+      reactNative.Animated.timing(translateY, { toValue: 0, duration: 400, easing: reactNative.Easing.out(reactNative.Easing.ease), useNativeDriver: true })
+    ]).start();
+  }, [opacity, translateY]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Animated.Text,
+    {
+      style: [
+        ts.stickyLabel,
+        { color: isDark ? "rgba(255,255,255,0.62)" : "#4b5563", opacity, transform: [{ translateY }] }
+      ],
+      children: label
+    }
+  );
+}
+function ThinkingBlock({
+  stickyLabel,
+  currentStepLabel,
+  isDark
+}) {
+  const label = currentStepLabel || PENDING_LABEL;
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: ts.container, children: [
+    stickyLabel ? /* @__PURE__ */ jsxRuntime.jsx(StickyLabel, { label: stickyLabel, isDark }, stickyLabel) : null,
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: ts.cursorRow, children: /* @__PURE__ */ jsxRuntime.jsx(FlipLabel, { label, isDark }, label) })
+  ] });
+}
+function deriveStickyLabel(steps) {
+  if (!steps || steps.length === 0) return void 0;
+  for (let i = steps.length - 1; i >= 0; i--) {
+    const s2 = steps[i];
+    if (s2.eventType === "STAGE_STARTED" && s2.stage === "analyzer" && s2.status === "completed" && s2.message) {
+      return s2.message;
+    }
+  }
+  return void 0;
+}
+function deriveCurrentStepLabel(steps, stickyLabel) {
+  if (!steps || steps.length === 0) return void 0;
+  for (let i = steps.length - 1; i >= 0; i--) {
+    const s2 = steps[i];
+    if (s2.status === "in_progress" && s2.message) {
+      if (s2.stage === "analyzer" && s2.message === stickyLabel) continue;
+      if (s2.message === stickyLabel) continue;
+      return s2.message;
+    }
+  }
+  for (let i = steps.length - 1; i >= 0; i--) {
+    const s2 = steps[i];
+    if (s2.message && s2.message !== stickyLabel) return s2.message;
+  }
+  return void 0;
+}
+var ts = reactNative.StyleSheet.create({
+  container: { paddingVertical: 2 },
+  stickyLabel: {
+    fontSize: 14,
+    lineHeight: 21,
+    color: "#4b5563",
+    marginBottom: 6
+  },
+  cursorRow: { overflow: "hidden" },
+  cursorLabel: {
+    fontSize: 14,
+    lineHeight: 21,
+    fontWeight: "500"
+  }
+});
+function UserBubble({ message, accent }) {
+  const text = message.content ?? "";
+  if (!text) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [sd.bubbleRow, sd.rowUser], children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [sd.bubble, sd.bubbleUser, { backgroundColor: accent }], children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [sd.bubbleText, sd.textUser], children: text }) }) });
+}
+function stripIncompleteImageToken(text) {
+  const lastBang = text.lastIndexOf("![");
+  if (lastBang === -1) return text;
+  const after = text.slice(lastBang);
+  if (/^!\[[^\]]*\]\([^)]*\)/.test(after)) return text;
+  return text.slice(0, lastBang);
+}
+function stripDuplicatePromptText(text, promptText) {
+  if (!promptText) return text;
+  const pm = promptText.replace(/\\n/g, "\n").trim();
+  if (!pm) return text;
+  const idx = text.indexOf(pm);
+  if (idx !== -1) {
+    return (text.slice(0, idx) + text.slice(idx + pm.length)).trim();
+  }
+  for (let cut = Math.min(text.length, pm.length); cut >= 24; cut--) {
+    if (text.endsWith(pm.slice(0, cut))) {
+      return text.slice(0, text.length - cut).trim();
+    }
+  }
+  return text;
+}
+function AssistantBubble({
+  message,
+  shouldType,
+  isDark,
+  accent,
+  suppressText
+}) {
+  const isCurrentlyStreaming = !!message.isStreaming && !message.isCancelled;
+  const mdStyles = isDark ? MD_STYLES_DARK : MD_STYLES_LIGHT;
+  const mdRules = react.useMemo(() => makeMdRules(isDark, accent), [isDark, accent]);
+  const bubbleBg = isDark ? "rgba(255,255,255,0.07)" : "#f3f4f6";
+  const errorBg = isDark ? "rgba(220,38,38,0.14)" : "#fef2f2";
+  const rawResponseContent = (() => {
+    const raw = message.isStreaming ? message.streamingContent || message.content : message.content;
+    if (!raw) return "";
+    const normalized = raw.replace(/\\n/g, "\n");
+    const cleaned = message.isStreaming ? stripIncompleteImageToken(normalized) : normalized;
+    return stripDuplicatePromptText(cleaned, suppressText);
+  })();
+  const isThinkingStreaming = isCurrentlyStreaming && !rawResponseContent && !message.isError;
+  const hasEverStreamed = react.useRef(!!message.isStreaming);
+  if (message.isStreaming) hasEverStreamed.current = true;
+  const typingEnabled = shouldType && hasEverStreamed.current && Boolean(rawResponseContent) && !message.isError;
+  const { displayedText, isTyping } = useTypingEffect(
+    rawResponseContent,
+    typingEnabled,
+    isCurrentlyStreaming,
+    3
+  );
+  const stickyLabel = deriveStickyLabel(message.steps);
+  const currentStepLabel = deriveCurrentStepLabel(message.steps, stickyLabel);
+  if (message.isError && !rawResponseContent && !displayedText) {
+    const detail = message.errorDetails || "Something went wrong. Please try again.";
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [sd.bubbleRow, sd.rowAssistant], children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [sd.bubble, sd.bubbleAssistant, { backgroundColor: errorBg }], children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: sd.errorText, children: detail }) }) });
+  }
+  if (isThinkingStreaming) {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [sd.bubbleRow, sd.rowAssistant], children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [sd.bubble, sd.bubbleAssistant, { backgroundColor: bubbleBg }], children: /* @__PURE__ */ jsxRuntime.jsx(ThinkingBlock, { stickyLabel, currentStepLabel, isDark }) }) });
+  }
+  const showCursor = (isCurrentlyStreaming || isTyping) && !message.isCancelled;
+  const markdownContent = showCursor ? displayedText + "\u258B" : displayedText;
+  if (!markdownContent) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [sd.bubbleRow, sd.rowAssistant], children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [sd.bubble, sd.bubbleAssistant, sd.bubbleAssistantWide, { backgroundColor: bubbleBg }], children: [
+    /* @__PURE__ */ jsxRuntime.jsx(Markdown__default.default, { style: mdStyles, rules: mdRules, children: markdownContent }),
+    message.isCancelled && /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: sd.cancelledText, children: "Response stopped" }),
+    message.isError && displayedText && /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: sd.partialErrorText, children: message.errorDetails || "The response was interrupted." })
+  ] }) });
+}
+function MessageBubble({ message, accent, shouldType, isDark, suppressText }) {
+  if (message.role === "user") return /* @__PURE__ */ jsxRuntime.jsx(UserBubble, { message, accent });
+  return /* @__PURE__ */ jsxRuntime.jsx(AssistantBubble, { message, shouldType, isDark, accent, suppressText });
+}
+var RESEND_COOLDOWN_S = 30;
+var DEFAULT_CODE_LEN = 6;
+function uaPalette(isDark) {
+  return isDark ? {
+    sheetBg: "#13201f",
+    text: "rgba(255,255,255,0.95)",
+    muted: "rgba(255,255,255,0.55)",
+    border: "rgba(255,255,255,0.10)",
+    fieldBg: "rgba(255,255,255,0.06)",
+    fieldBorder: "rgba(255,255,255,0.18)",
+    overlay: "rgba(0,0,0,0.62)",
+    grabber: "rgba(255,255,255,0.22)"
+  } : {
+    sheetBg: "#ffffff",
+    text: "#111827",
+    muted: "#6b7280",
+    border: "#eceef1",
+    fieldBg: "#f9fafb",
+    fieldBorder: "#d1d5db",
+    overlay: "rgba(15,23,42,0.45)",
+    grabber: "rgba(15,23,42,0.18)"
+  };
+}
+function promptInitialSeconds(prompt) {
+  return prompt && typeof prompt.expirySeconds === "number" && prompt.expirySeconds > 0 ? Math.floor(prompt.expirySeconds) : void 0;
+}
+function promptTimerKey(prompt) {
+  return prompt ? `${prompt.userActionId}|${prompt.subAction ?? ""}` : "";
+}
+function useExpiredFlag(prompt) {
+  const initial = promptInitialSeconds(prompt);
+  const key = promptTimerKey(prompt);
+  const [expired, setExpired] = react.useState(false);
+  react.useEffect(() => {
+    setExpired(false);
+    if (initial === void 0) return;
+    const t = setTimeout(() => setExpired(true), initial * 1e3);
+    return () => clearTimeout(t);
+  }, [key, initial]);
+  return expired;
+}
+function useSecondsLeft(expirySeconds, restartKey) {
+  const initial = typeof expirySeconds === "number" && expirySeconds > 0 ? Math.floor(expirySeconds) : void 0;
+  const [left, setLeft] = react.useState(initial);
+  react.useEffect(() => {
+    setLeft(initial);
+    if (initial === void 0) return;
+    const id = setInterval(() => {
+      setLeft((s2) => s2 === void 0 ? s2 : s2 <= 1 ? 0 : s2 - 1);
+    }, 1e3);
+    return () => clearInterval(id);
+  }, [restartKey, initial]);
+  return left;
+}
+function SheetTimerPill({
+  prompt,
+  accent,
+  isDark
+}) {
+  const left = useSecondsLeft(prompt.expirySeconds, promptTimerKey(prompt));
+  if (left === void 0 || prompt.status === "stale") return null;
+  const expired = left <= 0;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.View,
+    {
+      style: [
+        sht.timer,
+        {
+          borderColor: expired ? "#ef4444" : accent + "40",
+          backgroundColor: expired ? "rgba(239,68,68,0.10)" : accent + (isDark ? "1F" : "12")
+        }
+      ],
+      children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: { color: expired ? "#ef4444" : accent, fontSize: 12.5, fontWeight: "700", letterSpacing: 0.2 }, children: expired ? "Expired" : `${left}s` })
+    }
+  );
+}
+function CardTimerPill({
+  prompt,
+  accent,
+  isDark
+}) {
+  const left = useSecondsLeft(prompt.expirySeconds, promptTimerKey(prompt));
+  if (left === void 0 || left <= 0) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [rc.timer, { backgroundColor: accent + (isDark ? "26" : "14") }], children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Text, { style: { color: accent, fontSize: 12, fontWeight: "700" }, children: [
+    left,
+    "s"
+  ] }) });
+}
+function CodeInput({
+  value,
+  onChange,
+  length,
+  disabled,
+  error,
+  accent,
+  pal
+}) {
+  const ref = react.useRef(null);
+  react.useEffect(() => {
+    const t = setTimeout(() => ref.current?.focus(), 380);
+    return () => clearTimeout(t);
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Pressable, { onPress: () => ref.current?.focus(), style: ub.codeRow, children: [
+    Array.from({ length }).map((_, i) => {
+      const ch = value[i] ?? "";
+      const isCursor = i === value.length && !disabled;
+      const bc = error ? "#ef4444" : isCursor ? accent : pal.fieldBorder;
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [ub.codeBox, { borderColor: bc, backgroundColor: pal.fieldBg }], children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [ub.codeChar, { color: pal.text }], children: ch }) }, i);
+    }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.TextInput,
+      {
+        ref,
+        value,
+        onChangeText: (t) => onChange(t.replace(/[^0-9]/g, "").slice(0, length)),
+        keyboardType: "number-pad",
+        maxLength: length,
+        editable: !disabled,
+        caretHidden: true,
+        style: ub.codeHidden
+      }
+    )
+  ] });
+}
+function PrimaryButton({
+  label,
+  onPress,
+  disabled,
+  accent
+}) {
+  const bg = accent || DEFAULT_ACCENT;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Pressable,
+    {
+      onPress,
+      disabled,
+      android_ripple: { color: "rgba(255,255,255,0.22)" },
+      style: [ub.primaryBtn, { backgroundColor: bg, borderColor: bg, opacity: disabled ? 0.5 : 1 }],
+      children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: ub.primaryBtnText, children: label })
+    }
+  );
+}
+function VerificationBody({
+  prompt,
+  expired,
+  pal,
+  accent,
+  onSubmit,
+  onCancel,
+  onResend
+}) {
+  const isNumeric = prompt.verificationType !== "ALPHANUMERIC_CODE";
+  const field = prompt.requestedSchema?.properties?.verificationCode;
+  const codeLen = (typeof field?.maxLength === "number" ? field.maxLength : void 0) ?? (typeof field?.minLength === "number" ? field.minLength : void 0) ?? DEFAULT_CODE_LEN;
+  const [code, setCode] = react.useState("");
+  const [errored, setErrored] = react.useState(false);
+  const [resendSec, setResendSec] = react.useState(0);
+  const lastSubmitted = react.useRef(null);
+  const resendTimer = react.useRef(null);
+  const busy = prompt.status === "submitting";
+  const stale = prompt.status === "stale";
+  const locked = busy || stale || expired;
+  react.useEffect(() => {
+    if (prompt.subAction === "SubmissionInvalid") {
+      setErrored(true);
+      setCode("");
+      lastSubmitted.current = null;
+    }
+  }, [prompt.subAction, prompt.userActionId]);
+  const doSubmit = react.useCallback(
+    (value) => {
+      if (locked || !value) return;
+      if (lastSubmitted.current === value) return;
+      lastSubmitted.current = value;
+      void onSubmit(prompt.userActionId, { verificationCode: value }).catch(() => {
+        lastSubmitted.current = null;
+        setErrored(true);
+      });
+    },
+    [locked, onSubmit, prompt.userActionId]
+  );
+  react.useEffect(() => {
+    if (!isNumeric || locked) return;
+    if (code.length === codeLen && /^\d+$/.test(code)) doSubmit(code);
+  }, [code, codeLen, doSubmit, isNumeric, locked]);
+  react.useEffect(() => () => {
+    if (resendTimer.current) clearInterval(resendTimer.current);
+  }, []);
+  const handleResend = react.useCallback(async () => {
+    if (locked || resendSec > 0) return;
+    setErrored(false);
+    setCode("");
+    lastSubmitted.current = null;
+    try {
+      await onResend(prompt.userActionId);
+      setResendSec(RESEND_COOLDOWN_S);
+      if (resendTimer.current) clearInterval(resendTimer.current);
+      resendTimer.current = setInterval(() => {
+        setResendSec((s2) => {
+          if (s2 <= 1) {
+            if (resendTimer.current) clearInterval(resendTimer.current);
+            return 0;
+          }
+          return s2 - 1;
+        });
+      }, 1e3);
+    } catch {
+    }
+  }, [locked, onResend, prompt.userActionId, resendSec]);
+  const description = prompt.message?.trim() || (isNumeric ? `Enter the ${codeLen}-digit code to continue` : "Enter the verification code to continue");
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: ub.bodyWrap, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      reactNative.ScrollView,
+      {
+        style: ub.fieldsScroll,
+        contentContainerStyle: ub.fieldsContent,
+        keyboardShouldPersistTaps: "handled",
+        showsVerticalScrollIndicator: false,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [ub.desc, { color: pal.muted }], children: description }),
+          isNumeric ? /* @__PURE__ */ jsxRuntime.jsx(
+            CodeInput,
+            {
+              value: code,
+              onChange: (v) => {
+                setErrored(false);
+                setCode(v);
+              },
+              length: codeLen,
+              disabled: locked,
+              error: errored,
+              accent,
+              pal
+            }
+          ) : /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.TextInput,
+            {
+              value: code,
+              onChangeText: (t) => {
+                setErrored(false);
+                setCode(t);
+              },
+              editable: !locked,
+              placeholder: "Verification code",
+              placeholderTextColor: pal.muted,
+              autoComplete: "one-time-code",
+              style: [
+                ub.input,
+                { color: pal.text, backgroundColor: pal.fieldBg, borderColor: errored ? "#ef4444" : pal.fieldBorder }
+              ]
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: ub.actions, children: [
+      !isNumeric && /* @__PURE__ */ jsxRuntime.jsx(
+        PrimaryButton,
+        {
+          label: busy ? "Verifying\u2026" : "Verify",
+          onPress: () => doSubmit(code.trim()),
+          disabled: locked || !code.trim(),
+          accent
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: ub.linkRow, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { disabled: locked || resendSec > 0, onPress: () => void handleResend(), children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [ub.link, { color: accent, opacity: locked || resendSec > 0 ? 0.4 : 1 }], children: resendSec > 0 ? `Resend (${resendSec}s)` : "Resend" }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { disabled: busy, onPress: () => void onCancel(prompt.userActionId), children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [ub.link, ub.linkDanger, { opacity: busy ? 0.4 : 1 }], children: "Cancel" }) })
+      ] })
+    ] })
+  ] });
+}
+function FormBody({
+  prompt,
+  pal,
+  accent,
+  isDark,
+  onSubmit,
+  onCancel
+}) {
+  const schema = prompt.requestedSchema;
+  const fields = react.useMemo(() => renderableFields(schema), [schema]);
+  const [values, setValues] = react.useState(() => {
+    const init = {};
+    for (const [key, field] of fields) init[key] = defaultValueFor(field);
+    return init;
+  });
+  const [errors, setErrors] = react.useState({});
+  const busy = prompt.status === "submitting";
+  const stale = prompt.status === "stale";
+  const locked = busy || stale;
+  const isConfirm = prompt.subAction === "UserConfirmation";
+  const setValue = (key, v) => {
+    setValues((prev) => ({ ...prev, [key]: v }));
+    setErrors((prev) => {
+      if (!prev[key]) return prev;
+      const next = { ...prev };
+      delete next[key];
+      return next;
+    });
+  };
+  const handleSubmit = () => {
+    if (locked) return;
+    const validation = validateForm(schema, values);
+    if (Object.keys(validation).length > 0) {
+      setErrors(validation);
+      return;
+    }
+    void onSubmit(prompt.userActionId, buildContent(schema, values)).catch(() => {
+    });
+  };
+  const mdStyles = isDark ? MD_STYLES_DARK : MD_STYLES_LIGHT;
+  const mdRules = react.useMemo(() => makeMdRules(isDark, accent), [isDark, accent]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: ub.bodyWrap, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      reactNative.ScrollView,
+      {
+        style: ub.fieldsScroll,
+        contentContainerStyle: ub.fieldsContent,
+        keyboardShouldPersistTaps: "handled",
+        showsVerticalScrollIndicator: true,
+        children: [
+          prompt.message?.trim() ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: ub.messageBlock, children: /* @__PURE__ */ jsxRuntime.jsx(Markdown__default.default, { style: mdStyles, rules: mdRules, children: prompt.message.replace(/\\n/g, "\n") }) }) : null,
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: ub.form, children: fields.map(([key, field]) => {
+            const widget = classifyField(field);
+            const label = field.title || key;
+            const required = isRequired(schema, key);
+            const err = errors[key];
+            if (widget === "boolean") {
+              return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: ub.switchRow, children: [
+                /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Text, { style: [ub.label, { color: pal.text, flex: 1 }], children: [
+                  label,
+                  required ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: { color: "#ef4444" }, children: " *" }) : null
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  reactNative.Switch,
+                  {
+                    value: Boolean(values[key]),
+                    disabled: locked,
+                    onValueChange: (v) => setValue(key, v),
+                    trackColor: { true: accent }
+                  }
+                )
+              ] }, key);
+            }
+            return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: ub.field, children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Text, { style: [ub.label, { color: pal.text }], children: [
+                label,
+                required ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: { color: "#ef4444" }, children: " *" }) : null
+              ] }),
+              field.description ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [ub.hint, { color: pal.muted }], children: field.description }) : null,
+              widget === "select" ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: ub.optionList, children: getOptions(field).map((opt) => {
+                const selected = String(values[key] ?? "") === opt.const;
+                return /* @__PURE__ */ jsxRuntime.jsxs(
+                  reactNative.Pressable,
+                  {
+                    disabled: locked,
+                    onPress: () => setValue(key, opt.const),
+                    android_ripple: { color: accent + "22" },
+                    style: [
+                      ub.optionRow,
+                      {
+                        borderColor: selected ? accent : pal.fieldBorder,
+                        backgroundColor: selected ? accent + (isDark ? "26" : "14") : pal.fieldBg
+                      }
+                    ],
+                    children: [
+                      /* @__PURE__ */ jsxRuntime.jsx(
+                        reactNative.View,
+                        {
+                          style: [
+                            ub.radio,
+                            { borderColor: selected ? accent : pal.fieldBorder }
+                          ],
+                          children: selected ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [ub.radioDot, { backgroundColor: accent }] }) : null
+                        }
+                      ),
+                      /* @__PURE__ */ jsxRuntime.jsx(
+                        reactNative.Text,
+                        {
+                          style: [
+                            ub.optionLabel,
+                            { color: pal.text, fontWeight: selected ? "600" : "500" }
+                          ],
+                          children: opt.title || opt.const
+                        }
+                      )
+                    ]
+                  },
+                  opt.const
+                );
+              }) }) : /* @__PURE__ */ jsxRuntime.jsx(
+                reactNative.TextInput,
+                {
+                  value: String(values[key] ?? ""),
+                  editable: !locked,
+                  onChangeText: (t) => setValue(key, t),
+                  placeholder: field.description ? void 0 : label,
+                  placeholderTextColor: pal.muted,
+                  keyboardType: widget === "integer" ? "number-pad" : widget === "decimal" ? "decimal-pad" : "default",
+                  style: [
+                    ub.input,
+                    { color: pal.text, backgroundColor: pal.fieldBg, borderColor: err ? "#ef4444" : pal.fieldBorder }
+                  ]
+                }
+              ),
+              err ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: ub.error, children: err }) : null
+            ] }, key);
+          }) })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: ub.actions, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        PrimaryButton,
+        {
+          label: busy ? "Submitting\u2026" : isConfirm ? "Confirm" : "Next",
+          onPress: handleSubmit,
+          disabled: locked,
+          accent
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: ub.linkRow, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { disabled: busy, onPress: () => void onCancel(prompt.userActionId), children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [ub.link, ub.linkDanger, { opacity: busy ? 0.4 : 1 }], children: "Cancel" }) }) })
+    ] })
+  ] });
+}
+function UserActionSheet({
+  open,
+  active,
+  expired,
+  isDark,
+  accent,
+  insetBottom,
+  onSubmit,
+  onCancel,
+  onResend,
+  onMinimize
+}) {
+  const pal = uaPalette(isDark);
+  const screenH = reactNative.Dimensions.get("window").height;
+  const [shown, setShown] = react.useState(active);
+  react.useEffect(() => {
+    if (active) setShown(active);
+  }, [active]);
+  const translateY = react.useRef(new reactNative.Animated.Value(screenH)).current;
+  const backdrop = react.useRef(new reactNative.Animated.Value(0)).current;
+  const minimizeRef = react.useRef(onMinimize);
+  react.useEffect(() => {
+    minimizeRef.current = onMinimize;
+  });
+  const [mounted, setMounted] = react.useState(open);
+  const [kbHeight, setKbHeight] = react.useState(0);
+  react.useEffect(() => {
+    const showEvt = reactNative.Platform.OS === "ios" ? "keyboardWillShow" : "keyboardDidShow";
+    const hideEvt = reactNative.Platform.OS === "ios" ? "keyboardWillHide" : "keyboardDidHide";
+    const s1 = reactNative.Keyboard.addListener(showEvt, (e) => setKbHeight(e?.endCoordinates?.height ?? 0));
+    const s2 = reactNative.Keyboard.addListener(hideEvt, () => setKbHeight(0));
+    return () => {
+      s1.remove();
+      s2.remove();
+    };
+  }, []);
+  react.useEffect(() => {
+    if (open) {
+      setMounted(true);
+      translateY.setValue(screenH);
+      backdrop.setValue(0);
+      const id = requestAnimationFrame(() => {
+        reactNative.Animated.parallel([
+          reactNative.Animated.spring(translateY, { toValue: 0, useNativeDriver: true, damping: 30, stiffness: 360, mass: 0.85 }),
+          reactNative.Animated.timing(backdrop, { toValue: 1, duration: 190, useNativeDriver: true })
+        ]).start();
+      });
+      return () => cancelAnimationFrame(id);
+    }
+    reactNative.Animated.parallel([
+      reactNative.Animated.timing(translateY, { toValue: screenH, duration: 230, easing: reactNative.Easing.in(reactNative.Easing.cubic), useNativeDriver: true }),
+      reactNative.Animated.timing(backdrop, { toValue: 0, duration: 180, useNativeDriver: true })
+    ]).start(({ finished }) => {
+      if (finished) setMounted(false);
+    });
+    return void 0;
+  }, [open, translateY, backdrop, screenH]);
+  const pan = react.useRef(
+    reactNative.PanResponder.create({
+      onMoveShouldSetPanResponder: (_evt, g) => g.dy > 6 && Math.abs(g.dy) > Math.abs(g.dx) * 1.4,
+      onPanResponderMove: (_evt, g) => {
+        if (g.dy > 0) translateY.setValue(g.dy);
+      },
+      onPanResponderRelease: (_evt, g) => {
+        if (g.dy > 110 || g.vy > 0.8) {
+          minimizeRef.current();
+        } else {
+          reactNative.Animated.spring(translateY, { toValue: 0, useNativeDriver: true, damping: 30, stiffness: 360 }).start();
+        }
+      }
+    })
+  ).current;
+  const a = active ?? shown;
+  if (!mounted || !a) return null;
+  const isVerification = a.kind === "verification";
+  const title = isVerification ? "Verification required" : "Action required";
+  const subtitle = isVerification ? "Confirm the one-time code to continue" : "Review the details and confirm to continue";
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Modal,
+    {
+      visible: mounted,
+      transparent: true,
+      animationType: "none",
+      statusBarTranslucent: true,
+      onRequestClose: () => minimizeRef.current(),
+      children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: reactNative.StyleSheet.absoluteFill, pointerEvents: open ? "auto" : "none", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Animated.View,
+          {
+            pointerEvents: "none",
+            style: [sht.backdrop, { backgroundColor: pal.overlay, opacity: backdrop }]
+          }
+        ),
+        open ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { style: reactNative.StyleSheet.absoluteFill, onPress: () => minimizeRef.current(), accessibilityLabel: "Dismiss" }) : null,
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [sht.kav, { paddingBottom: kbHeight }], pointerEvents: "box-none", children: /* @__PURE__ */ jsxRuntime.jsxs(
+          reactNative.Animated.View,
+          {
+            style: [
+              sht.sheet,
+              {
+                backgroundColor: pal.sheetBg,
+                borderColor: pal.border,
+                // Cap to the space above the keyboard (and a top margin) so the
+                // header stays visible and the footer sits above the keyboard;
+                // the field area scrolls within whatever's left.
+                maxHeight: Math.min(screenH * 0.9, screenH - kbHeight - 72),
+                paddingBottom: kbHeight > 0 ? 16 : Math.max(insetBottom, 16) + 6,
+                transform: [{ translateY }]
+              }
+            ],
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { ...pan.panHandlers, style: sht.handleZone, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [sht.grabber, { backgroundColor: pal.grabber }] }) }),
+              /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: sht.header, children: [
+                /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [sht.iconCircle, { backgroundColor: accent + (isDark ? "26" : "14") }], children: isVerification ? /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.ShieldCheck, { size: 19, color: accent, strokeWidth: 2.1 }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.Pencil, { size: 17, color: accent, strokeWidth: 2.1 }) }),
+                /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: sht.headerText, children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [sht.title, { color: pal.text }], numberOfLines: 1, children: title }),
+                  /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [sht.subtitle, { color: pal.muted }], numberOfLines: 1, children: subtitle })
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsx(SheetTimerPill, { prompt: a, accent, isDark }),
+                /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { onPress: () => minimizeRef.current(), hitSlop: 10, style: [sht.closeBtn, { backgroundColor: pal.fieldBg }], children: /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.X, { size: 15, color: pal.muted, strokeWidth: 2.3 }) })
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [sht.headerRule, { backgroundColor: pal.border }] }),
+              a.status === "stale" ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: sht.simpleBody, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [ub.desc, { color: pal.muted }], children: "This request is no longer available." }) }) : expired ? /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: sht.simpleBody, children: [
+                /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [ub.desc, { color: pal.muted }], children: isVerification ? "This verification request expired." : "This request expired." }),
+                /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: ub.actions, children: /* @__PURE__ */ jsxRuntime.jsx(PrimaryButton, { label: "Close", onPress: () => void onCancel(a.userActionId), accent }) })
+              ] }) : isVerification ? /* @__PURE__ */ jsxRuntime.jsx(
+                VerificationBody,
+                {
+                  prompt: a,
+                  expired,
+                  pal,
+                  accent,
+                  onSubmit,
+                  onCancel,
+                  onResend
+                },
+                a.userActionId
+              ) : /* @__PURE__ */ jsxRuntime.jsx(FormBody, { prompt: a, pal, accent, isDark, onSubmit, onCancel }, a.userActionId)
+            ]
+          }
+        ) })
+      ] })
+    }
+  );
+}
+function UserActionReopenCard({
+  active,
+  expired,
+  isDark,
+  accent,
+  onReopen
+}) {
+  if (expired || active.status === "stale") return null;
+  const pal = uaPalette(isDark);
+  const isVerification = active.kind === "verification";
+  const title = isVerification ? "Verification required" : "Action required";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.Pressable,
+    {
+      onPress: onReopen,
+      accessibilityRole: "button",
+      accessibilityLabel: `${title}. Tap to respond.`,
+      android_ripple: { color: accent + "22" },
+      style: [
+        rc.card,
+        {
+          backgroundColor: pal.sheetBg,
+          borderColor: accent + (isDark ? "59" : "40")
+        }
+      ],
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [rc.iconCircle, { backgroundColor: accent + (isDark ? "26" : "14") }], children: isVerification ? /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.ShieldCheck, { size: 18, color: accent, strokeWidth: 2 }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.Pencil, { size: 16, color: accent, strokeWidth: 2 }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: rc.textWrap, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [rc.title, { color: pal.text }], numberOfLines: 1, children: title }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [rc.subtitle, { color: pal.muted }], numberOfLines: 1, children: "Tap to respond and continue" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(CardTimerPill, { prompt: active, accent, isDark }),
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.ChevronRight, { size: 18, color: pal.muted, strokeWidth: 2 })
+      ]
+    }
+  );
+}
+function NotificationStack({
+  notifications,
+  isDark,
+  onDismiss
+}) {
+  if (notifications.length === 0) return null;
+  const pal = uaPalette(isDark);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: ub.noteStack, children: notifications.map((n) => /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [ub.note, { backgroundColor: pal.fieldBg, borderColor: pal.border }], children: [
+    /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.Info, { size: 14, color: pal.muted, strokeWidth: 1.9 }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [ub.noteText, { color: pal.text }], children: n.message }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { onPress: () => onDismiss(n.id), hitSlop: 8, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReactNative.X, { size: 14, color: pal.muted, strokeWidth: 2 }) })
+  ] }, n.id)) });
+}
+var ub = reactNative.StyleSheet.create({
+  // Body wrapper can shrink within the sheet's (bounded) maxHeight so the inner
+  // field scroll takes over for tall forms while the footer stays pinned.
+  bodyWrap: { flexShrink: 1 },
+  // Field scroll region. flexShrink:1 + no flexGrow → hugs content for short
+  // forms (no scroll), shrinks and scrolls only when the form exceeds the sheet.
+  fieldsScroll: { flexShrink: 1 },
+  fieldsContent: { paddingBottom: 6 },
+  messageBlock: { marginBottom: 14, marginTop: 0 },
+  desc: { fontSize: 14, lineHeight: 20, marginBottom: 14 },
+  form: { gap: 14 },
+  field: { gap: 6 },
+  label: { fontSize: 13.5, fontWeight: "600", letterSpacing: -0.1 },
+  hint: { fontSize: 12, lineHeight: 16 },
+  input: {
+    borderWidth: 1,
+    borderRadius: 12,
+    paddingHorizontal: 14,
+    paddingVertical: 12,
+    fontSize: 16
+  },
+  error: { color: "#ef4444", fontSize: 12, marginTop: 2 },
+  switchRow: { flexDirection: "row", alignItems: "center", gap: 12 },
+  // Selectable option "boxes" for oneOf / enum single-select fields.
+  optionList: { gap: 9 },
+  optionRow: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 12,
+    borderWidth: 1.5,
+    borderRadius: 13,
+    paddingHorizontal: 14,
+    paddingVertical: 13
+  },
+  radio: {
+    width: 19,
+    height: 19,
+    borderRadius: 10,
+    borderWidth: 2,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  radioDot: { width: 10, height: 10, borderRadius: 5 },
+  optionLabel: { flex: 1, fontSize: 15, letterSpacing: -0.1 },
+  // Pinned footer (outside the fields scroll) — always visible.
+  actions: { paddingTop: 14, gap: 12 },
+  primaryBtn: { minHeight: 50, borderRadius: 14, borderWidth: 1, paddingVertical: 14, alignItems: "center", justifyContent: "center" },
+  primaryBtnText: { color: "#fff", fontSize: 15.5, fontWeight: "600", letterSpacing: -0.1 },
+  linkRow: { flexDirection: "row", justifyContent: "center", gap: 24, paddingTop: 2 },
+  link: { fontSize: 14, fontWeight: "500" },
+  linkDanger: { color: "#dc2626" },
+  codeRow: { flexDirection: "row", justifyContent: "center", gap: 9, position: "relative" },
+  codeBox: {
+    width: 46,
+    height: 56,
+    borderWidth: 1.5,
+    borderRadius: 12,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  codeChar: { fontSize: 24, fontWeight: "600" },
+  codeHidden: { ...reactNative.StyleSheet.absoluteFillObject, opacity: 0 },
+  noteStack: { paddingHorizontal: 16, paddingBottom: 6, gap: 6 },
+  note: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 8,
+    borderWidth: 1,
+    borderRadius: 12,
+    paddingHorizontal: 12,
+    paddingVertical: 10
+  },
+  noteText: { flex: 1, fontSize: 13.5, lineHeight: 19 }
+});
+var sht = reactNative.StyleSheet.create({
+  // High stacking so the sheet sits above the chat input bar (which carries its
+  // own zIndex/elevation) and everything else in the chat.
+  overlay: { zIndex: 100, ...reactNative.Platform.select({ android: { elevation: 100 }, default: {} }) },
+  backdrop: { ...reactNative.StyleSheet.absoluteFillObject },
+  kav: { flex: 1, justifyContent: "flex-end" },
+  sheet: {
+    borderTopLeftRadius: 26,
+    borderTopRightRadius: 26,
+    borderWidth: reactNative.StyleSheet.hairlineWidth,
+    borderBottomWidth: 0,
+    paddingHorizontal: 20,
+    paddingTop: 4,
+    maxWidth: 640,
+    width: "100%",
+    alignSelf: "center",
+    ...reactNative.Platform.select({
+      ios: {
+        shadowColor: "#000",
+        shadowOffset: { width: 0, height: -8 },
+        shadowOpacity: 0.22,
+        shadowRadius: 28
+      },
+      android: { elevation: 24 }
+    })
+  },
+  handleZone: { alignItems: "center", paddingTop: 9, paddingBottom: 8 },
+  grabber: { width: 38, height: 5, borderRadius: 3 },
+  header: { flexDirection: "row", alignItems: "center", gap: 11, marginTop: 0, marginBottom: 14 },
+  iconCircle: { width: 36, height: 36, borderRadius: 12, alignItems: "center", justifyContent: "center" },
+  headerText: { flex: 1, gap: 1 },
+  title: { fontSize: 17, fontWeight: "700", letterSpacing: -0.3 },
+  subtitle: { fontSize: 12.5, letterSpacing: -0.1 },
+  // Hairline rule under the header so the title cluster reads as its own zone.
+  headerRule: { height: reactNative.StyleSheet.hairlineWidth, marginBottom: 16, marginHorizontal: -20 },
+  timer: { borderWidth: 1, borderRadius: 999, paddingHorizontal: 10, paddingVertical: 4.5, minWidth: 44, alignItems: "center" },
+  closeBtn: { width: 29, height: 29, borderRadius: 14.5, alignItems: "center", justifyContent: "center" },
+  // Short, non-scrolling bodies (stale / expired notices).
+  simpleBody: { paddingBottom: 8 }
+});
+var rc = reactNative.StyleSheet.create({
+  card: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 12,
+    borderWidth: 1.5,
+    borderRadius: 18,
+    paddingHorizontal: 14,
+    paddingVertical: 13,
+    marginVertical: 6
+  },
+  iconCircle: { width: 34, height: 34, borderRadius: 17, alignItems: "center", justifyContent: "center" },
+  textWrap: { flex: 1, gap: 1 },
+  title: { fontSize: 14.5, fontWeight: "700", letterSpacing: -0.2 },
+  subtitle: { fontSize: 12.5, letterSpacing: -0.1 },
+  timer: { borderRadius: 999, paddingHorizontal: 9, paddingVertical: 4, minWidth: 40, alignItems: "center" }
+});
+var PaymanChat = react.forwardRef(
+  function PaymanChat2({ config, callbacks, children, onLoadMoreMessages, isLoadingMoreMessages = false, hasMoreMessages = false }, ref) {
+    const accent = config.accent ?? DEFAULT_ACCENT;
+    const systemScheme = reactNative.useColorScheme();
+    const isDark = (config.colorScheme ?? systemScheme) === "dark";
+    const ui = isDark ? {
+      listBg: "#0d1719",
+      emptyText: "rgba(255,255,255,0.55)"
+    } : {
+      listBg: "#ffffff",
+      emptyText: "#6b7280"
+    };
+    const callbacksRef = react.useRef(callbacks);
+    react.useEffect(() => {
+      callbacksRef.current = callbacks;
+    });
+    const stableCallbacks = react.useMemo(() => ({
+      onSessionIdChange: (id) => callbacksRef.current?.onSessionIdChange?.(id),
+      onStreamStart: () => callbacksRef.current?.onStreamStart?.(),
+      onStreamEnd: () => callbacksRef.current?.onStreamEnd?.(),
+      onError: (e) => {
+        console.error("[PaymanChat] stream error:", e.message, e);
+        callbacksRef.current?.onError?.(e);
+      },
+      onStatusMessage: (m) => callbacksRef.current?.onStatusMessage?.(m),
+      onStepsUpdate: (steps) => callbacksRef.current?.onStepsUpdate?.(steps),
+      onUserActionRequired: (r) => {
+        console.log("[PaymanChat] USER_ACTION_REQUIRED:", JSON.stringify({ kind: r?.kind, rawAction: r?.rawAction, userActionId: r?.userActionId, hasSchema: !!r?.requestedSchema }));
+        callbacksRef.current?.onUserActionRequired?.(r);
+      },
+      onUserNotification: (n) => {
+        console.log("[PaymanChat] USER_NOTIFICATION:", JSON.stringify({ id: n?.id, message: n?.message }));
+        callbacksRef.current?.onUserNotification?.(n);
+      }
+    }), []);
+    const {
+      messages,
+      sendMessage,
+      isWaitingForResponse,
+      resetSession,
+      clearMessages,
+      prependMessages,
+      cancelStream,
+      getSessionId,
+      getMessages,
+      userActionState,
+      submitUserAction: submitUserAction2,
+      cancelUserAction: cancelUserAction2,
+      resendUserAction: resendUserAction2,
+      dismissNotification
+    } = useChatV2(config, stableCallbacks);
+    react.useEffect(() => {
+      console.log(
+        "[PaymanChat] userActionState ->",
+        "prompts:",
+        userActionState.prompts.length,
+        userActionState.prompts.map((p) => `${p.kind}:${p.status}`).join(","),
+        "| notifications:",
+        userActionState.notifications.length
+      );
+    }, [userActionState]);
+    const activePrompt = react.useMemo(
+      () => userActionState.prompts.find((p) => p.kind !== "notification"),
+      [userActionState.prompts]
+    );
+    const expired = useExpiredFlag(activePrompt);
+    const [dismissedActionId, setDismissedActionId] = react.useState(null);
+    react.useEffect(() => {
+      if (activePrompt) setDismissedActionId(null);
+    }, [activePrompt?.userActionId, activePrompt?.subAction]);
+    const sheetOpen = !!activePrompt && dismissedActionId !== activePrompt.userActionId;
+    const showReopenCard = !!activePrompt && !sheetOpen && !expired && activePrompt.status !== "stale";
+    const minimizeActivePrompt = react.useCallback(() => {
+      setDismissedActionId((prev) => activePrompt?.userActionId ?? prev);
+    }, [activePrompt?.userActionId]);
+    const {
+      transcribedText,
+      isAvailable: voiceAvailable,
+      isRecording,
+      startRecording,
+      stopRecording,
+      clearTranscript
+    } = useVoice(
+      { lang: "en-US", interimResults: true, continuous: true },
+      { onError: (e) => console.error("Voice error:", e) }
+    );
+    const [inputValue, setInputValue] = react.useState("");
+    const [recordingSeconds, setRecordingSeconds] = react.useState(0);
+    const recordingStartRef = react.useRef(null);
+    const recordingTimerRef = react.useRef(null);
+    react.useImperativeHandle(ref, () => ({ resetSession, clearMessages, cancelStream, getSessionId, getMessages }));
+    const contextValue = react.useMemo(() => ({
+      resetSession,
+      clearMessages,
+      prependMessages,
+      cancelStream,
+      getSessionId,
+      getMessages,
+      isWaitingForResponse
+    }), [resetSession, clearMessages, prependMessages, cancelStream, getSessionId, getMessages, isWaitingForResponse]);
+    react.useEffect(() => {
+      if (isRecording) {
+        recordingStartRef.current = Date.now();
+        setRecordingSeconds(0);
+        recordingTimerRef.current = setInterval(() => {
+          if (recordingStartRef.current != null)
+            setRecordingSeconds(Math.floor((Date.now() - recordingStartRef.current) / 1e3));
+        }, 1e3);
+      } else {
+        recordingStartRef.current = null;
+        if (recordingTimerRef.current) {
+          clearInterval(recordingTimerRef.current);
+          recordingTimerRef.current = null;
+        }
+        setRecordingSeconds(0);
+      }
+      return () => {
+        if (recordingTimerRef.current) clearInterval(recordingTimerRef.current);
+      };
+    }, [isRecording]);
+    const prevInput = react.useRef(inputValue);
+    react.useEffect(() => {
+      const wasEmpty = prevInput.current.trim() === "";
+      const isEmpty2 = inputValue.trim() === "";
+      prevInput.current = inputValue;
+      if (!wasEmpty && isEmpty2) {
+        clearTranscript();
+        if (isRecording) stopRecording();
+      }
+    }, [inputValue, clearTranscript, isRecording, stopRecording]);
+    const handleSend = react.useCallback(() => {
+      if (isRecording) stopRecording();
+      const text = inputValue.trim();
+      if (!text || isWaitingForResponse) return;
+      console.log("[PaymanChat] sending. baseUrl:", config.api?.baseUrl, "agentId:", config.agentId, "stage:", config.stage, "sessionOwnerId:", config.sessionParams?.id);
+      setInputValue("");
+      void sendMessage(text);
+    }, [inputValue, isWaitingForResponse, sendMessage, isRecording, stopRecording, config]);
+    const handleVoicePress = react.useCallback(async () => {
+      if (!voiceAvailable) return;
+      clearTranscript();
+      await startRecording();
+    }, [voiceAvailable, startRecording, clearTranscript]);
+    const handleConfirmRecording = react.useCallback(() => {
+      stopRecording();
+      if (transcribedText.trim()) setInputValue(transcribedText);
+    }, [stopRecording, transcribedText]);
+    const handleCancelRecording = react.useCallback(() => {
+      stopRecording();
+      clearTranscript();
+    }, [stopRecording, clearTranscript]);
+    const isInputDisabled = !config.sessionParams?.id?.trim();
+    const enableVoice = config.enableVoice !== false;
+    const isEmpty = messages.length === 0;
+    const prevMessageCountRef = react.useRef(messages.length);
+    const typingMessageIds = react.useRef(/* @__PURE__ */ new Set());
+    react.useEffect(() => {
+      if (messages.length > prevMessageCountRef.current) {
+        const newMsgs = messages.slice(prevMessageCountRef.current);
+        newMsgs.forEach((m) => {
+          if (m.role === "assistant") typingMessageIds.current.add(m.id);
+        });
+      }
+      prevMessageCountRef.current = messages.length;
+    }, [messages]);
+    const scrollRef = react.useRef(null);
+    const scrollToBottom = react.useCallback((animated = true) => {
+      scrollRef.current?.scrollToEnd({ animated });
+    }, []);
+    react.useEffect(() => {
+      const t = setTimeout(() => scrollToBottom(true), 60);
+      return () => clearTimeout(t);
+    }, [messages, scrollToBottom]);
+    return /* @__PURE__ */ jsxRuntime.jsx(PaymanChatContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsxs(
+      reactNative.KeyboardAvoidingView,
+      {
+        style: s.container,
+        behavior: reactNative.Platform.OS === "ios" ? "padding" : "height",
+        keyboardVerticalOffset: 0,
+        children: [
+          children,
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [s.messageListWrap, { backgroundColor: ui.listBg }], children: isEmpty && !isWaitingForResponse ? /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: s.emptyState, children: [
+            config.emptyStateComponent,
+            config.emptyStateComponent != null && /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { height: 16 } }),
+            /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [s.emptyText, { color: ui.emptyText }], children: config.emptyStateText ?? "How can I help you today?" })
+          ] }) : /* @__PURE__ */ jsxRuntime.jsxs(
+            reactNative.ScrollView,
+            {
+              ref: scrollRef,
+              style: s.scrollList,
+              contentContainerStyle: s.listContent,
+              showsVerticalScrollIndicator: false,
+              keyboardShouldPersistTaps: "handled",
+              onContentSizeChange: () => scrollToBottom(false),
+              children: [
+                messages.map((msg) => /* @__PURE__ */ jsxRuntime.jsx(
+                  MessageBubble,
+                  {
+                    message: msg,
+                    accent,
+                    shouldType: typingMessageIds.current.has(msg.id),
+                    isDark,
+                    suppressText: activePrompt?.message && msg.role === "assistant" && msg.id === messages[messages.length - 1]?.id ? activePrompt.message : void 0
+                  },
+                  msg.id
+                )),
+                showReopenCard && activePrompt ? /* @__PURE__ */ jsxRuntime.jsx(
+                  UserActionReopenCard,
+                  {
+                    active: activePrompt,
+                    expired,
+                    isDark,
+                    accent,
+                    onReopen: () => setDismissedActionId(null)
+                  }
+                ) : null,
+                /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { height: 4 } })
+              ]
+            }
+          ) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            NotificationStack,
+            {
+              notifications: userActionState.notifications,
+              isDark,
+              onDismiss: dismissNotification
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: s.inputBarWrap, children: /* @__PURE__ */ jsxRuntime.jsx(
+            InputBar,
+            {
+              value: inputValue,
+              onChange: setInputValue,
+              onSend: handleSend,
+              onCancel: cancelStream,
+              disabled: isInputDisabled,
+              placeholder: config.placeholder ?? "Type your message...",
+              isStreaming: isWaitingForResponse,
+              accent,
+              enableVoice,
+              voiceAvailable: enableVoice && voiceAvailable,
+              isRecording: enableVoice && isRecording,
+              recordingSeconds,
+              transcribedText,
+              onVoicePress: handleVoicePress,
+              onConfirmRecording: handleConfirmRecording,
+              onCancelRecording: handleCancelRecording,
+              onFocus: () => {
+              },
+              insetBottom: config.contentInsetBottom ?? (reactNative.Platform.OS === "ios" ? 20 : 8)
+            }
+          ) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            UserActionSheet,
+            {
+              open: sheetOpen,
+              active: activePrompt,
+              expired,
+              isDark,
+              accent,
+              insetBottom: config.contentInsetBottom ?? (reactNative.Platform.OS === "ios" ? 20 : 8),
+              onSubmit: submitUserAction2,
+              onCancel: cancelUserAction2,
+              onResend: resendUserAction2,
+              onMinimize: minimizeActivePrompt
+            }
+          )
+        ]
+      }
+    ) });
+  }
+);
+var s = reactNative.StyleSheet.create({
+  container: { flex: 1, backgroundColor: "#f1f5f9" },
+  messageListWrap: { flex: 1, minHeight: 0, backgroundColor: "#ffffff" },
+  inputBarWrap: {
+    width: "100%",
+    zIndex: 2,
+    backgroundColor: "#ffffff",
+    ...reactNative.Platform.select({ android: { elevation: 8 }, default: {} })
+  },
+  // ── Input bar ──
+  outerBar: {
+    width: "100%",
+    backgroundColor: "#f1f5f9",
+    borderTopWidth: 1,
+    borderTopColor: "rgba(0,0,0,0.08)",
+    paddingTop: 6,
+    paddingHorizontal: 12,
+    borderTopLeftRadius: 20,
+    borderTopRightRadius: 20
+  },
+  outerBarVoice: {},
+  column: { maxWidth: 672, width: "100%", alignSelf: "center", gap: 2 },
+  inputWrap: { width: "100%", justifyContent: "center", paddingHorizontal: 4 },
+  inputWrapRelative: { position: "relative" },
+  input: {
+    minHeight: 36,
+    maxHeight: 110,
+    paddingVertical: 8,
+    paddingHorizontal: 16,
+    fontSize: 16,
+    color: "#1F2937",
+    lineHeight: 22
+  },
+  inputDisabled: { opacity: 0.5 },
+  inputHidden: { position: "absolute", left: 0, right: 0, top: 0, opacity: 0, zIndex: 0 },
+  actionsRow: { flexDirection: "row", justifyContent: "flex-end", alignItems: "center", marginBottom: 2 },
+  rightActions: { flexDirection: "row", alignItems: "center", gap: 6 },
+  iconBtn: { width: 28, height: 28, justifyContent: "center", alignItems: "center", borderRadius: 14, overflow: "hidden" },
+  iconBtnInner: { width: 28, height: 28, justifyContent: "center", alignItems: "center", backgroundColor: "rgba(0,0,0,0.1)", borderRadius: 14 },
+  sendBtn: { width: 28, height: 28, borderRadius: 14, overflow: "hidden", justifyContent: "center", alignItems: "center" },
+  sendBtnInner: { width: 28, height: 28, borderRadius: 14, justifyContent: "center", alignItems: "center" },
+  btnDisabled: { opacity: 0.35 },
+  pressed: { opacity: 0.7 },
+  disclaimerWrap: { maxWidth: 672, width: "100%", alignSelf: "center", paddingHorizontal: 12, marginTop: 2 },
+  disclaimerText: { fontSize: 10, lineHeight: 13, color: "#9CA3AF", textAlign: "center" },
+  // ── Voice bar ──
+  voiceBarContainer: { position: "absolute", left: 0, right: 0, top: 0, bottom: 0, justifyContent: "center", zIndex: 1 },
+  voiceBar: { flexDirection: "row", alignItems: "center", justifyContent: "space-between", borderWidth: 1, borderRadius: 28, minHeight: 56, paddingHorizontal: 12, paddingVertical: 10, gap: 12 },
+  voiceBarCircle: { width: 40, height: 40, borderRadius: 20, alignItems: "center", justifyContent: "center" },
+  voiceConfirm: { backgroundColor: "#FFFFFF", borderWidth: 1 },
+  voiceBarCenter: { flex: 1, flexDirection: "row", alignItems: "center", justifyContent: "space-between", gap: 10, marginLeft: 8 },
+  voiceDots: { flex: 1, flexDirection: "row", alignItems: "center", justifyContent: "space-between", gap: 4 },
+  voiceDot: { width: 4, borderRadius: 2 },
+  voiceTimer: { fontSize: 15, fontWeight: "600", minWidth: 36, textAlign: "right" },
+  // ── Messages ──
+  scrollList: { flex: 1 },
+  listContent: { paddingHorizontal: 16, paddingTop: 8, paddingBottom: 4, flexGrow: 1 },
+  emptyState: { flex: 1, alignItems: "center", justifyContent: "center", paddingHorizontal: 32, paddingBottom: 60 },
+  emptyText: { fontSize: 16, color: "#6b7280", textAlign: "center" }
+});
+var sd = reactNative.StyleSheet.create({
+  bubbleRow: { flexDirection: "row", marginVertical: 3 },
+  rowUser: { justifyContent: "flex-end" },
+  rowAssistant: { justifyContent: "flex-start" },
+  bubble: { maxWidth: "82%", paddingHorizontal: 14, paddingVertical: 10, borderRadius: 18 },
+  bubbleUser: { borderBottomRightRadius: 4 },
+  bubbleAssistant: { backgroundColor: "#f3f4f6", borderBottomLeftRadius: 4 },
+  // Assistant bubbles stretch wider so tables and code blocks have room
+  bubbleAssistantWide: { maxWidth: "97%" },
+  bubbleError: { backgroundColor: "#fef2f2" },
+  bubbleText: { fontSize: 15, lineHeight: 22 },
+  textUser: { color: "#ffffff" },
+  textAssistant: { color: "#111827" },
+  errorText: { fontSize: 14, lineHeight: 20, color: "#dc2626" },
+  partialErrorText: { fontSize: 12, color: "#dc2626", marginTop: 4 },
+  cancelledText: { fontSize: 12, color: "#9ca3af", marginTop: 4, fontStyle: "italic" },
+  thinkingRow: { flexDirection: "row", alignItems: "flex-start", gap: 6, marginBottom: 3 },
+  thinkingIcon: { fontSize: 12, lineHeight: 20, width: 14 },
+  thinkingStepText: { flex: 1, fontSize: 14, lineHeight: 20, color: "#374151", fontStyle: "italic" },
+  thinkingStepDone: { color: "#9ca3af" }
+});
+function mdPalette(isDark) {
+  return isDark ? {
+    text: "rgba(255,255,255,0.92)",
+    heading: "#ffffff",
+    muted: "rgba(255,255,255,0.55)",
+    border: "rgba(255,255,255,0.16)",
+    borderSoft: "rgba(255,255,255,0.10)",
+    headerBg: "rgba(255,255,255,0.07)",
+    codeInlineBg: "rgba(255,255,255,0.12)",
+    codeInlineText: "#e8eaed",
+    codeBlockBg: "#0b1416",
+    codeBlockText: "#f3f4f6",
+    blockquoteBar: "rgba(255,255,255,0.22)",
+    hr: "rgba(255,255,255,0.14)",
+    link: "#34c3cc"
+  } : {
+    text: "#1f2937",
+    heading: "#111827",
+    muted: "#4b5563",
+    border: "#d1d5db",
+    borderSoft: "#e5e7eb",
+    headerBg: "#f3f4f6",
+    codeInlineBg: "#e5e7eb",
+    codeInlineText: "#1f2937",
+    codeBlockBg: "#1f2937",
+    codeBlockText: "#f9fafb",
+    blockquoteBar: "#d1d5db",
+    hr: "#e5e7eb",
+    link: "#00858d"
+  };
+}
+var TABLE_CHAR_W = 7.6;
+var TABLE_CELL_PAD = 26;
+var TABLE_MIN_W = 44;
+var TABLE_MAX_W = 220;
+function nodeText(node) {
+  if (!node) return "";
+  if (Array.isArray(node.children) && node.children.length) {
+    return node.children.map(nodeText).join("");
+  }
+  return typeof node.content === "string" ? node.content : "";
+}
+function tableMatrix(tableNode) {
+  const rows = [];
+  const walk = (n) => {
+    if (!n) return;
+    if (n.type === "tr") {
+      rows.push((n.children || []).map(nodeText));
+      return;
+    }
+    (n.children || []).forEach(walk);
+  };
+  walk(tableNode);
+  return rows;
+}
+function makeMdRules(isDark, accent) {
+  const c = mdPalette(isDark);
+  const headerBg = isDark ? accent + "2E" : accent + "14";
+  const headerText = isDark ? "#8fe3e9" : accent;
+  return {
+    table: (node) => {
+      const rows = tableMatrix(node);
+      if (rows.length === 0) return null;
+      const ncols = Math.max(...rows.map((r) => r.length));
+      const colW = [];
+      for (let ci = 0; ci < ncols; ci++) {
+        let maxLen = 0;
+        for (const r of rows) maxLen = Math.max(maxLen, (r[ci] || "").length);
+        colW[ci] = Math.min(
+          TABLE_MAX_W,
+          Math.max(TABLE_MIN_W, Math.round(maxLen * TABLE_CHAR_W) + TABLE_CELL_PAD)
+        );
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.ScrollView,
+        {
+          horizontal: true,
+          showsHorizontalScrollIndicator: true,
+          style: { marginVertical: 8 },
+          children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { borderWidth: 1, borderColor: c.border, borderRadius: 8, overflow: "hidden" }, children: rows.map((cells, ri) => {
+            const isHeader = ri === 0;
+            return /* @__PURE__ */ jsxRuntime.jsx(
+              reactNative.View,
+              {
+                style: {
+                  flexDirection: "row",
+                  backgroundColor: isHeader ? headerBg : "transparent",
+                  borderTopWidth: ri === 0 ? 0 : 1,
+                  borderTopColor: c.borderSoft
+                },
+                children: Array.from({ length: ncols }).map((_, ci) => /* @__PURE__ */ jsxRuntime.jsx(
+                  reactNative.View,
+                  {
+                    style: {
+                      width: colW[ci],
+                      paddingHorizontal: 12,
+                      paddingVertical: 9,
+                      borderRightWidth: ci === ncols - 1 ? 0 : 1,
+                      borderRightColor: c.borderSoft,
+                      justifyContent: "center"
+                    },
+                    children: /* @__PURE__ */ jsxRuntime.jsx(
+                      reactNative.Text,
+                      {
+                        style: {
+                          fontSize: 13,
+                          lineHeight: 18,
+                          color: isHeader ? headerText : c.text,
+                          fontWeight: isHeader ? "700" : "400"
+                        },
+                        children: cells[ci] ?? ""
+                      }
+                    )
+                  },
+                  ci
+                ))
+              },
+              ri
+            );
+          }) })
+        },
+        node.key
+      );
+    }
+  };
+}
+function makeMdStyles(isDark) {
+  const c = mdPalette(isDark);
+  const mono = reactNative.Platform.OS === "ios" ? "Menlo" : "monospace";
+  return {
+    // Body
+    body: { color: c.text, fontSize: 14, lineHeight: 21 },
+    paragraph: { marginTop: 0, marginBottom: 4 },
+    // Emphasis
+    strong: { fontWeight: "700", color: c.text },
+    em: { fontStyle: "italic", color: c.text },
+    // Links
+    link: { color: c.link, textDecorationLine: "underline" },
+    // Inline code
+    code_inline: {
+      backgroundColor: c.codeInlineBg,
+      color: c.codeInlineText,
+      fontFamily: mono,
+      fontSize: 12,
+      paddingHorizontal: 4,
+      borderRadius: 4
+    },
+    code_inline_container: { borderRadius: 4 },
+    // Code blocks
+    fence: { backgroundColor: c.codeBlockBg, borderRadius: 8, padding: 12, marginVertical: 6 },
+    code_block: { backgroundColor: c.codeBlockBg, borderRadius: 8, padding: 12, marginVertical: 6 },
+    fence_code: { color: c.codeBlockText, fontFamily: mono, fontSize: 12 },
+    // Lists
+    bullet_list: { marginVertical: 4 },
+    ordered_list: { marginVertical: 4 },
+    list_item: { marginVertical: 1 },
+    bullet_list_icon: { color: c.muted, marginTop: 6 },
+    ordered_list_icon: { color: c.muted },
+    list_item_text: { fontSize: 14, color: c.text },
+    // Headings
+    heading1: { fontSize: 18, fontWeight: "700", color: c.heading, marginBottom: 6, marginTop: 8 },
+    heading2: { fontSize: 16, fontWeight: "700", color: c.heading, marginBottom: 4, marginTop: 6 },
+    heading3: { fontSize: 15, fontWeight: "600", color: c.heading, marginBottom: 4, marginTop: 4 },
+    // Blockquote / HR
+    blockquote: { borderLeftWidth: 3, borderLeftColor: c.blockquoteBar, paddingLeft: 10, marginVertical: 4 },
+    hr: { backgroundColor: c.hr, height: 1, marginVertical: 8 }
+    // Tables are rendered by a fully custom `table` rule (see makeMdRules) —
+    // no per-cell styles needed here.
+  };
+}
+var MD_STYLES_LIGHT = makeMdStyles(false);
+var MD_STYLES_DARK = makeMdStyles(true);
+function cn(...inputs) {
+  return tailwindMerge.twMerge(clsx.clsx(inputs));
+}
+
+// src/utils/formatDate.ts
+function formatDate(timestamp) {
+  const date = typeof timestamp === "string" ? new Date(timestamp) : timestamp;
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 6e4);
+  const diffHours = Math.floor(diffMs / 36e5);
+  const diffDays = Math.floor(diffMs / 864e5);
+  if (diffMins < 1) {
+    return "Just now";
+  }
+  if (diffMins < 60) {
+    return `${diffMins}m ago`;
+  }
+  if (diffHours < 24) {
+    return `${diffHours}h ago`;
+  }
+  if (diffDays < 7) {
+    return `${diffDays}d ago`;
+  }
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: date.getFullYear() !== now.getFullYear() ? "numeric" : void 0
+  });
+}
+function captureSentryError(error, context) {
+  if (!Sentry__namespace.getClient()) return;
+  const tags = {};
+  if (context.executionId) tags.executionId = context.executionId;
+  if (context.sessionId) tags.sessionId = context.sessionId;
+  if (context.route) tags.route = context.route;
+  if (context.cfRay) tags.cfRay = context.cfRay;
+  if (context.customerId) tags.customerId = context.customerId;
+  if (context.customerEmail) tags.customerEmail = context.customerEmail;
+  const contexts = {
+    chat_session: {
+      sessionId: context.sessionId ?? null,
+      sessionOwnerId: context.sessionOwnerId ?? null,
+      executionId: context.executionId ?? null,
+      agentId: context.agentId ?? null,
+      cfRay: context.cfRay ?? null,
+      customerId: context.customerId ?? null,
+      customerEmail: context.customerEmail ?? null
+    }
+  };
+  if (typeof error === "string") {
+    Sentry__namespace.captureMessage(error, { level: "error", tags, contexts });
+  } else {
+    Sentry__namespace.captureException(error, { tags, contexts });
+  }
+}
+
+exports.PaymanChat = PaymanChat;
+exports.PaymanChatContext = PaymanChatContext;
+exports.UserActionStaleError = UserActionStaleError;
+exports.cancelUserAction = cancelUserAction;
+exports.captureSentryError = captureSentryError;
+exports.cn = cn;
+exports.formatDate = formatDate;
+exports.resendUserAction = resendUserAction;
+exports.submitUserAction = submitUserAction;
+exports.useChatV2 = useChatV2;
+exports.usePaymanChat = usePaymanChat;
+exports.useVoice = useVoice;
+//# sourceMappingURL=index.native.js.map
+//# sourceMappingURL=index.native.js.map