@opengeni/react-native 1.4.5-canary.37615713321001

package/dist/index.js

@@ -0,0 +1,3345 @@
+import { sha256HexToArrayBuffer } from './chunk-5ZVK7WKA.js';
+export { createHydratedPersistenceAdapter, sha256HexToArrayBuffer } from './chunk-5ZVK7WKA.js';
+export { NativeTranscriptionError, appendDictation, isRetryableTranscriptionError, useNativeVoiceInput } from './chunk-EEDIMY3L.js';
+import { ThinkingOrb } from './chunk-M23SDI4R.js';
+import { useNativeTimelineTheme, Icon, fontStyle } from './chunk-PHJBSAR3.js';
+import { createContext, useState, useEffect, useLayoutEffect, useMemo, useContext, useRef, useCallback } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useSessionEvents, useSession, useTurnQueue, useComposer, useSessionControl, useHumanInputRequests, useGoal, useSessionLineage, projectPendingApprovals, groupTimeline, useSessionMcpApprovalPolicy } from '@opengeni/react/session';
+import { sessionAttentionReadThroughSequence } from '@opengeni/react/session-attention-model';
+import { StyleSheet, Platform, KeyboardAvoidingView, View, FlatList, ActivityIndicator, Text, ScrollView, Pressable, Linking, TextInput } from 'react-native';
+import { createSessionRealtimeController, sessionRealtimeTransportKind } from '@opengeni/sdk/realtime';
+import { useSessionRealtime } from '@opengeni/react/session-realtime';
+
+function createEventTarget() {
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    addEventListener: (type, listener) => {
+      const existing = listeners.get(type) ?? /* @__PURE__ */ new Set();
+      existing.add(listener);
+      listeners.set(type, existing);
+    },
+    removeEventListener: (type, listener) => {
+      listeners.get(type)?.delete(listener);
+    },
+    dispatch: (type) => {
+      for (const listener of listeners.get(type) ?? []) listener();
+    }
+  };
+}
+function installOpenGeniReactNativeEnvironment(adapters) {
+  const globals = globalThis;
+  const windowTarget = createEventTarget();
+  const documentTarget = createEventTarget();
+  const existingWindow = Reflect.get(globals, "window");
+  const existingSessionStorage = Reflect.get(globals, "sessionStorage");
+  const existingDocument = Reflect.get(globals, "document");
+  const existingCrypto = Reflect.get(globals, "crypto");
+  const nativeWindow = createDelegatingObject(isObject(existingWindow) ? existingWindow : globals);
+  let lifecycleState = adapters.lifecycle.currentState();
+  const sessionStorage = {
+    getItem: (key) => adapters.persistence.getItem(key),
+    setItem: (key, value) => adapters.persistence.setItem(key, value),
+    removeItem: (key) => adapters.persistence.removeItem(key),
+    clear: () => adapters.persistence.clear(),
+    key: () => null,
+    get length() {
+      return 0;
+    }
+  };
+  const nativeCrypto = createDelegatingObject(isObject(existingCrypto) ? existingCrypto : null);
+  const subtleValue = isObject(existingCrypto) ? Reflect.get(existingCrypto, "subtle") : void 0;
+  const nativeSubtle = createDelegatingObject(isObject(subtleValue) ? subtleValue : null);
+  Reflect.set(nativeCrypto, "randomUUID", () => adapters.crypto.randomUUID());
+  Reflect.set(
+    nativeSubtle,
+    "digest",
+    async (algorithm, data) => {
+      const name = typeof algorithm === "string" ? algorithm : algorithm.name;
+      if (name.toUpperCase() !== "SHA-256") {
+        throw new TypeError(`Unsupported native digest algorithm: ${name}`);
+      }
+      const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+      return sha256HexToArrayBuffer(await adapters.crypto.sha256Hex(bytes));
+    }
+  );
+  Reflect.set(nativeCrypto, "subtle", nativeSubtle);
+  Reflect.set(globals, "crypto", nativeCrypto);
+  Reflect.set(nativeWindow, "sessionStorage", sessionStorage);
+  if (typeof Reflect.get(nativeWindow, "setTimeout") !== "function") {
+    Reflect.set(nativeWindow, "setTimeout", globalThis.setTimeout.bind(globalThis));
+  }
+  if (typeof Reflect.get(nativeWindow, "clearTimeout") !== "function") {
+    Reflect.set(nativeWindow, "clearTimeout", globalThis.clearTimeout.bind(globalThis));
+  }
+  if (typeof Reflect.get(nativeWindow, "addEventListener") !== "function") {
+    Reflect.set(
+      nativeWindow,
+      "addEventListener",
+      (type, listener) => windowTarget.addEventListener(type, listener)
+    );
+  }
+  if (typeof Reflect.get(nativeWindow, "removeEventListener") !== "function") {
+    Reflect.set(
+      nativeWindow,
+      "removeEventListener",
+      (type, listener) => windowTarget.removeEventListener(type, listener)
+    );
+  }
+  Reflect.set(globals, "window", nativeWindow);
+  Reflect.set(globals, "sessionStorage", sessionStorage);
+  const nativeDocument = {
+    get visibilityState() {
+      return lifecycleState === "active" ? "visible" : "hidden";
+    },
+    addEventListener: (type, listener) => documentTarget.addEventListener(type, listener),
+    removeEventListener: (type, listener) => documentTarget.removeEventListener(type, listener)
+  };
+  Reflect.set(globals, "document", nativeDocument);
+  const unsubscribe = adapters.lifecycle.subscribe((next) => {
+    const wasActive = lifecycleState === "active";
+    lifecycleState = next;
+    documentTarget.dispatch("visibilitychange");
+    if (!wasActive && next === "active") windowTarget.dispatch("pageshow");
+  });
+  return {
+    cleanup: () => {
+      unsubscribe();
+      restoreGlobal(globals, "window", nativeWindow, existingWindow);
+      restoreGlobal(globals, "sessionStorage", sessionStorage, existingSessionStorage);
+      restoreGlobal(globals, "document", nativeDocument, existingDocument);
+      restoreGlobal(globals, "crypto", nativeCrypto, existingCrypto);
+    }
+  };
+}
+function restoreGlobal(target, key, installedValue, previousValue) {
+  if (Reflect.get(target, key) !== installedValue) return;
+  if (previousValue === void 0) Reflect.deleteProperty(target, key);
+  else Reflect.set(target, key, previousValue);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function createDelegatingObject(prototype) {
+  const value = {};
+  Object.setPrototypeOf(value, prototype);
+  return value;
+}
+var NativeEnvironmentContext = createContext(null);
+function OpenGeniReactNativeProvider({
+  adapters,
+  children,
+  loadingFallback = null
+}) {
+  const [hydrated, setHydrated] = useState(false);
+  const [active, setActive] = useState(adapters.lifecycle.currentState() === "active");
+  useEffect(() => {
+    let mounted = true;
+    setHydrated(false);
+    void adapters.persistence.hydrate().then(() => {
+      if (!mounted) return;
+      setHydrated(true);
+    });
+    const unsubscribe = adapters.lifecycle.subscribe((state) => setActive(state === "active"));
+    return () => {
+      mounted = false;
+      unsubscribe();
+    };
+  }, [adapters]);
+  useLayoutEffect(() => {
+    const installed = installOpenGeniReactNativeEnvironment(adapters);
+    return () => {
+      globalThis.setTimeout(() => installed.cleanup(), 0);
+    };
+  }, [adapters]);
+  const value = useMemo(() => ({ adapters, active }), [active, adapters]);
+  if (!hydrated) return loadingFallback;
+  return /* @__PURE__ */ jsx(NativeEnvironmentContext.Provider, { value, children });
+}
+function useOpenGeniReactNativeEnvironment() {
+  const value = useContext(NativeEnvironmentContext);
+  if (!value) {
+    throw new Error("OpenGeni native hooks require OpenGeniReactNativeProvider");
+  }
+  return value;
+}
+var NATIVE_ATTACHMENT_PREPARATION_TIMEOUT_MS = 3e4;
+function sameNativeAttachmentScope(left, right) {
+  return left.client === right.client && left.workspaceId === right.workspaceId && left.sessionId === right.sessionId;
+}
+function projectNativeAttachmentScopeState(scopeMatches, attachments, error) {
+  return scopeMatches ? { attachments, error } : { attachments: [], error: null };
+}
+async function runNativeAttachmentPicker(input) {
+  try {
+    const files = await input.pick();
+    if (input.currentGeneration() !== input.generation) return "stale";
+    await input.addFiles(files, input.generation);
+    return input.currentGeneration() === input.generation ? "added" : "stale";
+  } catch (cause) {
+    if (input.currentGeneration() !== input.generation) return "stale";
+    input.onError(cause instanceof Error ? cause : new Error(String(cause)));
+    return "failed";
+  }
+}
+async function addNativeFilesForGeneration(input) {
+  if (input.currentGeneration() !== input.generation) return;
+  const unique = input.files.filter((file) => !input.hasSource(file.id));
+  if (unique.length === 0) return;
+  for (const file of unique) input.rememberSource(file);
+  input.appendAttachments(unique);
+  await unique.reduce(async (previous, file) => {
+    await previous;
+    if (input.currentGeneration() !== input.generation) return;
+    await input.upload(file, input.generation);
+  }, Promise.resolve());
+}
+async function prepareNativeAttachmentUpload(input) {
+  const timeoutMs = input.timeoutMs ?? NATIVE_ATTACHMENT_PREPARATION_TIMEOUT_MS;
+  const bytes = await withTimeout(
+    input.files.readBytes(input.source),
+    timeoutMs,
+    "File preparation timed out. Retry the upload."
+  );
+  const sha256 = await withTimeout(
+    input.crypto.sha256Hex(bytes),
+    timeoutMs,
+    "File verification timed out. Retry the upload."
+  );
+  const uploadBytes = Uint8Array.from(bytes);
+  const data = uploadBytes.buffer;
+  return { bytes, data, sha256 };
+}
+async function withTimeout(operation, timeoutMs, message) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("Native attachment timeout must be a positive number");
+  }
+  let timeout;
+  const timedOut = new Promise((_resolve, reject) => {
+    timeout = setTimeout(() => reject(new Error(message)), timeoutMs);
+  });
+  try {
+    return await Promise.race([operation, timedOut]);
+  } finally {
+    if (timeout !== void 0) clearTimeout(timeout);
+  }
+}
+function useNativeFileAttachments(input) {
+  const [attachments, setAttachments] = useState([]);
+  const [error, setError] = useState(null);
+  const sources = useRef(/* @__PURE__ */ new Map());
+  const attempts = useRef(/* @__PURE__ */ new Map());
+  const scopeGeneration = useRef(0);
+  const currentScope = {
+    client: input.client,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId
+  };
+  const previousScope = useRef(currentScope);
+  const scopeMatches = sameNativeAttachmentScope(previousScope.current, currentScope);
+  useLayoutEffect(() => {
+    const nextScope = {
+      client: input.client,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId
+    };
+    if (sameNativeAttachmentScope(previousScope.current, nextScope)) return;
+    previousScope.current = nextScope;
+    scopeGeneration.current += 1;
+    sources.current.clear();
+    attempts.current.clear();
+    setAttachments([]);
+    setError(null);
+  }, [input.client, input.sessionId, input.workspaceId]);
+  useEffect(
+    () => () => {
+      scopeGeneration.current += 1;
+      sources.current.clear();
+      attempts.current.clear();
+    },
+    []
+  );
+  const upload = useCallback(
+    async (source, generation = scopeGeneration.current) => {
+      if (scopeGeneration.current !== generation) return;
+      const attempt = (attempts.current.get(source.id) ?? 0) + 1;
+      attempts.current.set(source.id, attempt);
+      setAttachments(
+        (current) => current.map(
+          (entry) => entry.id === source.id ? { ...entry, status: "preparing", error: void 0 } : entry
+        )
+      );
+      try {
+        const { data, sha256 } = await prepareNativeAttachmentUpload({
+          source,
+          files: input.files,
+          crypto: input.crypto
+        });
+        if (scopeGeneration.current !== generation || attempts.current.get(source.id) !== attempt || !sources.current.has(source.id)) {
+          return;
+        }
+        setAttachments(
+          (current) => current.map(
+            (entry) => entry.id === source.id ? { ...entry, status: "uploading" } : entry
+          )
+        );
+        const file = await input.client.uploadFile(input.workspaceId, {
+          filename: source.name,
+          contentType: source.contentType,
+          data,
+          sha256
+        });
+        if (scopeGeneration.current !== generation || attempts.current.get(source.id) !== attempt || !sources.current.has(source.id)) {
+          return;
+        }
+        sources.current.delete(source.id);
+        attempts.current.delete(source.id);
+        setAttachments(
+          (current) => current.map(
+            (entry) => entry.id === source.id ? { ...entry, status: "ready", file, error: void 0 } : entry
+          )
+        );
+      } catch (cause) {
+        if (scopeGeneration.current !== generation || attempts.current.get(source.id) !== attempt || !sources.current.has(source.id)) {
+          return;
+        }
+        setAttachments(
+          (current) => current.map(
+            (entry) => entry.id === source.id ? {
+              ...entry,
+              status: "failed",
+              error: cause instanceof Error ? cause.message : String(cause)
+            } : entry
+          )
+        );
+      }
+    },
+    [input.client, input.crypto, input.files, input.workspaceId]
+  );
+  const addFilesForGeneration = useCallback(
+    async (files, generation) => {
+      await addNativeFilesForGeneration({
+        files,
+        generation,
+        currentGeneration: () => scopeGeneration.current,
+        hasSource: (id) => sources.current.has(id),
+        rememberSource: (file) => sources.current.set(file.id, file),
+        appendAttachments: (unique) => setAttachments((current) => [
+          ...current,
+          ...unique.map(
+            (file) => ({
+              id: file.id,
+              name: file.name,
+              contentType: file.contentType,
+              sizeBytes: file.sizeBytes,
+              kind: file.kind,
+              ...file.previewUri ? { previewUri: file.previewUri } : {},
+              status: "preparing"
+            })
+          )
+        ]),
+        upload
+      });
+    },
+    [upload]
+  );
+  const addFiles = useCallback(
+    async (files) => await addFilesForGeneration(files, scopeGeneration.current),
+    [addFilesForGeneration]
+  );
+  const pickFiles = useCallback(
+    async (pick) => {
+      const generation = scopeGeneration.current;
+      setError(null);
+      await runNativeAttachmentPicker({
+        generation,
+        currentGeneration: () => scopeGeneration.current,
+        pick,
+        addFiles: addFilesForGeneration,
+        onError: setError
+      });
+    },
+    [addFilesForGeneration]
+  );
+  const pickDocuments = useCallback(
+    async () => await pickFiles(() => input.files.pickDocuments()),
+    [input.files, pickFiles]
+  );
+  const pickImages = useCallback(
+    async () => await pickFiles(() => input.files.pickImages()),
+    [input.files, pickFiles]
+  );
+  const retry = useCallback(
+    async (id) => {
+      const source = sources.current.get(id);
+      if (source) await upload(source);
+    },
+    [upload]
+  );
+  const remove = useCallback((id) => {
+    sources.current.delete(id);
+    attempts.current.delete(id);
+    setAttachments((current) => current.filter((entry) => entry.id !== id));
+  }, []);
+  const clear = useCallback(() => {
+    sources.current.clear();
+    attempts.current.clear();
+    setAttachments([]);
+    setError(null);
+  }, []);
+  const clearError = useCallback(() => setError(null), []);
+  const restoreReady = useCallback((files) => {
+    const restored = [...files];
+    setAttachments((current) => {
+      const kept = current.filter((entry) => entry.status !== "ready");
+      return [
+        ...restored.map(
+          (file) => ({
+            id: `restored:${file.id}`,
+            name: file.filename,
+            contentType: file.contentType,
+            sizeBytes: file.sizeBytes,
+            kind: file.contentType.startsWith("image/") ? "image" : "document",
+            status: "ready",
+            file
+          })
+        ),
+        ...kept
+      ];
+    });
+  }, []);
+  const visibleState = projectNativeAttachmentScopeState(scopeMatches, attachments, error);
+  const visibleAttachments = visibleState.attachments;
+  const visibleError = visibleState.error;
+  const readyResources = useMemo(
+    () => visibleAttachments.flatMap(
+      (attachment) => attachment.status === "ready" && attachment.file ? [{ kind: "file", fileId: attachment.file.id }] : []
+    ),
+    [visibleAttachments]
+  );
+  return {
+    attachments: visibleAttachments,
+    readyResources,
+    uploading: visibleAttachments.some(
+      (attachment) => attachment.status === "preparing" || attachment.status === "uploading"
+    ),
+    hasUnresolved: visibleAttachments.some((attachment) => attachment.status !== "ready"),
+    error: visibleError,
+    pickDocuments,
+    pickImages,
+    addFiles,
+    retry,
+    remove,
+    clear,
+    clearError,
+    restoreReady
+  };
+}
+function readAcknowledgementFrontier(session, attentionThrough) {
+  const lastSequence = session?.lastSequence ?? 0;
+  return {
+    readThrough: Math.max(lastSequence, attentionThrough),
+    unread: Boolean(session?.unread) || attentionThrough > lastSequence
+  };
+}
+function useNativeReadAcknowledgement(input) {
+  const { client, workspaceId, sessionId, session, events, active } = input;
+  const attentionThrough = useMemo(() => sessionAttentionReadThroughSequence(events), [events]);
+  const { readThrough, unread } = readAcknowledgementFrontier(session, attentionThrough);
+  const acknowledged = useRef(null);
+  useEffect(() => {
+    if (!active || !session || !unread || readThrough <= 0) return;
+    if (!client.updateSessionAttention) return;
+    const key = `${workspaceId}:${sessionId}:${readThrough}`;
+    const previous = acknowledged.current;
+    if (previous?.key === key) return;
+    acknowledged.current = { key, retried: false };
+    const send = () => client.updateSessionAttention(workspaceId, sessionId, {
+      unread: false,
+      acknowledgedThroughSequence: readThrough
+    });
+    send().catch(() => {
+      const current = acknowledged.current;
+      if (current?.key !== key || current.retried) return;
+      current.retried = true;
+      void send().catch(() => void 0);
+    });
+  }, [active, client, readThrough, session, sessionId, unread, workspaceId]);
+}
+
+// src/use-native-session.ts
+function sessionRunActive(status) {
+  return status === "queued" || status === "running" || status === "recovering" || status === "waiting_capacity" || status === "requires_action";
+}
+function useOpenGeniNativeSession(input) {
+  const environment = useOpenGeniReactNativeEnvironment();
+  const events = useSessionEvents(input.sessionId, {
+    client: input.client,
+    workspaceId: input.workspaceId,
+    enabled: environment.active
+  });
+  const session = useSession(input.sessionId, {
+    client: input.client,
+    workspaceId: input.workspaceId,
+    enabled: environment.active,
+    events: events.events
+  });
+  const queue = useTurnQueue(input.sessionId, {
+    client: input.client,
+    workspaceId: input.workspaceId,
+    enabled: environment.active,
+    events: events.events
+  });
+  const attachments = useNativeFileAttachments({
+    client: input.client,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    files: environment.adapters.files,
+    crypto: environment.adapters.crypto
+  });
+  const composer = useComposer(input.sessionId, {
+    client: input.client,
+    workspaceId: input.workspaceId,
+    events: events.events,
+    effectiveControl: queue.effectiveControl,
+    // As on web: while a turn runs or prompts wait, a Send shows in the queue
+    // at once instead of flashing as a chat bubble before it is queued.
+    sendDestination: () => (session.session?.activeTurnId ?? null) !== null || queue.queue.length > 0 ? "queue" : "chat",
+    sendExtras: () => ({ resources: attachments.readyResources }),
+    sendBlocked: () => attachments.hasUnresolved,
+    onSent: () => attachments.clear()
+  });
+  const control = useSessionControl(input.sessionId, {
+    client: input.client,
+    workspaceId: input.workspaceId
+  });
+  const humanInput = useHumanInputRequests(input.sessionId, {
+    client: input.client,
+    workspaceId: input.workspaceId,
+    enabled: environment.active,
+    events: events.events
+  });
+  const goal = useGoal(input.sessionId, {
+    client: input.client,
+    workspaceId: input.workspaceId,
+    enabled: environment.active,
+    events: events.events
+  });
+  const lineage = useSessionLineage(input.sessionId, {
+    client: input.client,
+    workspaceId: input.workspaceId,
+    enabled: environment.active,
+    events: events.events,
+    pollIntervalMs: 3e4
+  });
+  const approvals = useMemo(() => projectPendingApprovals(events.events), [events.events]);
+  const timelineGroups = useMemo(() => groupTimeline(events.timeline), [events.timeline]);
+  useNativeReadAcknowledgement({
+    client: input.client,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    session: session.session ?? null,
+    events: events.events,
+    active: environment.active
+  });
+  const mcpApprovalPolicy = useSessionMcpApprovalPolicy(
+    input.sessionId,
+    input.mcpApprovalPolicyServerId,
+    {
+      client: input.client,
+      workspaceId: input.workspaceId,
+      events: events.events,
+      enabled: environment.active && Boolean(input.mcpApprovalPolicyServerId)
+    }
+  );
+  const refresh = useCallback(async () => {
+    await Promise.all([
+      session.refresh(),
+      queue.refresh(),
+      humanInput.refresh(),
+      events.jumpToLatest(),
+      mcpApprovalPolicy.refresh()
+    ]);
+  }, [events, humanInput, mcpApprovalPolicy, queue, session]);
+  return {
+    sessionId: input.sessionId,
+    workspaceId: input.workspaceId,
+    session,
+    events: events.events,
+    timeline: events.timeline,
+    timelineGroups,
+    connectionState: events.connectionState,
+    sessionStatus: events.sessionStatus ?? session.session?.status ?? null,
+    initialLoading: events.initialLoading || session.loading,
+    hasOlder: events.hasOlder,
+    loadingOlder: events.loadingOlder,
+    loadOlder: events.loadOlder,
+    queue,
+    composer,
+    attachments,
+    approvals,
+    control,
+    humanInput,
+    mcpApprovalPolicy,
+    goal,
+    lineage,
+    active: environment.active,
+    runActive: sessionRunActive(events.sessionStatus ?? session.session?.status ?? null),
+    error: events.error ?? session.error ?? queue.error ?? queue.mutationError ?? composer.error ?? composer.draftConflict ?? control.error ?? humanInput.error ?? humanInput.mutationError ?? mcpApprovalPolicy.error,
+    refresh
+  };
+}
+
+// src/presentation.ts
+var DEFAULT_OPENGENI_NATIVE_LABELS = {
+  knowledgeOutcome: {
+    published: "Knowledge published",
+    pending: "Knowledge awaiting review",
+    rejected: "Knowledge rejected",
+    archived: "Knowledge archived",
+    failed: "Knowledge could not be saved"
+  },
+  emptyTitle: "Start a conversation",
+  emptyDescription: "Ask the agent to help with work in this session.",
+  loadEarlier: "Load earlier activity",
+  loadingEarlier: "Loading earlier activity\u2026",
+  reconnecting: "Reconnecting\u2026",
+  connecting: "Connecting\u2026",
+  offlinePaused: "Live updates pause while the app is in the background.",
+  error: "Something went wrong. Try again.",
+  retry: "Retry",
+  dismiss: "Dismiss",
+  queueTitle: "Queued prompts",
+  queueEmpty: "No queued prompts",
+  edit: "Edit",
+  runNext: "Run next",
+  remove: "Remove",
+  moveEarlier: "Move earlier",
+  moveLater: "Move later",
+  approvalsTitle: "Approval required",
+  approve: "Approve",
+  deny: "Deny",
+  questionsTitle: "Your input is needed",
+  humanInputAsked: "Agent asked",
+  humanInputOutcome: {
+    answered: "You answered",
+    skipped: "Skipped",
+    expired: "Expired",
+    cancelled: "Cancelled"
+  },
+  submitAnswers: "Submit answers",
+  skip: "Skip",
+  other: "Other",
+  required: "Required",
+  attachDocument: "Attach document",
+  attachImage: "Attach image",
+  preparingAttachment: "Preparing\u2026",
+  uploading: "Uploading\u2026",
+  uploadFailed: "Upload failed",
+  attachmentError: "Could not open the file picker.",
+  removeAttachment: "Remove attachment",
+  retryUpload: "Retry upload",
+  restoredAttachment: "Attached file",
+  composerPlaceholder: "Message the agent\u2026",
+  send: "Send",
+  steer: "Steer",
+  pause: "Pause",
+  resume: "Resume",
+  savingDraft: "Saving draft\u2026",
+  draftConflict: "This draft changed elsewhere.",
+  keepMine: "Keep mine",
+  useRemote: "Use saved draft",
+  thinking: "Thinking",
+  thought: "Thought",
+  reasoning: "Reasoning",
+  tool: "Tool",
+  worker: "Worker",
+  user: "You",
+  assistant: "Assistant",
+  sandbox: "Sandbox",
+  goal: "Goal",
+  goalAction: {
+    set: "Goal set",
+    updated: "Goal updated",
+    completed: "Goal completed",
+    paused: "Goal paused",
+    resumed: "Goal resumed",
+    cleared: "Goal cleared",
+    held: "Goal held",
+    continuation: "Continuing toward the goal"
+  },
+  contextUpdated: "Context updated",
+  contextCompactionPhase: {
+    started: "Compacting conversation history",
+    compacted: "Conversation history compacted",
+    skipped: "Conversation history compaction skipped"
+  },
+  machineUpdates: "Machine updates: {value}",
+  connectionRequired: "Connection required for {provider}",
+  memory: "Memory",
+  memoryAction: {
+    saved: "Saved to memory",
+    corrected: "Updated memory",
+    updated: "Updated memory in place",
+    archived: "Archived memory"
+  },
+  fleetDecision: "Fleet decision",
+  fleetOutcome: {
+    selected: "Selected {candidate}",
+    waiting: "Waiting for capacity",
+    none: "No candidate selected"
+  },
+  fleetReason: {
+    leaseReused: "Reused the fenced lease",
+    pin: "Kept the session pin",
+    rotation: "Rotated for capacity",
+    active: "Used the active subscription",
+    allCapped: "All observed subscriptions were capped",
+    none: "No production candidate was selected"
+  },
+  turn: "Turn",
+  activity: "Activity",
+  statusQueued: "Queued",
+  statusRunning: "Running",
+  statusComplete: "Complete",
+  statusRecovering: "Recovering",
+  statusWaitingCapacity: "Waiting for capacity",
+  statusIdle: "Idle",
+  statusRequiresAction: "Waiting on you",
+  statusFailed: "Failed",
+  statusCancelled: "Cancelled",
+  relativeNow: "now",
+  relativeSeconds: "{value}s",
+  relativeMinutes: "{value}m",
+  relativeHours: "{value}h",
+  relativeDays: "{value}d"
+};
+var DEFAULT_OPENGENI_NATIVE_THEME = {
+  dark: false,
+  colors: {
+    background: "#f7f7f5",
+    surface: "#ffffff",
+    elevated: "#f0f0ed",
+    border: "#dfdfda",
+    text: "#1b1b19",
+    secondaryText: "#5c5c57",
+    mutedText: "#83837b",
+    accent: "#2563eb",
+    accentForeground: "#ffffff",
+    userBubble: "#1f2937",
+    userBubbleText: "#ffffff",
+    danger: "#b42318",
+    dangerSurface: "#fef3f2",
+    warning: "#b54708",
+    warningSurface: "#fffaeb",
+    success: "#067647"
+  }
+};
+
+// src/view-model.ts
+function nativeKnowledgeOutcomeLabel(item, labels) {
+  return (labels.knowledgeOutcome ?? DEFAULT_OPENGENI_NATIVE_LABELS.knowledgeOutcome)[item.outcome];
+}
+function nativeSessionStatusTone(status) {
+  switch (status) {
+    case "queued":
+    case "running":
+    case "recovering":
+    case "waiting_capacity":
+      return "working";
+    case "requires_action":
+      return "attention";
+    case "failed":
+      return "failed";
+    case "cancelled":
+      return "complete";
+    default:
+      return "neutral";
+  }
+}
+function boundedJson(value, maximum = 1200) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(value, null, 2) ?? "";
+  } catch {
+    serialized = String(value);
+  }
+  return serialized.length <= maximum ? serialized : `${serialized.slice(0, maximum)}\u2026`;
+}
+function plainTextContent(value) {
+  return value.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/^\s{0,3}(?:#{1,6}|>|[-+])\s+/gm, "").replace(/\*\*|__|~~|`/g, "").replace(/(^|\s)[*_](?=\S)/g, "$1").replace(/(?<=\S)[*_](?=\s|$|[.,!?;:])/g, "").trim();
+}
+function normalizedPreview(value, maximum = 140) {
+  const normalized = plainTextContent(value).replace(/\s+/g, " ").trim();
+  if (!normalized) return "";
+  return normalized.length <= maximum ? normalized : `${normalized.slice(0, maximum - 1)}\u2026`;
+}
+function recordPreview(value) {
+  for (const key of ["summary", "message", "title", "name", "status", "text", "query", "cmd"]) {
+    const candidate = Reflect.get(value, key);
+    if (typeof candidate === "string") {
+      const preview = normalizedPreview(candidate);
+      if (preview) return preview;
+    }
+  }
+  const keys = Object.keys(value);
+  return keys.length > 0 ? keys.slice(0, 4).join(", ") : "";
+}
+function inspectableValuePreview(value) {
+  if (typeof value === "string") return normalizedPreview(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return value.length === 1 ? "1 item" : `${value.length} items`;
+  if (value && typeof value === "object") return recordPreview(value);
+  return "";
+}
+function nativeToolDisplayName(name) {
+  const boundary = name.indexOf("__");
+  const leaf = boundary >= 0 ? name.slice(boundary + 2) : name;
+  const phrase = leaf.replace(/[_-]+/g, " ").trim();
+  return phrase ? phrase.charAt(0).toLocaleUpperCase() + phrase.slice(1) : name;
+}
+function activityStatus(item, labels) {
+  const fallbackStatus = nativeTimelineStatusLabel(item.status, labels);
+  return {
+    status: item.status === "complete" ? null : fallbackStatus,
+    fallbackStatus,
+    expandedByDefault: item.status === "failed",
+    tone: item.status === "running" ? "running" : item.status === "failed" ? "failed" : "neutral"
+  };
+}
+function nativeActivityPresentation(item, labels) {
+  switch (item.kind) {
+    case "agent-message":
+      return {
+        title: labels.assistant,
+        preview: normalizedPreview(item.text),
+        status: item.streaming ? labels.statusRunning : null,
+        detail: plainTextContent(item.text) || null,
+        expandedByDefault: false,
+        tone: item.streaming ? "running" : "neutral"
+      };
+    case "reasoning":
+      return {
+        title: item.streaming ? labels.thinking : labels.thought,
+        preview: normalizedPreview(item.text),
+        status: item.streaming ? labels.statusRunning : null,
+        detail: plainTextContent(item.text) || null,
+        expandedByDefault: false,
+        tone: item.streaming ? "running" : "neutral"
+      };
+    case "tool-call": {
+      const outputPreview = inspectableValuePreview(item.output);
+      const argumentPreview = inspectableValuePreview(item.arguments);
+      const status = activityStatus(item, labels);
+      return {
+        title: nativeToolDisplayName(item.name),
+        preview: outputPreview || argumentPreview || status.fallbackStatus,
+        detail: boundedJson({
+          input: item.arguments,
+          ...item.output !== void 0 ? { result: item.output } : {},
+          ...item.truncation ? { truncation: item.truncation } : {}
+        }),
+        status: status.status,
+        expandedByDefault: status.expandedByDefault,
+        tone: status.tone
+      };
+    }
+    case "worker": {
+      const status = activityStatus(item, labels);
+      return {
+        title: labels.worker,
+        preview: normalizedPreview(item.prompt ?? item.failure?.message ?? "") || status.fallbackStatus,
+        detail: item.failure ? boundedJson(item.failure) : item.prompt?.trim() || item.workerSessionId || null,
+        status: status.status,
+        expandedByDefault: status.expandedByDefault,
+        tone: status.tone
+      };
+    }
+    case "sandbox": {
+      const status = activityStatus(item, labels);
+      return {
+        title: nativeToolDisplayName(item.name || labels.sandbox),
+        preview: inspectableValuePreview(item.output) || inspectableValuePreview(item.command) || status.fallbackStatus,
+        detail: boundedJson({
+          ...item.command ? { command: item.command } : {},
+          ...item.output ? { output: item.output } : {},
+          ...item.origin ? { origin: item.origin } : {}
+        }),
+        status: status.status,
+        expandedByDefault: status.expandedByDefault,
+        tone: status.tone
+      };
+    }
+    case "startup-phase": {
+      const status = activityStatus(item, labels);
+      return {
+        title: nativeToolDisplayName(item.phase),
+        preview: item.outcome ? nativeToolDisplayName(item.outcome) : status.fallbackStatus,
+        detail: item.durationMs == null ? null : `${Math.max(0, Math.round(item.durationMs / 100) / 10)}s`,
+        status: status.status,
+        expandedByDefault: status.expandedByDefault,
+        tone: status.tone
+      };
+    }
+    case "knowledge":
+      return {
+        title: nativeKnowledgeOutcomeLabel(item, labels),
+        preview: item.filename ?? "",
+        status: null,
+        detail: item.filename ?? null,
+        expandedByDefault: false,
+        tone: item.status === "failed" ? "failed" : "neutral"
+      };
+    case "memory":
+      return {
+        title: nativeMemoryActionLabel(item, labels),
+        preview: normalizedPreview(item.replacementPreview ?? item.preview),
+        status: null,
+        detail: item.replacementPreview ? boundedJson({ before: item.preview, after: item.replacementPreview }) : item.preview,
+        expandedByDefault: false,
+        tone: "neutral"
+      };
+    case "fleet-decision": {
+      const summary = nativeFleetDecisionSummary(item, labels);
+      return {
+        title: labels.fleetDecision,
+        preview: summary,
+        status: null,
+        detail: boundedJson({
+          outcome: item.actualOutcome,
+          reason: item.actualReason,
+          admission: item.admissionOutcome,
+          candidates: item.candidateCount
+        }),
+        expandedByDefault: false,
+        tone: item.actualOutcome === "waiting" ? "running" : "neutral"
+      };
+    }
+  }
+}
+function formatLabel(template, values) {
+  return Object.entries(values).reduce(
+    (formatted, [key, value]) => formatted.split(`{${key}}`).join(String(value)),
+    template
+  );
+}
+function formatNativeRelativeTime(iso, labels, now = /* @__PURE__ */ new Date()) {
+  const then = new Date(iso).getTime();
+  if (Number.isNaN(then)) return "";
+  const seconds = Math.max(0, Math.floor((now.getTime() - then) / 1e3));
+  if (seconds < 10) return labels.relativeNow;
+  if (seconds < 60) return formatLabel(labels.relativeSeconds, { value: seconds });
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return formatLabel(labels.relativeMinutes, { value: minutes });
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return formatLabel(labels.relativeHours, { value: hours });
+  const days = Math.floor(hours / 24);
+  if (days < 14) return formatLabel(labels.relativeDays, { value: days });
+  return new Date(iso).toLocaleDateString();
+}
+function nativeTimelineStatusLabel(status, labels) {
+  switch (status) {
+    case "running":
+      return labels.statusRunning;
+    case "complete":
+      return labels.statusComplete;
+    case "failed":
+      return labels.statusFailed;
+    case "cancelled":
+      return labels.statusCancelled;
+  }
+}
+function nativeGoalActionLabel(action, labels) {
+  return labels.goalAction[action];
+}
+function nativeHumanInputRequestPreview(requests) {
+  return requests.flatMap(
+    (request) => request.questions.map((question) => question.label?.trim() || question.prompt.trim())
+  ).filter((label) => label.length > 0).join(" \xB7 ");
+}
+function nativeHumanInputSummary(item, labels) {
+  const questions = item.questions.map((question) => question.label ? `${question.label}: ${question.prompt}` : question.prompt).join("\n");
+  const outcome = labels.humanInputOutcome[item.response.outcome];
+  const answers = item.answers.map(
+    (answer) => `${answer.label}: ${answer.values.join(", ") || labels.humanInputOutcome.answered}`
+  ).join("\n");
+  return [questions, answers ? `${outcome}: ${answers}` : outcome].filter(Boolean).join("\n");
+}
+function nativeContextCompactionPhaseLabel(phase, labels) {
+  return labels.contextCompactionPhase[phase];
+}
+function nativeMemoryActionLabel(item, labels) {
+  if (item.variant === "saved") return labels.memoryAction.saved;
+  if (item.replacementPreview) return labels.memoryAction.corrected;
+  return item.action === "updated" ? labels.memoryAction.updated : labels.memoryAction.archived;
+}
+function nativeFleetDecisionSummary(item, labels) {
+  const outcome = item.actualOutcome === "selected" && item.actualCandidateKey ? formatLabel(labels.fleetOutcome.selected, { candidate: item.actualCandidateKey }) : item.actualOutcome === "waiting" ? labels.fleetOutcome.waiting : labels.fleetOutcome.none;
+  const reason = (() => {
+    switch (item.actualReason) {
+      case "lease_reused":
+        return labels.fleetReason.leaseReused;
+      case "pin":
+        return labels.fleetReason.pin;
+      case "rotation":
+        return labels.fleetReason.rotation;
+      case "active":
+        return labels.fleetReason.active;
+      case "all_capped":
+        return labels.fleetReason.allCapped;
+      case "none":
+        return labels.fleetReason.none;
+    }
+  })();
+  return `${outcome} \xB7 ${reason}`;
+}
+function timelineAccessibilityLabel(item, labels) {
+  switch (item.kind) {
+    case "user-message":
+      return `${labels.user}: ${item.text}`;
+    case "human-input":
+      return `${labels.humanInputAsked}: ${nativeHumanInputSummary(item, labels)}`;
+    case "agent-message":
+      return `${labels.assistant}: ${item.text}`;
+    case "reasoning":
+      return `${labels.reasoning}: ${item.text}`;
+    case "tool-call":
+      return `${labels.tool} ${item.name}, ${nativeTimelineStatusLabel(item.status, labels)}`;
+    case "worker":
+      return `${labels.worker}, ${nativeTimelineStatusLabel(item.status, labels)}${item.prompt ? `: ${item.prompt}` : ""}`;
+    case "sandbox":
+      return `${labels.sandbox} ${item.name}, ${nativeTimelineStatusLabel(item.status, labels)}`;
+    case "startup-phase":
+      return `${labels.activity}, ${nativeTimelineStatusLabel(item.status, labels)}`;
+    case "session-status":
+      return nativeSessionStatusLabel(item.status, labels);
+    case "goal":
+      return `${nativeGoalActionLabel(item.action, labels)}${item.text ? `: ${item.text}` : ""}`;
+    case "notice":
+      return item.text;
+    case "context-compaction":
+      return nativeContextCompactionPhaseLabel(item.phase, labels);
+    case "machine-input-batch":
+      return formatLabel(labels.machineUpdates, { value: item.members.length });
+    case "auth-needed":
+      return formatLabel(labels.connectionRequired, { provider: item.providerDomain });
+    case "knowledge":
+      return `${nativeKnowledgeOutcomeLabel(item, labels)}${item.filename ? `: ${item.filename}` : ""}`;
+    case "memory":
+      return `${nativeMemoryActionLabel(item, labels)}: ${item.replacementPreview ?? item.preview}`;
+    case "fleet-decision":
+      return `${labels.fleetDecision}: ${nativeFleetDecisionSummary(item, labels)}`;
+    case "turn-end":
+      return `${labels.turn}, ${nativeTimelineStatusLabel(item.outcome, labels)}`;
+    case "worker-completion":
+      return item.text;
+  }
+}
+function nativeSessionStatusLabel(status, labels) {
+  switch (status) {
+    case "queued":
+      return labels.statusQueued;
+    case "running":
+      return labels.statusRunning;
+    case "recovering":
+      return labels.statusRecovering;
+    case "waiting_capacity":
+      return labels.statusWaitingCapacity;
+    case "idle":
+      return labels.statusIdle;
+    case "requires_action":
+      return labels.statusRequiresAction;
+    case "failed":
+      return labels.statusFailed;
+    case "cancelled":
+      return labels.statusCancelled;
+  }
+}
+function validateHumanInputAnswers(questions, drafts) {
+  const answers = [];
+  let valid = true;
+  for (const question of questions) {
+    const draft = drafts[question.id] ?? emptyHumanInputDraft();
+    const values = question.kind === "text" ? draft.values.filter((value) => value.trim().length > 0) : draft.values;
+    const other = draft.otherSelected ? draft.other.trim() : "";
+    const supplied = values.length + (other.length > 0 ? 1 : 0);
+    if (question.kind !== "text" && draft.otherSelected && other.length === 0) valid = false;
+    if (question.required && supplied === 0) valid = false;
+    if (question.kind !== "text") {
+      const minimum = question.validation?.minSelections;
+      const maximum = question.kind === "single_select" ? 1 : question.validation?.maxSelections;
+      if (minimum != null && supplied < minimum) valid = false;
+      if (maximum != null && supplied > maximum) valid = false;
+    }
+    if (supplied > 0) {
+      answers.push({
+        questionId: question.id,
+        values,
+        ...other ? { other } : {}
+      });
+    }
+  }
+  return { answers, valid };
+}
+function emptyHumanInputDraft() {
+  return { values: [], other: "", otherSelected: false };
+}
+var NO_COMPOSER_INSETS = { bottom: 0, left: 0, right: 0 };
+var NO_RESTORED_RESOURCES = [];
+function OpenGeniNativeSessionView({
+  controller,
+  theme = DEFAULT_OPENGENI_NATIVE_THEME,
+  labels: labelOverrides,
+  header,
+  composerAccessory,
+  composerSafeAreaInsets = NO_COMPOSER_INSETS,
+  renderComposer,
+  renderComposerActions,
+  renderComposerSurface,
+  renderTool,
+  renderMessage,
+  summarizeTurn,
+  formatError,
+  keyboardVerticalOffset = 0,
+  testID
+}) {
+  const labels = useMemo(
+    () => ({ ...DEFAULT_OPENGENI_NATIVE_LABELS, ...labelOverrides }),
+    [labelOverrides]
+  );
+  const listRef = useRef(null);
+  const followTail = useRef(true);
+  const humanInputRequests = controller.humanInput.requests;
+  const humanInputRequestKey = humanInputRequests.map((request) => request.id).join("|");
+  const [humanInputOpen, setHumanInputOpen] = useState(true);
+  const humanInputExpanded = humanInputRequests.length > 0 && humanInputOpen;
+  const auxiliarySurfacesVisible = controller.queue.queue.length > 0 || controller.queue.effectiveControl?.state === "paused" && controller.queue.effectiveControl.resumeOptions.length > 1;
+  useEffect(() => {
+    if (humanInputRequestKey) setHumanInputOpen(true);
+  }, [humanInputRequestKey]);
+  const onScroll = useCallback((event) => {
+    const { contentOffset, contentSize, layoutMeasurement } = event.nativeEvent;
+    followTail.current = contentSize.height - (contentOffset.y + layoutMeasurement.height) < 96;
+  }, []);
+  return /* @__PURE__ */ jsxs(
+    KeyboardAvoidingView,
+    {
+      behavior: Platform.OS === "ios" ? "padding" : void 0,
+      keyboardVerticalOffset,
+      style: [styles.root, { backgroundColor: theme.colors.background }],
+      testID,
+      children: [
+        header,
+        /* @__PURE__ */ jsx(View, { style: styles.body, children: /* @__PURE__ */ jsxs(View, { style: styles.timelineColumn, children: [
+          /* @__PURE__ */ jsxs(View, { style: styles.timelineStage, children: [
+            /* @__PURE__ */ jsx(
+              ConnectionBanner,
+              {
+                controller,
+                formatError,
+                labels,
+                theme
+              }
+            ),
+            /* @__PURE__ */ jsx(View, { style: humanInputExpanded ? styles.timelineHidden : styles.timeline, children: /* @__PURE__ */ jsx(
+              FlatList,
+              {
+                contentContainerStyle: [
+                  styles.timelineContent,
+                  renderComposer ? styles.timelineContentNativeComposer : null,
+                  controller.timelineGroups.length === 0 && styles.emptyTimeline
+                ],
+                data: controller.timelineGroups,
+                keyboardDismissMode: "interactive",
+                keyboardShouldPersistTaps: "handled",
+                keyExtractor: timelineGroupKey,
+                ListHeaderComponent: controller.hasOlder ? /* @__PURE__ */ jsx(
+                  ActionButton,
+                  {
+                    label: controller.loadingOlder ? labels.loadingEarlier : labels.loadEarlier,
+                    onPress: () => void controller.loadOlder(),
+                    theme,
+                    disabled: controller.loadingOlder,
+                    variant: "quiet"
+                  }
+                ) : void 0,
+                ListEmptyComponent: controller.initialLoading ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.colors.accent }) : /* @__PURE__ */ jsxs(View, { accessible: true, accessibilityRole: "summary", style: styles.emptyState, children: [
+                  /* @__PURE__ */ jsx(Text, { style: [styles.emptyTitle, { color: theme.colors.text }], children: labels.emptyTitle }),
+                  /* @__PURE__ */ jsx(
+                    Text,
+                    {
+                      style: [styles.emptyDescription, { color: theme.colors.secondaryText }],
+                      children: labels.emptyDescription
+                    }
+                  )
+                ] }),
+                onContentSizeChange: () => {
+                  if (followTail.current) listRef.current?.scrollToEnd({ animated: true });
+                },
+                onScroll,
+                ref: listRef,
+                renderItem: ({ item }) => /* @__PURE__ */ jsx(
+                  TimelineGroupRow,
+                  {
+                    group: item,
+                    labels,
+                    renderMessage,
+                    renderTool,
+                    summarizeTurn,
+                    theme
+                  }
+                ),
+                scrollEventThrottle: 32,
+                style: styles.timeline
+              }
+            ) }),
+            humanInputRequests.length > 0 ? /* @__PURE__ */ jsx(
+              HumanInputWorkspace,
+              {
+                expanded: humanInputOpen,
+                labels,
+                onRespond: (requestId, response) => void controller.humanInput.respond(requestId, response),
+                onToggle: () => setHumanInputOpen((current) => !current),
+                requests: humanInputRequests,
+                respondingRequestId: controller.humanInput.respondingRequestId,
+                theme
+              }
+            ) : null,
+            controller.approvals.length > 0 ? /* @__PURE__ */ jsx(View, { pointerEvents: "box-none", style: styles.approvalOverlay, children: /* @__PURE__ */ jsx(ApprovalSurface, { controller, labels, theme }) }) : null
+          ] }),
+          auxiliarySurfacesVisible ? /* @__PURE__ */ jsx(
+            ScrollView,
+            {
+              contentContainerStyle: styles.sessionSurfacesContent,
+              keyboardShouldPersistTaps: "handled",
+              style: styles.sessionSurfaces,
+              children: /* @__PURE__ */ jsx(SessionSurfaces, { controller, labels, theme })
+            }
+          ) : null,
+          /* @__PURE__ */ jsxs(
+            View,
+            {
+              style: [
+                styles.composerDock,
+                {
+                  backgroundColor: theme.colors.background,
+                  borderTopColor: theme.colors.border,
+                  borderTopWidth: StyleSheet.hairlineWidth,
+                  paddingBottom: Math.max(8, composerSafeAreaInsets.bottom),
+                  paddingLeft: Math.max(12, composerSafeAreaInsets.left + 12),
+                  paddingRight: Math.max(12, composerSafeAreaInsets.right + 12)
+                }
+              ],
+              children: [
+                /* @__PURE__ */ jsx(
+                  OpenGeniNativeAttachmentStrip,
+                  {
+                    attachments: controller.attachments,
+                    labels,
+                    onRemoveRestoredResource: controller.composer.removeRestoredResource,
+                    restoredResources: controller.composer.restoredResources,
+                    theme
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Composer,
+                  {
+                    accessory: composerAccessory,
+                    controller,
+                    labels,
+                    renderActions: renderComposerActions,
+                    renderComposer,
+                    renderSurface: renderComposerSurface,
+                    theme
+                  }
+                )
+              ]
+            }
+          )
+        ] }) })
+      ]
+    }
+  );
+}
+function timelineGroupKey(group) {
+  return group.kind === "item" ? `item-${group.item.id}` : group.id;
+}
+function TimelineGroupRow({
+  group,
+  labels,
+  renderMessage,
+  renderTool,
+  summarizeTurn,
+  theme
+}) {
+  switch (group.kind) {
+    case "item":
+      return /* @__PURE__ */ jsx(
+        TimelineRow,
+        {
+          item: group.item,
+          labels,
+          renderMessage,
+          renderTool,
+          theme
+        }
+      );
+    case "activity":
+      return /* @__PURE__ */ jsx(
+        ActivityRail,
+        {
+          items: group.items,
+          labels,
+          renderMessage,
+          renderTool,
+          theme
+        }
+      );
+    case "turn":
+      return /* @__PURE__ */ jsx(
+        SettledTurn,
+        {
+          group,
+          labels,
+          renderMessage,
+          renderTool,
+          summarizeTurn,
+          theme
+        }
+      );
+  }
+}
+function SettledTurn({
+  group,
+  labels,
+  renderMessage,
+  renderTool,
+  summarizeTurn,
+  theme
+}) {
+  const [open, setOpen] = useState(group.outcome === "failed");
+  const items = useMemo(() => collectTurnActivityItems(group.groups), [group.groups]);
+  const durationMs = turnDurationMs(group.startedAt, group.endedAt);
+  const summary = summarizeTurn?.({
+    items,
+    toolCalls: items.filter((item) => item.kind === "tool-call"),
+    outcome: group.outcome,
+    failureText: group.failureText,
+    durationMs,
+    settled: items.every((item) => !activityItemRunning(item)),
+    contextCompactionCount: group.contextCompactionCount ?? 0
+  }) ?? {
+    content: `${labels.activity} \xB7 ${items.length}`,
+    accessibilityLabel: `${labels.activity}, ${items.length}`
+  };
+  return /* @__PURE__ */ jsxs(View, { style: styles.turnGroup, children: [
+    /* @__PURE__ */ jsxs(
+      Pressable,
+      {
+        accessibilityLabel: summary.accessibilityLabel ?? summary.content,
+        accessibilityRole: "button",
+        accessibilityState: { expanded: open },
+        onPress: () => setOpen((current) => !current),
+        style: ({ pressed }) => [
+          styles.turnSummary,
+          {
+            backgroundColor: group.outcome === "failed" ? theme.colors.dangerSurface : theme.colors.elevated,
+            borderColor: group.outcome === "failed" ? theme.colors.danger : theme.colors.border,
+            opacity: pressed ? 0.72 : 1
+          }
+        ],
+        children: [
+          /* @__PURE__ */ jsx(Text, { style: [styles.turnChevron, { color: theme.colors.mutedText }], children: open ? "\u2304" : "\u203A" }),
+          /* @__PURE__ */ jsx(
+            Text,
+            {
+              accessibilityElementsHidden: true,
+              importantForAccessibility: "no",
+              style: [
+                styles.turnOutcome,
+                {
+                  color: group.outcome === "failed" ? theme.colors.danger : group.outcome === "complete" ? theme.colors.success : theme.colors.mutedText
+                }
+              ],
+              children: group.outcome === "complete" ? "\u2713" : group.outcome === "failed" ? "!" : "\u2013"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Text,
+            {
+              numberOfLines: 1,
+              style: [
+                styles.turnSummaryText,
+                {
+                  color: group.outcome === "failed" ? theme.colors.danger : theme.colors.secondaryText
+                }
+              ],
+              children: summary.content
+            }
+          ),
+          summary.duration ? /* @__PURE__ */ jsx(Text, { style: [styles.turnDuration, { color: theme.colors.mutedText }], children: summary.duration }) : null
+        ]
+      }
+    ),
+    open ? /* @__PURE__ */ jsxs(View, { style: [styles.turnRail, { borderLeftColor: theme.colors.border }], children: [
+      group.groups.map((child) => /* @__PURE__ */ jsx(
+        TimelineGroupRow,
+        {
+          group: child,
+          labels,
+          renderMessage,
+          renderTool,
+          summarizeTurn,
+          theme
+        },
+        timelineGroupKey(child)
+      )),
+      group.failureText ? /* @__PURE__ */ jsx(Text, { style: [styles.secondaryText, { color: theme.colors.danger }], children: group.failureText }) : null
+    ] }) : null
+  ] });
+}
+function collectTurnActivityItems(groups) {
+  return groups.flatMap((group) => {
+    switch (group.kind) {
+      case "activity":
+        return group.items;
+      case "turn":
+        return collectTurnActivityItems(group.groups);
+      case "item":
+        return isActivityItem(group.item) ? [group.item] : [];
+    }
+  });
+}
+function isActivityItem(item) {
+  return item.kind === "agent-message" && item.phase === "commentary" || item.kind === "reasoning" || item.kind === "tool-call" || item.kind === "worker" || item.kind === "sandbox" || item.kind === "memory" || item.kind === "fleet-decision";
+}
+function activityItemRunning(item) {
+  return (item.kind === "reasoning" || item.kind === "agent-message") && item.streaming || (item.kind === "tool-call" || item.kind === "worker" || item.kind === "sandbox") && item.status === "running";
+}
+function turnDurationMs(startedAt, endedAt) {
+  const start = Date.parse(startedAt);
+  const end = Date.parse(endedAt);
+  return Number.isFinite(start) && Number.isFinite(end) && end >= start ? end - start : void 0;
+}
+function ActivityRail({
+  items,
+  labels,
+  renderMessage,
+  renderTool,
+  theme
+}) {
+  return /* @__PURE__ */ jsx(View, { style: [styles.activityRail, { borderLeftColor: theme.colors.border }], children: items.map((item) => /* @__PURE__ */ jsx(
+    TimelineRow,
+    {
+      compactActivity: true,
+      item,
+      labels,
+      renderMessage,
+      renderTool,
+      theme
+    },
+    item.id
+  )) });
+}
+function ConnectionBanner({
+  controller,
+  formatError,
+  labels,
+  theme
+}) {
+  const message = !controller.active ? labels.offlinePaused : controller.connectionState === "reconnecting" ? labels.reconnecting : controller.connectionState === "connecting" ? labels.connecting : null;
+  const error = controller.error;
+  if (!message && !error) return null;
+  const displayMessage = error ? formatError?.(error) ?? labels.error : message;
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      accessibilityLiveRegion: "polite",
+      style: [
+        styles.banner,
+        {
+          backgroundColor: error ? theme.colors.dangerSurface : theme.colors.elevated
+        }
+      ],
+      children: [
+        /* @__PURE__ */ jsx(
+          Text,
+          {
+            numberOfLines: 3,
+            style: [
+              styles.bannerText,
+              { color: error ? theme.colors.danger : theme.colors.secondaryText }
+            ],
+            children: displayMessage
+          }
+        ),
+        error ? /* @__PURE__ */ jsx(
+          ActionButton,
+          {
+            label: labels.retry,
+            onPress: () => void controller.refresh(),
+            theme,
+            variant: "quiet"
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function TimelineRow({
+  compactActivity = false,
+  item,
+  labels,
+  renderMessage,
+  renderTool,
+  theme
+}) {
+  if (item.kind === "tool-call" && renderTool) {
+    const rendered = renderTool(item, { compact: compactActivity, labels, theme });
+    if (rendered !== null && rendered !== void 0) return /* @__PURE__ */ jsx(Fragment, { children: rendered });
+  }
+  if (item.kind === "user-message" || item.kind === "agent-message") {
+    const user = item.kind === "user-message";
+    const role = user ? "user" : "assistant";
+    return /* @__PURE__ */ jsx(
+      View,
+      {
+        accessible: true,
+        accessibilityLabel: timelineAccessibilityLabel(item, labels),
+        style: [styles.messageRow, user ? styles.userMessageRow : styles.agentMessageRow],
+        children: /* @__PURE__ */ jsxs(
+          View,
+          {
+            style: [
+              styles.messageBubble,
+              user ? styles.userMessageBubble : styles.agentMessage,
+              {
+                backgroundColor: user ? theme.colors.userBubble : "transparent",
+                borderColor: user ? theme.colors.border : "transparent"
+              }
+            ],
+            children: [
+              renderMessage ? renderMessage(item.text, role, { theme }) : /* @__PURE__ */ jsx(
+                Text,
+                {
+                  selectable: true,
+                  style: [
+                    styles.messageText,
+                    { color: user ? theme.colors.userBubbleText : theme.colors.text }
+                  ],
+                  children: item.text
+                }
+              ),
+              item.kind === "agent-message" && item.streaming ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.colors.accent, size: "small" }) : null
+            ]
+          }
+        )
+      }
+    );
+  }
+  if (item.kind === "reasoning") {
+    if (compactActivity) {
+      return /* @__PURE__ */ jsx(
+        ReasoningDisclosure,
+        {
+          item,
+          labels,
+          renderMessage,
+          theme
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(TimelineCard, { item, labels, theme, title: labels.reasoning, children: renderMessage ? renderMessage(item.text, "reasoning", { theme }) : /* @__PURE__ */ jsx(Text, { selectable: true, style: [styles.secondaryText, { color: theme.colors.secondaryText }], children: item.text }) });
+  }
+  if (item.kind === "notice") {
+    return /* @__PURE__ */ jsx(NoticeRow, { item, labels, theme });
+  }
+  if (item.kind === "session-status") {
+    return /* @__PURE__ */ jsx(SessionStatusRow, { item, labels, theme });
+  }
+  if (item.kind === "tool-call") {
+    return /* @__PURE__ */ jsx(
+      NativeActivityDisclosure,
+      {
+        compact: compactActivity,
+        item,
+        labels,
+        theme
+      }
+    );
+  }
+  if (isActivityItem(item)) {
+    return /* @__PURE__ */ jsx(
+      NativeActivityDisclosure,
+      {
+        compact: compactActivity,
+        item,
+        labels,
+        theme
+      }
+    );
+  }
+  const title = timelineTitle(item, labels);
+  const detail = timelineSummary(item, labels);
+  if (compactActivity) {
+    return /* @__PURE__ */ jsxs(
+      View,
+      {
+        accessible: true,
+        accessibilityLabel: timelineAccessibilityLabel(item, labels),
+        style: styles.step,
+        children: [
+          /* @__PURE__ */ jsx(Text, { style: [styles.stepLabel, { color: theme.colors.mutedText }], children: title }),
+          detail ? /* @__PURE__ */ jsx(Text, { selectable: true, style: [styles.secondaryText, { color: theme.colors.secondaryText }], children: detail }) : null
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(TimelineCard, { item, labels, theme, title, children: detail ? /* @__PURE__ */ jsx(Text, { selectable: true, style: [styles.secondaryText, { color: theme.colors.secondaryText }], children: detail }) : null });
+}
+function NativeActivityDisclosure({
+  compact,
+  item,
+  labels,
+  theme
+}) {
+  const presentation = nativeActivityPresentation(item, labels);
+  const [open, setOpen] = useState(presentation.expandedByDefault);
+  const expandable = Boolean(presentation.detail);
+  const foreground = presentation.tone === "failed" ? theme.colors.danger : presentation.tone === "running" ? theme.colors.accent : theme.colors.mutedText;
+  const technical = item.kind === "tool-call" || item.kind === "sandbox";
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: [
+        styles.activityDisclosure,
+        !compact && styles.activityDisclosureCard,
+        !compact && {
+          backgroundColor: theme.colors.surface,
+          borderColor: presentation.tone === "failed" ? theme.colors.danger : theme.colors.border
+        }
+      ],
+      children: [
+        /* @__PURE__ */ jsxs(
+          Pressable,
+          {
+            accessible: true,
+            accessibilityLabel: timelineAccessibilityLabel(item, labels),
+            accessibilityRole: expandable ? "button" : void 0,
+            accessibilityState: expandable ? { expanded: open } : void 0,
+            disabled: !expandable,
+            onPress: () => setOpen((current) => !current),
+            style: ({ pressed }) => [
+              styles.activityDisclosureHeader,
+              { opacity: pressed && expandable ? 0.68 : 1 }
+            ],
+            children: [
+              /* @__PURE__ */ jsx(Text, { style: [styles.activityDisclosureChevron, { color: theme.colors.mutedText }], children: expandable ? open ? "\u2304" : "\u203A" : "\xB7" }),
+              /* @__PURE__ */ jsx(View, { style: [styles.activityStatusDot, { backgroundColor: foreground }] }),
+              /* @__PURE__ */ jsx(
+                Text,
+                {
+                  numberOfLines: 1,
+                  style: [
+                    styles.activityDisclosureTitle,
+                    { color: presentation.tone === "failed" ? theme.colors.danger : theme.colors.text }
+                  ],
+                  children: presentation.title
+                }
+              ),
+              !open && presentation.preview ? /* @__PURE__ */ jsx(
+                Text,
+                {
+                  numberOfLines: 1,
+                  style: [styles.activityDisclosurePreview, { color: theme.colors.mutedText }],
+                  children: presentation.preview
+                }
+              ) : null,
+              presentation.status ? /* @__PURE__ */ jsx(Text, { numberOfLines: 1, style: [styles.activityDisclosureStatus, { color: foreground }], children: presentation.status }) : null
+            ]
+          }
+        ),
+        open && presentation.detail ? /* @__PURE__ */ jsx(View, { style: styles.activityDisclosureBody, children: /* @__PURE__ */ jsx(
+          Text,
+          {
+            selectable: true,
+            style: [
+              technical ? styles.codeText : styles.secondaryText,
+              { color: theme.colors.secondaryText }
+            ],
+            children: presentation.detail
+          }
+        ) }) : null
+      ]
+    }
+  );
+}
+function timelineTitle(item, labels) {
+  switch (item.kind) {
+    case "worker":
+    case "worker-completion":
+      return labels.worker;
+    case "sandbox":
+      return item.name;
+    case "startup-phase":
+      return labels.activity;
+    case "session-status":
+      return nativeSessionStatusLabel(item.status, labels);
+    case "human-input":
+      return labels.humanInputAsked;
+    case "goal":
+      return nativeGoalActionLabel(item.action, labels);
+    case "context-compaction":
+      return nativeContextCompactionPhaseLabel(item.phase, labels);
+    case "memory":
+      return nativeMemoryActionLabel(item, labels);
+    case "knowledge":
+      return nativeKnowledgeOutcomeLabel(item, labels);
+    case "fleet-decision":
+      return labels.fleetDecision;
+    case "turn-end":
+      return labels.turn;
+    case "notice":
+    case "machine-input-batch":
+    case "auth-needed":
+      return labels.activity;
+  }
+}
+function ReasoningDisclosure({
+  item,
+  labels,
+  renderMessage,
+  theme
+}) {
+  const [open, setOpen] = useState(false);
+  const presentation = nativeActivityPresentation(item, labels);
+  const { preview, title } = presentation;
+  return /* @__PURE__ */ jsxs(View, { style: styles.disclosure, children: [
+    /* @__PURE__ */ jsxs(
+      Pressable,
+      {
+        accessibilityLabel: `${title}: ${preview}`,
+        accessibilityRole: "button",
+        accessibilityState: { expanded: open },
+        onPress: () => setOpen((current) => !current),
+        style: ({ pressed }) => [
+          styles.disclosureHeader,
+          { backgroundColor: pressed ? theme.colors.elevated : "transparent" }
+        ],
+        children: [
+          /* @__PURE__ */ jsx(Text, { style: [styles.disclosureChevron, { color: theme.colors.mutedText }], children: open ? "\u2304" : "\u203A" }),
+          /* @__PURE__ */ jsx(Text, { style: [styles.disclosureIcon, { color: theme.colors.mutedText }], children: "\u25CC" }),
+          /* @__PURE__ */ jsx(
+            Text,
+            {
+              numberOfLines: 1,
+              style: [
+                styles.disclosureTitle,
+                {
+                  color: theme.colors.mutedText,
+                  fontStyle: item.streaming ? "normal" : "italic",
+                  fontWeight: item.streaming ? "600" : "400"
+                }
+              ],
+              children: title
+            }
+          ),
+          !open ? /* @__PURE__ */ jsx(
+            Text,
+            {
+              numberOfLines: 1,
+              style: [styles.disclosurePreview, { color: theme.colors.mutedText }],
+              children: preview
+            }
+          ) : null
+        ]
+      }
+    ),
+    open ? /* @__PURE__ */ jsx(View, { style: styles.disclosureBody, children: renderMessage ? renderMessage(item.text, "reasoning", { theme }) : /* @__PURE__ */ jsx(Text, { selectable: true, style: [styles.secondaryText, { color: theme.colors.secondaryText }], children: presentation.detail }) }) : null
+  ] });
+}
+function NoticeRow({
+  item,
+  labels,
+  theme
+}) {
+  const [detailsOpen, setDetailsOpen] = useState(false);
+  const action = item.action;
+  const failed = item.tone === "failed";
+  const waiting = item.tone === "waiting" || item.tone === "input";
+  const foreground = failed ? theme.colors.danger : waiting ? theme.colors.warning : theme.colors.secondaryText;
+  const background = failed ? theme.colors.dangerSurface : waiting ? theme.colors.warningSurface : theme.colors.elevated;
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      accessibilityLiveRegion: "polite",
+      accessible: true,
+      accessibilityLabel: timelineAccessibilityLabel(item, labels),
+      style: [styles.notice, { backgroundColor: background, borderColor: foreground }],
+      children: [
+        /* @__PURE__ */ jsx(Text, { style: [styles.noticeIcon, { color: foreground }], children: "!" }),
+        /* @__PURE__ */ jsxs(View, { style: styles.noticeContent, children: [
+          /* @__PURE__ */ jsx(Text, { selectable: true, style: [styles.secondaryText, { color: foreground }], children: item.text }),
+          item.details ? /* @__PURE__ */ jsxs(View, { style: styles.noticeDetails, children: [
+            /* @__PURE__ */ jsx(
+              Pressable,
+              {
+                accessibilityRole: "button",
+                accessibilityState: { expanded: detailsOpen },
+                onPress: () => setDetailsOpen((current) => !current),
+                children: /* @__PURE__ */ jsxs(Text, { style: [styles.noticeAction, { color: foreground }], children: [
+                  detailsOpen ? "\u2304" : "\u203A",
+                  " ",
+                  item.details.label
+                ] })
+              }
+            ),
+            detailsOpen ? /* @__PURE__ */ jsx(Text, { selectable: true, style: [styles.codeText, { color: foreground }], children: boundedJson(item.details.value) }) : null
+          ] }) : null
+        ] }),
+        action ? /* @__PURE__ */ jsx(
+          Pressable,
+          {
+            accessibilityRole: "link",
+            onPress: () => void Linking.openURL(action.url),
+            style: styles.noticeLink,
+            children: /* @__PURE__ */ jsx(Text, { style: [styles.noticeAction, { color: foreground }], children: action.label })
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function SessionStatusRow({
+  item,
+  labels,
+  theme
+}) {
+  const label = nativeSessionStatusLabel(item.status, labels).toLocaleLowerCase();
+  const dotColor = sessionStatusColor(item.status, theme);
+  const relativeTime = formatNativeRelativeTime(item.occurredAt, labels);
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      accessibilityRole: "text",
+      accessible: true,
+      accessibilityLabel: `${label}${relativeTime ? `, ${relativeTime}` : ""}`,
+      style: styles.sessionStatus,
+      children: [
+        /* @__PURE__ */ jsx(View, { style: [styles.sessionStatusRule, { backgroundColor: theme.colors.border }] }),
+        /* @__PURE__ */ jsxs(View, { style: styles.sessionStatusLabel, children: [
+          /* @__PURE__ */ jsx(View, { style: [styles.sessionStatusDot, { backgroundColor: dotColor }] }),
+          /* @__PURE__ */ jsxs(Text, { style: [styles.sessionStatusText, { color: theme.colors.mutedText }], children: [
+            label,
+            relativeTime ? ` \xB7 ${relativeTime}` : ""
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(View, { style: [styles.sessionStatusRule, { backgroundColor: theme.colors.border }] })
+      ]
+    }
+  );
+}
+function sessionStatusColor(status, theme) {
+  switch (status) {
+    case "failed":
+      return theme.colors.danger;
+    case "requires_action":
+    case "waiting_capacity":
+      return theme.colors.warning;
+    case "idle":
+      return theme.colors.success;
+    case "running":
+    case "recovering":
+      return theme.colors.accent;
+    default:
+      return theme.colors.mutedText;
+  }
+}
+function TimelineCard({
+  children,
+  item,
+  labels,
+  theme,
+  title
+}) {
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      accessible: true,
+      accessibilityLabel: timelineAccessibilityLabel(item, labels),
+      style: [
+        styles.timelineCard,
+        { backgroundColor: theme.colors.surface, borderColor: theme.colors.border }
+      ],
+      children: [
+        /* @__PURE__ */ jsx(Text, { style: [styles.cardTitle, { color: theme.colors.text }], children: title }),
+        children
+      ]
+    }
+  );
+}
+function timelineSummary(item, labels) {
+  switch (item.kind) {
+    case "worker":
+      return item.prompt ?? nativeTimelineStatusLabel(item.status, labels);
+    case "worker-completion":
+      return item.text;
+    case "sandbox":
+      return item.output || item.command || nativeTimelineStatusLabel(item.status, labels);
+    case "startup-phase":
+      return nativeTimelineStatusLabel(item.status, labels);
+    case "session-status":
+      return nativeSessionStatusLabel(item.status, labels);
+    case "human-input":
+      return nativeHumanInputSummary(item, labels);
+    case "goal":
+      return item.text ?? "";
+    case "notice":
+      return item.text;
+    case "context-compaction":
+      return "";
+    case "machine-input-batch":
+      return item.members.map((member) => member.summary).join("\n");
+    case "auth-needed":
+      return item.providerDomain;
+    case "memory":
+      return item.replacementPreview ?? item.preview;
+    case "knowledge":
+      return item.filename ?? "";
+    case "fleet-decision":
+      return nativeFleetDecisionSummary(item, labels);
+    case "turn-end":
+      return item.failureText ?? nativeTimelineStatusLabel(item.outcome, labels);
+  }
+}
+function ApprovalSurface({
+  controller,
+  labels,
+  theme
+}) {
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      pointerEvents: "auto",
+      style: [
+        styles.approvalSurface,
+        { backgroundColor: theme.colors.warningSurface, borderColor: theme.colors.warning }
+      ],
+      children: [
+        /* @__PURE__ */ jsx(Text, { style: [styles.actionTitle, { color: theme.colors.text }], children: labels.approvalsTitle }),
+        controller.approvals.map((approval) => /* @__PURE__ */ jsxs(View, { style: styles.approvalItem, children: [
+          /* @__PURE__ */ jsx(Text, { style: [styles.cardTitle, { color: theme.colors.text }], children: approval.name }),
+          /* @__PURE__ */ jsx(
+            Text,
+            {
+              numberOfLines: 3,
+              selectable: true,
+              style: [styles.codeText, { color: theme.colors.secondaryText }],
+              children: boundedJson(approval.arguments)
+            }
+          ),
+          /* @__PURE__ */ jsxs(View, { style: styles.buttonRow, children: [
+            /* @__PURE__ */ jsx(
+              ActionButton,
+              {
+                label: labels.deny,
+                onPress: () => void controller.control.reject(approval.id),
+                theme,
+                variant: "danger",
+                disabled: controller.control.responding
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              ActionButton,
+              {
+                label: labels.approve,
+                onPress: () => void controller.control.approve(approval.id),
+                theme,
+                disabled: controller.control.responding
+              }
+            )
+          ] })
+        ] }, approval.id))
+      ]
+    }
+  );
+}
+function SessionSurfaces({
+  controller,
+  labels,
+  theme
+}) {
+  return /* @__PURE__ */ jsxs(View, { style: styles.actionSurfaces, children: [
+    controller.queue.effectiveControl?.state === "paused" && controller.queue.effectiveControl.resumeOptions.length > 1 ? /* @__PURE__ */ jsxs(View, { style: styles.actionGroup, children: [
+      /* @__PURE__ */ jsx(Text, { style: [styles.actionTitle, { color: theme.colors.text }], children: labels.resume }),
+      controller.queue.effectiveControl.resumeOptions.filter((option) => option.scope !== "selected").map((option) => /* @__PURE__ */ jsxs(
+        View,
+        {
+          style: [
+            styles.actionCard,
+            {
+              backgroundColor: theme.colors.warningSurface,
+              borderColor: theme.colors.warning
+            }
+          ],
+          children: [
+            /* @__PURE__ */ jsx(Text, { style: [styles.secondaryText, { color: theme.colors.text }], children: option.impactCopy }),
+            /* @__PURE__ */ jsx(
+              ActionButton,
+              {
+                label: labels.resume,
+                onPress: () => void controller.composer.resumeScope(option),
+                theme,
+                disabled: controller.composer.resuming
+              }
+            )
+          ]
+        },
+        `${option.scope}:${option.targetId ?? "current"}`
+      ))
+    ] }) : null,
+    controller.queue.queue.length > 0 ? /* @__PURE__ */ jsx(QueueSurface, { controller, labels, theme }) : null
+  ] });
+}
+function QueueSurface({
+  controller,
+  labels,
+  theme
+}) {
+  const [open, setOpen] = useState(false);
+  const edit = async (turn) => {
+    if (controller.composer.hasDraftContent()) return;
+    const draft = await controller.queue.editTurn(turn.id, {
+      expectedDraftRevision: controller.composer.draftRevision,
+      replaceDraft: true
+    });
+    if (draft) controller.composer.applyDraft(draft);
+  };
+  const move = (index, direction) => {
+    const turn = controller.queue.queue[index];
+    if (!turn) return;
+    const beforeTurnId = direction < 0 ? controller.queue.queue[index - 1]?.id ?? null : controller.queue.queue[index + 2]?.id ?? null;
+    void controller.queue.moveTurn(turn.id, beforeTurnId);
+  };
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: [
+        styles.queueSurface,
+        { backgroundColor: theme.colors.surface, borderColor: theme.colors.border }
+      ],
+      children: [
+        /* @__PURE__ */ jsxs(
+          Pressable,
+          {
+            accessibilityLabel: `${labels.queueTitle}, ${controller.queue.queue.length}`,
+            accessibilityRole: "button",
+            accessibilityState: { expanded: open },
+            onPress: () => setOpen((value) => !value),
+            style: ({ pressed }) => [styles.queueDisclosure, { opacity: pressed ? 0.72 : 1 }],
+            children: [
+              /* @__PURE__ */ jsx(Text, { style: [styles.queueChevron, { color: theme.colors.mutedText }], children: open ? "\u2304" : "\u203A" }),
+              /* @__PURE__ */ jsxs(Text, { numberOfLines: 1, style: [styles.queueTitle, { color: theme.colors.text }], children: [
+                controller.queue.queue.length,
+                " ",
+                labels.queueTitle
+              ] }),
+              !open ? /* @__PURE__ */ jsx(Text, { numberOfLines: 1, style: [styles.queuePreview, { color: theme.colors.mutedText }], children: controller.queue.queue[0]?.prompt }) : null
+            ]
+          }
+        ),
+        open ? controller.queue.queue.map((turn, index) => /* @__PURE__ */ jsxs(View, { style: [styles.queueRow, { borderTopColor: theme.colors.border }], children: [
+          /* @__PURE__ */ jsx(Text, { numberOfLines: 3, style: [styles.queuePrompt, { color: theme.colors.text }], children: turn.prompt }),
+          /* @__PURE__ */ jsxs(View, { style: styles.queueActions, children: [
+            index > 0 ? /* @__PURE__ */ jsx(
+              ActionButton,
+              {
+                compact: true,
+                label: labels.moveEarlier,
+                onPress: () => move(index, -1),
+                theme,
+                variant: "quiet",
+                disabled: controller.queue.mutating
+              }
+            ) : null,
+            index < controller.queue.queue.length - 1 ? /* @__PURE__ */ jsx(
+              ActionButton,
+              {
+                compact: true,
+                label: labels.moveLater,
+                onPress: () => move(index, 1),
+                theme,
+                variant: "quiet",
+                disabled: controller.queue.mutating
+              }
+            ) : null,
+            /* @__PURE__ */ jsx(
+              ActionButton,
+              {
+                compact: true,
+                label: labels.edit,
+                onPress: () => void edit(turn),
+                theme,
+                variant: "quiet",
+                disabled: controller.composer.hasDraftContent() || controller.queue.mutating
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              ActionButton,
+              {
+                compact: true,
+                label: labels.runNext,
+                onPress: () => void controller.queue.steerTurn(turn.id),
+                theme,
+                variant: "quiet",
+                disabled: controller.queue.mutating
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              ActionButton,
+              {
+                compact: true,
+                label: labels.remove,
+                onPress: () => void controller.queue.removeTurn(turn.id),
+                theme,
+                variant: "danger",
+                disabled: controller.queue.mutating
+              }
+            )
+          ] })
+        ] }, turn.id)) : null
+      ]
+    }
+  );
+}
+function HumanInputWorkspace({
+  expanded,
+  labels,
+  onRespond,
+  onToggle,
+  requests,
+  respondingRequestId,
+  theme
+}) {
+  const preview = nativeHumanInputRequestPreview(requests);
+  const identityLabel = preview ? `${labels.questionsTitle}: ${preview}` : labels.questionsTitle;
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: expanded ? styles.humanInputWorkspaceExpanded : styles.humanInputWorkspaceCollapsed,
+      testID: "opengeni-human-input-workspace",
+      children: [
+        /* @__PURE__ */ jsxs(
+          Pressable,
+          {
+            accessibilityLabel: identityLabel,
+            accessibilityRole: "button",
+            accessibilityState: { expanded },
+            onPress: onToggle,
+            style: ({ pressed }) => [
+              styles.humanInputDisclosure,
+              { backgroundColor: pressed ? theme.colors.elevated : "transparent" }
+            ],
+            children: [
+              /* @__PURE__ */ jsx(Text, { style: [styles.disclosureChevron, { color: theme.colors.mutedText }], children: expanded ? "\u2304" : "\u203A" }),
+              /* @__PURE__ */ jsx(
+                Text,
+                {
+                  numberOfLines: 1,
+                  style: [styles.humanInputDisclosureTitle, { color: theme.colors.text }],
+                  children: labels.questionsTitle
+                }
+              ),
+              !expanded && preview ? /* @__PURE__ */ jsx(
+                Text,
+                {
+                  numberOfLines: 1,
+                  style: [styles.disclosurePreview, { color: theme.colors.mutedText }],
+                  children: preview
+                }
+              ) : null
+            ]
+          }
+        ),
+        expanded ? /* @__PURE__ */ jsx(
+          ScrollView,
+          {
+            contentContainerStyle: styles.humanInputWorkspaceBody,
+            keyboardShouldPersistTaps: "handled",
+            style: styles.humanInputWorkspaceScroll,
+            children: requests.map((request) => /* @__PURE__ */ jsx(
+              HumanInputCard,
+              {
+                labels,
+                onRespond: (response) => onRespond(request.id, response),
+                request,
+                responding: respondingRequestId === request.id,
+                theme
+              },
+              request.id
+            ))
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function HumanInputCard({
+  labels,
+  onRespond,
+  request,
+  responding,
+  theme
+}) {
+  const [drafts, setDrafts] = useState({});
+  const projection = validateHumanInputAnswers(request.questions, drafts);
+  const update = (questionId, updater) => {
+    setDrafts((current) => ({
+      ...current,
+      [questionId]: updater(current[questionId] ?? emptyHumanInputDraft())
+    }));
+  };
+  return /* @__PURE__ */ jsx(View, { style: styles.actionGroup, children: /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: [
+        styles.actionCard,
+        { backgroundColor: theme.colors.surface, borderColor: theme.colors.border }
+      ],
+      children: [
+        request.questions.map((question) => /* @__PURE__ */ jsx(
+          QuestionField,
+          {
+            draft: drafts[question.id],
+            labels,
+            onChange: (next) => update(question.id, () => next),
+            question,
+            theme
+          },
+          question.id
+        )),
+        /* @__PURE__ */ jsxs(View, { style: styles.buttonRow, children: [
+          request.allowSkip ? /* @__PURE__ */ jsx(
+            ActionButton,
+            {
+              label: labels.skip,
+              onPress: () => onRespond({ outcome: "skipped" }),
+              theme,
+              variant: "quiet",
+              disabled: responding
+            }
+          ) : null,
+          /* @__PURE__ */ jsx(
+            ActionButton,
+            {
+              label: labels.submitAnswers,
+              onPress: () => onRespond({ outcome: "answered", answers: projection.answers }),
+              theme,
+              disabled: !projection.valid || responding
+            }
+          )
+        ] })
+      ]
+    }
+  ) });
+}
+function QuestionField({
+  draft,
+  labels,
+  onChange,
+  question,
+  theme
+}) {
+  const current = draft ?? emptyHumanInputDraft();
+  const values = current.values;
+  const toggle = (id) => {
+    const next = question.kind === "single_select" ? [id] : values.includes(id) ? values.filter((value) => value !== id) : [...values, id];
+    onChange({
+      ...current,
+      values: next,
+      ...question.kind === "single_select" ? { otherSelected: false } : {}
+    });
+  };
+  return /* @__PURE__ */ jsxs(View, { style: styles.question, children: [
+    /* @__PURE__ */ jsxs(Text, { style: [styles.cardTitle, { color: theme.colors.text }], children: [
+      question.label ?? question.prompt,
+      question.required ? ` \xB7 ${labels.required}` : ""
+    ] }),
+    question.label ? /* @__PURE__ */ jsx(Text, { style: [styles.secondaryText, { color: theme.colors.secondaryText }], children: question.prompt }) : null,
+    question.helpText ? /* @__PURE__ */ jsx(Text, { style: [styles.helpText, { color: theme.colors.mutedText }], children: question.helpText }) : null,
+    question.kind === "text" ? /* @__PURE__ */ jsx(
+      TextInput,
+      {
+        accessibilityLabel: question.label ?? question.prompt,
+        multiline: true,
+        onChangeText: (text) => onChange({ ...current, values: text ? [text] : [] }),
+        style: [
+          styles.questionInput,
+          {
+            backgroundColor: theme.colors.background,
+            borderColor: theme.colors.border,
+            color: theme.colors.text
+          }
+        ],
+        value: values[0] ?? ""
+      }
+    ) : /* @__PURE__ */ jsx(View, { style: styles.optionList, children: question.options.map((option) => {
+      const selected = values.includes(option.id);
+      return /* @__PURE__ */ jsxs(
+        Pressable,
+        {
+          accessibilityRole: question.kind === "single_select" ? "radio" : "checkbox",
+          accessibilityState: { checked: selected },
+          onPress: () => toggle(option.id),
+          style: [
+            styles.option,
+            {
+              backgroundColor: selected ? theme.colors.elevated : theme.colors.background,
+              borderColor: selected ? theme.colors.accent : theme.colors.border
+            }
+          ],
+          children: [
+            /* @__PURE__ */ jsx(Text, { style: [styles.optionLabel, { color: theme.colors.text }], children: option.label }),
+            option.description ? /* @__PURE__ */ jsx(Text, { style: [styles.helpText, { color: theme.colors.secondaryText }], children: option.description }) : null
+          ]
+        },
+        option.id
+      );
+    }) }),
+    question.kind !== "text" && question.allowOther ? /* @__PURE__ */ jsxs(
+      View,
+      {
+        style: [
+          styles.option,
+          {
+            backgroundColor: current.otherSelected ? theme.colors.elevated : theme.colors.background,
+            borderColor: current.otherSelected ? theme.colors.accent : theme.colors.border
+          }
+        ],
+        children: [
+          /* @__PURE__ */ jsx(
+            Pressable,
+            {
+              accessibilityRole: question.kind === "single_select" ? "radio" : "checkbox",
+              accessibilityState: { checked: current.otherSelected },
+              onPress: () => onChange({
+                ...current,
+                otherSelected: !current.otherSelected,
+                ...question.kind === "single_select" && !current.otherSelected ? { values: [] } : {}
+              }),
+              style: styles.otherOptionToggle,
+              children: /* @__PURE__ */ jsx(Text, { style: [styles.optionLabel, { color: theme.colors.text }], children: labels.other })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            TextInput,
+            {
+              accessibilityLabel: labels.other,
+              editable: current.otherSelected,
+              onChangeText: (other) => onChange({ ...current, other }),
+              placeholder: labels.other,
+              placeholderTextColor: theme.colors.mutedText,
+              style: [
+                styles.otherInput,
+                {
+                  backgroundColor: theme.colors.background,
+                  borderColor: theme.colors.border,
+                  color: theme.colors.text,
+                  opacity: current.otherSelected ? 1 : 0.5
+                }
+              ],
+              value: current.other
+            }
+          )
+        ]
+      }
+    ) : null
+  ] });
+}
+function OpenGeniNativeAttachmentStrip({
+  attachments,
+  labels,
+  onRemoveRestoredResource,
+  restoredResources = NO_RESTORED_RESOURCES,
+  theme
+}) {
+  const error = attachments.error;
+  if (attachments.attachments.length === 0 && restoredResources.length === 0 && !error) return null;
+  return /* @__PURE__ */ jsxs(
+    ScrollView,
+    {
+      contentContainerStyle: styles.attachmentStrip,
+      horizontal: true,
+      keyboardShouldPersistTaps: "handled",
+      showsHorizontalScrollIndicator: false,
+      children: [
+        error ? /* @__PURE__ */ jsxs(
+          View,
+          {
+            style: [
+              styles.attachmentChip,
+              { backgroundColor: theme.colors.dangerSurface, borderColor: theme.colors.danger }
+            ],
+            children: [
+              /* @__PURE__ */ jsx(Text, { style: [styles.attachmentName, { color: theme.colors.danger }], children: labels.attachmentError }),
+              /* @__PURE__ */ jsx(
+                ActionButton,
+                {
+                  label: labels.dismiss,
+                  onPress: () => attachments.clearError(),
+                  theme,
+                  variant: "quiet"
+                }
+              )
+            ]
+          }
+        ) : null,
+        attachments.attachments.map((attachment) => /* @__PURE__ */ jsxs(
+          View,
+          {
+            style: [
+              styles.attachmentChip,
+              { backgroundColor: theme.colors.elevated, borderColor: theme.colors.border }
+            ],
+            children: [
+              /* @__PURE__ */ jsx(Text, { numberOfLines: 1, style: [styles.attachmentName, { color: theme.colors.text }], children: attachment.name }),
+              /* @__PURE__ */ jsx(
+                Text,
+                {
+                  style: [
+                    styles.helpText,
+                    {
+                      color: attachment.status === "failed" ? theme.colors.danger : theme.colors.mutedText
+                    }
+                  ],
+                  children: attachment.status === "preparing" ? labels.preparingAttachment : attachment.status === "uploading" ? labels.uploading : attachment.status === "failed" ? labels.uploadFailed : formatBytes(attachment.sizeBytes)
+                }
+              ),
+              /* @__PURE__ */ jsxs(View, { style: styles.buttonRow, children: [
+                attachment.status === "failed" ? /* @__PURE__ */ jsx(
+                  ActionButton,
+                  {
+                    label: labels.retryUpload,
+                    onPress: () => void attachments.retry(attachment.id),
+                    theme,
+                    variant: "quiet"
+                  }
+                ) : null,
+                /* @__PURE__ */ jsx(
+                  ActionButton,
+                  {
+                    label: labels.removeAttachment,
+                    onPress: () => attachments.remove(attachment.id),
+                    theme,
+                    variant: "quiet"
+                  }
+                )
+              ] })
+            ]
+          },
+          attachment.id
+        )),
+        restoredResources.map((_resource, index) => /* @__PURE__ */ jsxs(
+          View,
+          {
+            style: [
+              styles.attachmentChip,
+              { backgroundColor: theme.colors.elevated, borderColor: theme.colors.border }
+            ],
+            children: [
+              /* @__PURE__ */ jsx(Text, { style: [styles.attachmentName, { color: theme.colors.text }], children: labels.restoredAttachment }),
+              /* @__PURE__ */ jsx(
+                ActionButton,
+                {
+                  label: labels.removeAttachment,
+                  onPress: () => onRemoveRestoredResource?.(index),
+                  theme,
+                  variant: "quiet",
+                  disabled: !onRemoveRestoredResource
+                }
+              )
+            ]
+          },
+          `restored-${index}`
+        ))
+      ]
+    }
+  );
+}
+function Composer({
+  accessory,
+  controller,
+  labels,
+  renderActions,
+  renderComposer,
+  renderSurface,
+  theme
+}) {
+  const paused = controller.queue.effectiveControl?.state === "paused";
+  const busy = controller.composer.sending || controller.composer.pausing || controller.composer.resuming;
+  const actionContext = {
+    accessory,
+    labels,
+    theme,
+    busy,
+    paused,
+    runActive: controller.runActive,
+    canSubmit: controller.composer.canSend && !busy,
+    draftSaving: controller.composer.draftSaving,
+    submitLabel: labels.send,
+    onAttachDocument: () => void controller.attachments.pickDocuments(),
+    onAttachImage: () => void controller.attachments.pickImages(),
+    onTogglePause: () => void (paused ? controller.composer.resume() : controller.composer.pause()),
+    onSubmit: () => void controller.composer.send()
+  };
+  const composerContext = {
+    ...actionContext,
+    value: controller.composer.value,
+    onChangeText: controller.composer.setValue,
+    placeholder: labels.composerPlaceholder
+  };
+  const content = /* @__PURE__ */ jsxs(Fragment, { children: [
+    controller.composer.draftConflict ? /* @__PURE__ */ jsxs(View, { style: [styles.draftConflict, { backgroundColor: theme.colors.warningSurface }], children: [
+      /* @__PURE__ */ jsx(Text, { style: [styles.secondaryText, { color: theme.colors.warning }], children: labels.draftConflict }),
+      /* @__PURE__ */ jsxs(View, { style: styles.buttonRow, children: [
+        /* @__PURE__ */ jsx(
+          ActionButton,
+          {
+            label: labels.useRemote,
+            onPress: () => void controller.composer.resolveDraftConflict("use_remote"),
+            theme,
+            variant: "quiet"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          ActionButton,
+          {
+            label: labels.keepMine,
+            onPress: () => void controller.composer.resolveDraftConflict("keep_mine"),
+            theme,
+            variant: "quiet"
+          }
+        )
+      ] })
+    ] }) : null,
+    renderComposer ? renderComposer(composerContext) : /* @__PURE__ */ jsxs(View, { style: renderActions ? styles.composerRow : styles.composerStack, children: [
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          accessibilityLabel: labels.composerPlaceholder,
+          blurOnSubmit: false,
+          multiline: true,
+          onChangeText: controller.composer.setValue,
+          placeholder: labels.composerPlaceholder,
+          placeholderTextColor: theme.colors.mutedText,
+          style: [styles.composerInput, { color: theme.colors.text }],
+          value: controller.composer.value
+        }
+      ),
+      renderActions ? renderActions(actionContext) : /* @__PURE__ */ jsx(DefaultComposerActions, { ...actionContext })
+    ] })
+  ] });
+  if (renderComposer) {
+    return /* @__PURE__ */ jsx(Fragment, { children: content });
+  }
+  if (renderSurface) {
+    return renderSurface({ children: content, style: styles.composerContainer });
+  }
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      style: [
+        styles.composerContainer,
+        { backgroundColor: theme.colors.surface, borderColor: theme.colors.border }
+      ],
+      children: content
+    }
+  );
+}
+function DefaultComposerActions(context) {
+  return /* @__PURE__ */ jsxs(View, { style: styles.composerToolbar, children: [
+    /* @__PURE__ */ jsxs(View, { style: styles.buttonWrap, children: [
+      /* @__PURE__ */ jsx(
+        ActionButton,
+        {
+          accessibilityLabel: context.labels.attachDocument,
+          label: "\uFF0B",
+          onPress: () => context.onAttachDocument(),
+          theme: context.theme,
+          variant: "quiet",
+          disabled: context.busy
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        ActionButton,
+        {
+          accessibilityLabel: context.labels.attachImage,
+          label: "\u25A7",
+          onPress: () => context.onAttachImage(),
+          theme: context.theme,
+          variant: "quiet",
+          disabled: context.busy
+        }
+      ),
+      context.accessory
+    ] }),
+    /* @__PURE__ */ jsxs(View, { style: styles.buttonWrap, children: [
+      /* @__PURE__ */ jsx(
+        ActionButton,
+        {
+          label: context.paused ? context.labels.resume : context.labels.pause,
+          onPress: () => context.onTogglePause(),
+          theme: context.theme,
+          variant: "quiet",
+          disabled: context.busy
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        ActionButton,
+        {
+          label: context.submitLabel,
+          onPress: () => context.onSubmit(),
+          theme: context.theme,
+          disabled: !context.canSubmit
+        }
+      )
+    ] })
+  ] });
+}
+function ActionButton({
+  accessibilityLabel,
+  compact = false,
+  disabled = false,
+  label,
+  onPress,
+  theme,
+  variant = "primary"
+}) {
+  const colors = variant === "primary" ? {
+    background: theme.colors.accent,
+    foreground: theme.colors.accentForeground,
+    border: theme.colors.accent
+  } : variant === "danger" ? {
+    background: "transparent",
+    foreground: theme.colors.danger,
+    border: theme.colors.danger
+  } : {
+    background: "transparent",
+    foreground: theme.colors.secondaryText,
+    border: theme.colors.border
+  };
+  return /* @__PURE__ */ jsx(
+    Pressable,
+    {
+      accessibilityLabel: accessibilityLabel ?? label,
+      accessibilityRole: "button",
+      accessibilityState: { disabled },
+      disabled,
+      onPress,
+      style: ({ pressed }) => [
+        styles.button,
+        compact && styles.compactButton,
+        {
+          backgroundColor: colors.background,
+          borderColor: colors.border,
+          opacity: disabled ? 0.42 : pressed ? 0.72 : 1
+        }
+      ],
+      children: /* @__PURE__ */ jsx(
+        Text,
+        {
+          style: [
+            styles.buttonText,
+            compact && styles.compactButtonText,
+            { color: colors.foreground }
+          ],
+          children: label
+        }
+      )
+    }
+  );
+}
+function formatBytes(value) {
+  if (value === null) return "";
+  if (value < 1024) return `${value} B`;
+  if (value < 1024 * 1024) return `${Math.round(value / 1024)} KB`;
+  return `${(value / (1024 * 1024)).toFixed(1)} MB`;
+}
+var styles = StyleSheet.create({
+  root: { flex: 1 },
+  body: { flex: 1 },
+  timelineColumn: { flex: 1, minWidth: 0 },
+  timelineStage: { flex: 1, minHeight: 0 },
+  timeline: { flex: 1 },
+  timelineHidden: { flex: 0, height: 0, overflow: "hidden", opacity: 0 },
+  timelineContent: {
+    width: "100%",
+    maxWidth: 820,
+    alignSelf: "center",
+    gap: 12,
+    padding: 16,
+    paddingBottom: 132
+  },
+  timelineContentNativeComposer: {
+    paddingBottom: 16
+  },
+  emptyTimeline: { flexGrow: 1, justifyContent: "center" },
+  emptyState: { alignItems: "center", gap: 8, paddingHorizontal: 32 },
+  emptyTitle: { fontSize: 22, fontWeight: "700", textAlign: "center" },
+  emptyDescription: { fontSize: 15, lineHeight: 22, textAlign: "center" },
+  banner: {
+    minHeight: 44,
+    paddingHorizontal: 16,
+    paddingVertical: 10,
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 12
+  },
+  bannerText: { flex: 1, fontSize: 13, lineHeight: 18 },
+  messageRow: { width: "100%" },
+  userMessageRow: { alignItems: "flex-end" },
+  agentMessageRow: { alignItems: "flex-start" },
+  messageBubble: {
+    gap: 8
+  },
+  userMessageBubble: {
+    maxWidth: "84%",
+    borderRadius: 16,
+    borderWidth: StyleSheet.hairlineWidth,
+    paddingHorizontal: 14,
+    paddingVertical: 11
+  },
+  agentMessage: {
+    width: "100%",
+    paddingHorizontal: 4,
+    paddingVertical: 5
+  },
+  messageText: { fontSize: 16, lineHeight: 23 },
+  timelineCard: { borderRadius: 14, borderWidth: StyleSheet.hairlineWidth, padding: 12, gap: 7 },
+  activityRail: { borderLeftWidth: 2, gap: 12, paddingLeft: 12 },
+  step: { gap: 4 },
+  stepLabel: { fontSize: 12, fontWeight: "600", lineHeight: 16 },
+  disclosure: { gap: 4 },
+  disclosureHeader: {
+    minHeight: 44,
+    borderRadius: 8,
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 7,
+    paddingHorizontal: 6,
+    paddingVertical: 7
+  },
+  disclosureChevron: { width: 14, fontSize: 18, lineHeight: 20, textAlign: "center" },
+  disclosureIcon: { width: 15, fontSize: 16, lineHeight: 18, textAlign: "center" },
+  disclosureTitle: { flexShrink: 0, fontSize: 14, lineHeight: 19 },
+  disclosurePreview: { minWidth: 0, flex: 1, fontSize: 13, lineHeight: 18 },
+  disclosureBody: { marginLeft: 42, paddingBottom: 6 },
+  activityDisclosure: { gap: 4 },
+  activityDisclosureCard: {
+    borderRadius: 12,
+    borderWidth: StyleSheet.hairlineWidth,
+    paddingHorizontal: 8,
+    paddingVertical: 4
+  },
+  activityDisclosureHeader: {
+    minHeight: 44,
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 7,
+    paddingVertical: 6
+  },
+  activityDisclosureChevron: { width: 14, fontSize: 18, lineHeight: 20, textAlign: "center" },
+  activityStatusDot: { width: 6, height: 6, borderRadius: 999 },
+  activityDisclosureTitle: { minWidth: 0, flexShrink: 1, fontSize: 13, fontWeight: "600" },
+  activityDisclosurePreview: { minWidth: 0, flex: 1, fontSize: 13, lineHeight: 18 },
+  activityDisclosureStatus: { flexShrink: 0, fontSize: 11, fontWeight: "600", lineHeight: 15 },
+  activityDisclosureBody: { marginLeft: 27, paddingBottom: 7, paddingRight: 6 },
+  notice: {
+    borderRadius: 10,
+    borderWidth: StyleSheet.hairlineWidth,
+    flexDirection: "row",
+    alignItems: "flex-start",
+    gap: 10,
+    paddingHorizontal: 13,
+    paddingVertical: 11
+  },
+  noticeIcon: { width: 16, fontSize: 17, fontWeight: "800", lineHeight: 20, textAlign: "center" },
+  noticeContent: { minWidth: 0, flex: 1, gap: 7 },
+  noticeDetails: { gap: 6 },
+  noticeAction: { fontSize: 12, fontWeight: "700", lineHeight: 17 },
+  noticeLink: { minHeight: 44, justifyContent: "center", paddingHorizontal: 2 },
+  sessionStatus: { flexDirection: "row", alignItems: "center", gap: 10 },
+  sessionStatusRule: { height: StyleSheet.hairlineWidth, flex: 1 },
+  sessionStatusLabel: { flexDirection: "row", alignItems: "center", gap: 6 },
+  sessionStatusDot: { width: 5, height: 5, borderRadius: 999 },
+  sessionStatusText: { fontSize: 11, lineHeight: 15 },
+  turnGroup: { gap: 8 },
+  turnSummary: {
+    minHeight: 48,
+    borderRadius: 999,
+    borderWidth: StyleSheet.hairlineWidth,
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 7,
+    paddingHorizontal: 12
+  },
+  turnSummaryText: { flex: 1, fontSize: 13, fontWeight: "600" },
+  turnChevron: { width: 13, fontSize: 19, fontWeight: "500", textAlign: "center" },
+  turnOutcome: { width: 14, fontSize: 13, fontWeight: "800", textAlign: "center" },
+  turnDuration: { fontSize: 12, fontVariant: ["tabular-nums"] },
+  turnRail: { borderLeftWidth: 2, gap: 12, marginLeft: 8, paddingLeft: 12 },
+  cardTitle: { fontSize: 14, fontWeight: "700", lineHeight: 19 },
+  secondaryText: { fontSize: 14, lineHeight: 20 },
+  helpText: { fontSize: 12, lineHeight: 17 },
+  codeText: {
+    fontFamily: Platform.select({ ios: "Menlo", android: "monospace" }),
+    fontSize: 12,
+    lineHeight: 17
+  },
+  approvalOverlay: {
+    position: "absolute",
+    left: 0,
+    right: 0,
+    bottom: 12,
+    alignItems: "center",
+    paddingHorizontal: 16
+  },
+  approvalSurface: {
+    width: "100%",
+    maxWidth: 760,
+    borderRadius: 16,
+    borderWidth: 1,
+    padding: 12,
+    gap: 10,
+    elevation: 8,
+    shadowColor: "#000000",
+    shadowOffset: { width: 0, height: 10 },
+    shadowOpacity: 0.16,
+    shadowRadius: 18
+  },
+  approvalItem: { gap: 8 },
+  sessionSurfaces: { maxHeight: 300 },
+  sessionSurfacesContent: { paddingVertical: 4 },
+  humanInputWorkspaceCollapsed: { flexShrink: 0 },
+  humanInputWorkspaceExpanded: { flex: 1, minHeight: 0 },
+  humanInputDisclosure: {
+    minHeight: 44,
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 7,
+    paddingHorizontal: 12,
+    paddingVertical: 7
+  },
+  humanInputDisclosureTitle: { flexShrink: 0, fontSize: 14, fontWeight: "600", lineHeight: 19 },
+  humanInputWorkspaceScroll: { flex: 1, minHeight: 0 },
+  humanInputWorkspaceBody: { gap: 14, paddingHorizontal: 12, paddingBottom: 16 },
+  actionSurfaces: { gap: 14, paddingHorizontal: 12, paddingVertical: 8 },
+  actionGroup: { gap: 8 },
+  actionTitle: { fontSize: 15, fontWeight: "700" },
+  actionCard: { borderRadius: 14, borderWidth: 1, padding: 12, gap: 10 },
+  queueSurface: {
+    overflow: "hidden",
+    borderRadius: 12,
+    borderWidth: StyleSheet.hairlineWidth
+  },
+  queueDisclosure: {
+    minHeight: 44,
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 8,
+    paddingHorizontal: 12,
+    paddingVertical: 8
+  },
+  queueChevron: { width: 12, fontSize: 18, lineHeight: 20, textAlign: "center" },
+  queueTitle: { flexShrink: 0, fontSize: 13, fontWeight: "600" },
+  queuePreview: { minWidth: 0, flex: 1, fontSize: 13 },
+  queueRow: { borderTopWidth: StyleSheet.hairlineWidth, padding: 12, gap: 9 },
+  queuePrompt: { fontSize: 14, lineHeight: 19 },
+  queueActions: { flexDirection: "row", alignItems: "center", flexWrap: "wrap", gap: 6 },
+  buttonRow: { flexDirection: "row", alignItems: "center", justifyContent: "flex-end", gap: 8 },
+  buttonWrap: { flexDirection: "row", alignItems: "center", flexWrap: "wrap", gap: 6 },
+  button: {
+    minHeight: 48,
+    minWidth: 48,
+    borderRadius: 11,
+    borderWidth: 1,
+    alignItems: "center",
+    justifyContent: "center",
+    paddingHorizontal: 12,
+    paddingVertical: 8
+  },
+  buttonText: { fontSize: 13, fontWeight: "700" },
+  compactButton: {
+    minHeight: 36,
+    minWidth: 0,
+    borderRadius: 9,
+    paddingHorizontal: 10,
+    paddingVertical: 6
+  },
+  compactButtonText: { fontSize: 12 },
+  question: { gap: 8 },
+  questionInput: {
+    minHeight: 48,
+    maxHeight: 144,
+    borderWidth: 1,
+    borderRadius: 11,
+    paddingHorizontal: 12,
+    paddingVertical: 10,
+    fontSize: 15,
+    textAlignVertical: "top"
+  },
+  optionList: { gap: 7 },
+  option: {
+    minHeight: 48,
+    borderWidth: 1,
+    borderRadius: 11,
+    justifyContent: "center",
+    paddingHorizontal: 12,
+    paddingVertical: 9
+  },
+  optionLabel: { fontSize: 14, fontWeight: "600" },
+  otherOptionToggle: { minHeight: 48, justifyContent: "center" },
+  otherInput: {
+    minHeight: 48,
+    borderWidth: 1,
+    borderRadius: 9,
+    marginTop: 7,
+    paddingHorizontal: 10,
+    paddingVertical: 8,
+    fontSize: 14
+  },
+  attachmentStrip: { gap: 8, paddingHorizontal: 12, paddingVertical: 6 },
+  attachmentChip: {
+    width: 180,
+    minHeight: 64,
+    borderWidth: 1,
+    borderRadius: 12,
+    padding: 9,
+    gap: 4
+  },
+  attachmentName: { fontSize: 13, fontWeight: "600" },
+  composerDock: { paddingHorizontal: 12, paddingTop: 5, paddingBottom: 8, gap: 5 },
+  composerContainer: {
+    width: "100%",
+    maxWidth: 820,
+    alignSelf: "center",
+    borderRadius: 28,
+    borderWidth: 1,
+    padding: 5,
+    gap: 4
+  },
+  composerRow: { minHeight: 40, flexDirection: "row", alignItems: "flex-end" },
+  composerStack: { gap: 8 },
+  composerInput: {
+    minWidth: 0,
+    minHeight: 40,
+    maxHeight: 120,
+    flex: 1,
+    paddingHorizontal: 11,
+    paddingVertical: 9,
+    fontSize: 16,
+    lineHeight: 22,
+    textAlignVertical: "top"
+  },
+  composerToolbar: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    gap: 8
+  },
+  draftConflict: { borderRadius: 10, padding: 8, gap: 6 }
+});
+function createMemoryRealtimeOwnerStorage() {
+  const values = /* @__PURE__ */ new Map();
+  return {
+    getItem: (key) => values.get(key) ?? null,
+    setItem: (key, value) => void values.set(key, String(value)),
+    removeItem: (key) => void values.delete(key)
+  };
+}
+function audioTracks(stream) {
+  const candidate = stream;
+  if (!candidate) return [];
+  if (typeof candidate.getAudioTracks === "function") return candidate.getAudioTracks();
+  if (typeof candidate.getTracks === "function")
+    return candidate.getTracks().filter((track) => track.kind === "audio");
+  return [];
+}
+function createNativeRemoteAudio() {
+  let source = null;
+  let muted = false;
+  let paused = true;
+  const apply = () => {
+    const enabled = !muted && !paused;
+    for (const track of audioTracks(source)) track.enabled = enabled;
+  };
+  const element = {
+    autoplay: true,
+    get muted() {
+      return muted;
+    },
+    set muted(value) {
+      muted = Boolean(value);
+      apply();
+    },
+    get srcObject() {
+      return source;
+    },
+    set srcObject(value) {
+      source = value ?? null;
+      if (source === null) paused = true;
+      apply();
+    },
+    get paused() {
+      return paused;
+    },
+    async play() {
+      paused = false;
+      apply();
+    },
+    pause() {
+      paused = true;
+      apply();
+    }
+  };
+  return element;
+}
+function createNativeRealtimeControllerFactory(webrtc, options = {}) {
+  const storage = options.storage ?? createMemoryRealtimeOwnerStorage();
+  return (controllerOptions) => createSessionRealtimeController({
+    ...controllerOptions,
+    storage: controllerOptions.storage ?? storage,
+    remoteAudio: controllerOptions.remoteAudio ?? createNativeRemoteAudio(),
+    createPeerConnection: () => webrtc.createPeerConnection(),
+    getUserMedia: (constraints) => webrtc.getUserMedia(constraints)
+  });
+}
+function useNativeSessionRealtime(options) {
+  const { webrtc, storage, ...realtimeOptions } = options;
+  const controllerFactory = useMemo(
+    () => createNativeRealtimeControllerFactory(webrtc, storage ? { storage } : {}),
+    [webrtc, storage]
+  );
+  return useSessionRealtime({ ...realtimeOptions, controllerFactory });
+}
+function nativeRealtimeModelSupported(model) {
+  const transport = sessionRealtimeTransportKind(model);
+  return transport === "codex" || transport === "azure-live";
+}
+function randomCallId() {
+  const crypto = globalThis.crypto;
+  if (crypto?.randomUUID) return crypto.randomUUID();
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+    const value = Math.floor(Math.random() * 16);
+    return (char === "x" ? value : value & 3 | 8).toString(16);
+  });
+}
+function useNativeRealtimeCall(options) {
+  const { realtime, call } = options;
+  const [callId, setCallId] = useState(null);
+  const [ending, setEnding] = useState(false);
+  const [speaker, setSpeakerState] = useState(false);
+  const [route, setRoute] = useState(null);
+  const [error, setError] = useState(null);
+  const [systemCall, setSystemCall] = useState(false);
+  const callIdRef = useRef(null);
+  const systemCallRef = useRef(null);
+  const connectedRef = useRef(null);
+  const realtimeRef = useRef(realtime);
+  realtimeRef.current = realtime;
+  const status = realtime.snapshot.status;
+  const muted = realtime.snapshot.inputMuted;
+  const finish = useCallback(
+    async (reason) => {
+      const id = callIdRef.current;
+      if (!id) return;
+      const reported = systemCallRef.current === id;
+      callIdRef.current = null;
+      systemCallRef.current = null;
+      connectedRef.current = null;
+      setCallId(null);
+      setEnding(false);
+      setSpeakerState(false);
+      setSystemCall(false);
+      if (reported) await call?.endCall(id, reason).catch(() => void 0);
+    },
+    [call]
+  );
+  useEffect(() => {
+    if (!call) return;
+    return call.subscribe((event) => {
+      if (event.type === "routeChanged") {
+        setRoute(event.route);
+        setSpeakerState(event.route === "speaker");
+        return;
+      }
+      if (event.type === "startRequested" || event.type === "audioSessionActivated" || event.type === "audioSessionDeactivated")
+        return;
+      if (event.callId !== callIdRef.current) return;
+      if (event.type === "ended") {
+        callIdRef.current = null;
+        systemCallRef.current = null;
+        connectedRef.current = null;
+        setCallId(null);
+        setEnding(false);
+        setSystemCall(false);
+        void realtimeRef.current.stop().catch(() => void 0);
+      } else if (event.type === "muteChanged") {
+        realtimeRef.current.setInputMuted(event.muted);
+      }
+    });
+  }, [call]);
+  useEffect(() => {
+    const id = callIdRef.current;
+    if (id && status === "active" && connectedRef.current !== id) {
+      connectedRef.current = id;
+      if (systemCallRef.current === id) call?.reportConnected(id);
+    }
+  }, [call, status, callId]);
+  useEffect(() => {
+    if (!callIdRef.current) return;
+    if (status === "error" || status === "lost_owner") {
+      setError(realtime.snapshot.error ?? "Voice disconnected.");
+      void finish("failed");
+    } else if (status === "idle" && connectedRef.current === callIdRef.current) {
+      void finish("ended");
+    }
+  }, [finish, realtime.snapshot.error, status]);
+  const start = useCallback(async () => {
+    if (callIdRef.current) return;
+    const current = realtimeRef.current;
+    if (!current.canStart) {
+      throw new Error(current.admissionBlocker ?? "Voice is not ready yet.");
+    }
+    const id = randomCallId();
+    callIdRef.current = id;
+    setCallId(id);
+    setError(null);
+    if (call) {
+      try {
+        await call.startCall({ callId: id, title: options.title, target: options.target ?? null });
+        if (callIdRef.current === id) {
+          systemCallRef.current = id;
+          setSystemCall(true);
+        }
+      } catch {
+      }
+    }
+    if (callIdRef.current !== id) return;
+    try {
+      await current.start();
+    } catch (cause) {
+      setError(cause instanceof Error ? cause.message : "Could not start the call.");
+      await finish("failed");
+      throw cause;
+    }
+  }, [call, finish, options.target, options.title]);
+  const end = useCallback(async () => {
+    if (!callIdRef.current) return;
+    setEnding(true);
+    await realtimeRef.current.stop().catch(() => void 0);
+    await finish("ended");
+  }, [finish]);
+  const setMuted = useCallback(
+    (next) => {
+      realtimeRef.current.setInputMuted(next);
+      const id = callIdRef.current;
+      if (id && systemCallRef.current === id) void call?.setMuted(id, next).catch(() => void 0);
+    },
+    [call]
+  );
+  const setSpeaker = useCallback(
+    (on) => {
+      setSpeakerState(on);
+      void call?.setSpeaker(on).catch(() => setSpeakerState(!on));
+    },
+    [call]
+  );
+  const phase = !callId ? "idle" : ending || status === "stopping" ? "ending" : status === "active" ? "active" : status === "recovering" && connectedRef.current === callId ? "reconnecting" : "connecting";
+  return {
+    phase,
+    muted,
+    speaker,
+    route,
+    error,
+    systemCall,
+    canStart: !callId && realtime.canStart,
+    start,
+    end,
+    setMuted,
+    setSpeaker
+  };
+}
+var DEFAULT_OPENGENI_NATIVE_CALL_LABELS = {
+  connecting: "Connecting\u2026",
+  live: "Listening",
+  reconnecting: "Reconnecting\u2026",
+  ending: "Ending\u2026",
+  muted: "Muted",
+  mute: "Mute",
+  unmute: "Unmute",
+  speaker: "Speaker",
+  end: "End",
+  minimize: "Back to chat"
+};
+function formatDuration(seconds) {
+  const minutes = Math.floor(seconds / 60);
+  const rest = seconds % 60;
+  return `${minutes}:${String(rest).padStart(2, "0")}`;
+}
+function useCallDuration(active) {
+  const [since, setSince] = useState(null);
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    if (!active) return setSince(null);
+    setSince((current) => current ?? Date.now());
+    const timer = setInterval(() => setNow(Date.now()), 1e3);
+    return () => clearInterval(timer);
+  }, [active]);
+  return since === null ? null : Math.max(0, Math.floor((now - since) / 1e3));
+}
+function CallButton({
+  icon,
+  label,
+  onPress,
+  selected = false,
+  destructive = false,
+  disabled = false
+}) {
+  const theme = useNativeTimelineTheme();
+  const { colors } = theme;
+  const hangUp = theme.scheme === "dark" ? "#FF453A" : "#FF3B30";
+  const background = destructive ? hangUp : selected ? colors.fg : colors["surface-2"];
+  const foreground = destructive ? "#FFFFFF" : selected ? colors.bg : colors.fg;
+  return /* @__PURE__ */ jsxs(View, { style: styles2.buttonColumn, children: [
+    /* @__PURE__ */ jsx(
+      Pressable,
+      {
+        accessibilityRole: "button",
+        accessibilityLabel: label,
+        accessibilityState: { selected, disabled },
+        disabled,
+        onPress,
+        style: ({ pressed }) => [
+          styles2.button,
+          { backgroundColor: background, opacity: disabled ? 0.4 : pressed ? 0.75 : 1 }
+        ],
+        children: /* @__PURE__ */ jsx(Icon, { name: icon, size: 26, color: foreground })
+      }
+    ),
+    /* @__PURE__ */ jsx(Text, { style: [styles2.buttonLabel, fontStyle(theme, 500), { color: colors["fg-muted"] }], children: label })
+  ] });
+}
+function OpenGeniNativeCallView({
+  call,
+  title,
+  subtitle,
+  onMinimize,
+  labels: labelOverrides
+}) {
+  const theme = useNativeTimelineTheme();
+  const { colors } = theme;
+  const labels = { ...DEFAULT_OPENGENI_NATIVE_CALL_LABELS, ...labelOverrides };
+  const duration = useCallDuration(call.phase === "active");
+  const status = call.phase === "connecting" || call.phase === "idle" ? labels.connecting : call.phase === "reconnecting" ? labels.reconnecting : call.phase === "ending" ? labels.ending : call.muted ? labels.muted : labels.live;
+  const orbState = call.phase === "active" ? call.muted ? "breathing" : "listening" : "connecting";
+  const live = call.phase !== "idle" && call.phase !== "ending";
+  return /* @__PURE__ */ jsxs(View, { style: [styles2.screen, { backgroundColor: colors.canvas }], testID: "opengeni-call", children: [
+    /* @__PURE__ */ jsx(View, { style: styles2.header, children: onMinimize ? /* @__PURE__ */ jsx(
+      Pressable,
+      {
+        accessibilityRole: "button",
+        accessibilityLabel: labels.minimize,
+        hitSlop: 12,
+        onPress: onMinimize,
+        style: ({ pressed }) => [styles2.minimize, { opacity: pressed ? 0.6 : 1 }],
+        children: /* @__PURE__ */ jsx(Icon, { name: "chevron-down", size: 24, color: colors["fg-muted"] })
+      }
+    ) : null }),
+    /* @__PURE__ */ jsxs(View, { style: styles2.center, children: [
+      /* @__PURE__ */ jsx(ThinkingOrb, { state: orbState, size: 64, displaySize: 176, speed: 0.7 }),
+      /* @__PURE__ */ jsx(
+        Text,
+        {
+          style: [styles2.title, fontStyle(theme, 600), { color: colors.fg }],
+          numberOfLines: 2,
+          accessibilityRole: "header",
+          children: title
+        }
+      ),
+      subtitle ? /* @__PURE__ */ jsx(
+        Text,
+        {
+          style: [styles2.subtitle, fontStyle(theme, 400), { color: colors["fg-muted"] }],
+          numberOfLines: 1,
+          children: subtitle
+        }
+      ) : null,
+      /* @__PURE__ */ jsx(
+        Text,
+        {
+          style: [styles2.status, fontStyle(theme, 500), { color: colors["fg-muted"] }],
+          accessibilityLiveRegion: "polite",
+          children: duration !== null && !call.muted ? `${status} \xB7 ${formatDuration(duration)}` : status
+        }
+      ),
+      call.error ? /* @__PURE__ */ jsx(Text, { style: [styles2.error, fontStyle(theme, 400), { color: colors.danger }], children: call.error }) : null
+    ] }),
+    /* @__PURE__ */ jsxs(View, { style: styles2.controls, children: [
+      /* @__PURE__ */ jsx(
+        CallButton,
+        {
+          icon: call.muted ? "mic-off" : "mic",
+          label: call.muted ? labels.unmute : labels.mute,
+          selected: call.muted,
+          disabled: !live,
+          onPress: () => call.setMuted(!call.muted)
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        CallButton,
+        {
+          icon: "volume-2",
+          label: labels.speaker,
+          selected: call.speaker,
+          disabled: !live,
+          onPress: () => call.setSpeaker(!call.speaker)
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        CallButton,
+        {
+          icon: "phone-off",
+          label: labels.end,
+          destructive: true,
+          disabled: call.phase === "idle" || call.phase === "ending",
+          onPress: () => void call.end()
+        }
+      )
+    ] })
+  ] });
+}
+var styles2 = StyleSheet.create({
+  screen: { flex: 1, paddingHorizontal: 24, paddingBottom: 32 },
+  header: { height: 52, flexDirection: "row", alignItems: "center" },
+  minimize: { width: 44, height: 44, alignItems: "center", justifyContent: "center" },
+  center: { flex: 1, alignItems: "center", justifyContent: "center", gap: 10 },
+  title: { fontSize: 26, lineHeight: 32, textAlign: "center", marginTop: 28 },
+  subtitle: { fontSize: 15, lineHeight: 20, textAlign: "center" },
+  status: { fontSize: 17, lineHeight: 22, marginTop: 4, fontVariant: ["tabular-nums"] },
+  error: { fontSize: 15, lineHeight: 20, textAlign: "center", marginTop: 8 },
+  controls: { flexDirection: "row", justifyContent: "space-evenly", alignItems: "flex-start" },
+  buttonColumn: { alignItems: "center", gap: 8, width: 88 },
+  button: {
+    width: 72,
+    height: 72,
+    borderRadius: 36,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  buttonLabel: { fontSize: 13, lineHeight: 16 }
+});
+
+export { DEFAULT_OPENGENI_NATIVE_CALL_LABELS, DEFAULT_OPENGENI_NATIVE_LABELS, DEFAULT_OPENGENI_NATIVE_THEME, NATIVE_ATTACHMENT_PREPARATION_TIMEOUT_MS, OpenGeniNativeAttachmentStrip, OpenGeniNativeCallView, OpenGeniNativeSessionView, OpenGeniReactNativeProvider, boundedJson, createMemoryRealtimeOwnerStorage, createNativeRealtimeControllerFactory, createNativeRemoteAudio, formatNativeRelativeTime, installOpenGeniReactNativeEnvironment, nativeHumanInputRequestPreview, nativeRealtimeModelSupported, nativeSessionStatusTone, prepareNativeAttachmentUpload, timelineAccessibilityLabel, useNativeFileAttachments, useNativeRealtimeCall, useNativeSessionRealtime, useOpenGeniNativeSession, useOpenGeniReactNativeEnvironment, validateHumanInputAnswers };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map