@sagepilot-ai/react-native-sdk 0.2.3 → 0.2.5

package/dist/index.mjs

@@ -15,7 +15,7 @@ var SagepilotChatError = class extends Error {
 
 // src/core/config/constants.ts
 var SDK_NAME = "@sagepilot-ai/react-native-sdk";
-var SDK_VERSION = "0.2.3";
+var SDK_VERSION = "0.2.5";
 var DEFAULT_HOST = "https://app.sagepilot.ai";
 var DEFAULT_WIDGET_HOST = "https://app.sagepilot.ai";
 var CUSTOMER_API_PREFIX = "/customer-api/v1";
@@ -464,6 +464,18 @@ function normalizeIdentity(identity) {
     user_hash: identity.userHash ?? identity.user_hash
   };
 }
+function readStringField(input, key) {
+  const value = input[key];
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readRecordField(input, key) {
+  const value = input[key];
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
 function toPublicSessionState(session) {
   return {
     session_id: session.session_id,
@@ -497,6 +509,7 @@ var SagepilotReactNativeChat = class {
     this.unreadPollTimer = null;
     this.stateCallbacks = /* @__PURE__ */ new Set();
     this.identifyCallbacks = /* @__PURE__ */ new Set();
+    this.conversationCreatedCallbacks = /* @__PURE__ */ new Set();
     this.unreadCallbacks = /* @__PURE__ */ new Set();
     this.readyCallbacks = /* @__PURE__ */ new Set();
     this.presentCallbacks = /* @__PURE__ */ new Set();
@@ -519,6 +532,9 @@ var SagepilotReactNativeChat = class {
     const { workspaceId, channelId } = parseKey(config.key);
     this.runtimeOptions = {
       behavior: config.behavior,
+      cacheStorage: config.cacheStorage,
+      filePicker: config.filePicker,
+      fileStore: config.fileStore,
       presentation: config.presentation,
       theme: config.theme,
       hostedClaimsStorageKeyPrefix: config.hostedClaimsStorageKeyPrefix || DEFAULT_HOSTED_CLAIMS_STORAGE_KEY_PREFIX
@@ -703,7 +719,15 @@ var SagepilotReactNativeChat = class {
   }
   presentMessageComposer(message, options) {
     this.requireConfigured();
-    this.hostedChatView = { screen: "composer", message, mode: options?.mode ?? "auto" };
+    const chatId = normalizeOptionalString(options?.chatId);
+    this.hostedChatView = {
+      screen: "composer",
+      message,
+      mode: options?.mode ?? "auto",
+      chatId,
+      metadata: options?.metadata,
+      onConversationCreated: options?.onConversationCreated
+    };
     return this.showHostedChat();
   }
   dismiss() {
@@ -752,6 +776,13 @@ var SagepilotReactNativeChat = class {
       this.dismissCallbacks.delete(callback);
     };
   }
+  onConversationCreated(callback) {
+    if (typeof callback !== "function") return () => void 0;
+    this.conversationCreatedCallbacks.add(callback);
+    return () => {
+      this.conversationCreatedCallbacks.delete(callback);
+    };
+  }
   onError(callback) {
     if (typeof callback !== "function") return () => void 0;
     this.errorCallbacks.add(callback);
@@ -803,7 +834,10 @@ var SagepilotReactNativeChat = class {
       url.searchParams.set("jwt", this.legacyWidgetJwt);
     }
     if (this.hostedChatView.screen === "composer") {
-      if (this.hostedChatView.mode === "new") {
+      if (this.hostedChatView.chatId) {
+        url.searchParams.set("chat_id", this.hostedChatView.chatId);
+      }
+      if (this.hostedChatView.mode === "new" && !this.hostedChatView.chatId) {
         url.searchParams.set("new", "true");
       }
       if (this.hostedChatView.message) {
@@ -831,13 +865,19 @@ var SagepilotReactNativeChat = class {
       "})();"
     ].join("\n");
   }
+  getActiveHostedChatId() {
+    if (this.hostedChatView.screen === "composer" && this.hostedChatView.chatId) {
+      return this.hostedChatView.chatId;
+    }
+    return this.session?.conversation_id ?? void 0;
+  }
   getHostedIdentityMessage() {
     if (!this.legacyWidgetJwt) return null;
     return {
       type: "identity_update",
       data: {
         jwt: this.legacyWidgetJwt,
-        chat_id: this.session?.conversation_id ?? void 0
+        chat_id: this.getActiveHostedChatId()
       }
     };
   }
@@ -856,17 +896,62 @@ var SagepilotReactNativeChat = class {
       }
       return true;
     }
+    if (message.type === "sagepilot:conversation_created") {
+      this.handleConversationCreated(message);
+      return true;
+    }
     if (message.type === "sagepilot:error") {
       this.emitError(message);
       return true;
     }
     return true;
   }
+  handleConversationCreated(message) {
+    const chatId = readStringField(message, "chat_id") ?? readStringField(message, "conversation_id");
+    if (!chatId) return;
+    void this.persistConversationId(chatId).catch((error) => this.emitError(error));
+    const bridgeMetadata = readRecordField(message, "metadata");
+    const composerMetadata = this.hostedChatView.screen === "composer" ? this.hostedChatView.metadata : void 0;
+    const metadata = {
+      ...composerMetadata ?? {},
+      ...bridgeMetadata ?? {}
+    };
+    const workspaceId = readStringField(message, "workspace_id") ?? this.workspaceId;
+    const channelId = readStringField(message, "channel_id") ?? this.channelId;
+    const sessionId = readStringField(message, "session_id") ?? this.session?.session_id;
+    const customerId = readStringField(message, "customer_id");
+    const messageId = readStringField(message, "message_id");
+    const createdAt = readStringField(message, "created_at");
+    const event = {
+      chat_id: chatId,
+      ...workspaceId ? { workspace_id: workspaceId } : {},
+      ...channelId ? { channel_id: channelId } : {},
+      ...sessionId ? { session_id: sessionId } : {},
+      ...customerId ? { customer_id: customerId } : {},
+      ...messageId ? { message_id: messageId } : {},
+      ...createdAt ? { created_at: createdAt } : {},
+      ...Object.keys(metadata).length > 0 ? { metadata } : {}
+    };
+    if (this.hostedChatView.screen === "composer") {
+      this.hostedChatView.onConversationCreated?.(event);
+    }
+    this.conversationCreatedCallbacks.forEach((callback) => callback(event));
+  }
+  async persistConversationId(conversationId) {
+    if (!this.session || !this.sessionManager) return;
+    if (this.session.conversation_id === conversationId) return;
+    this.session = await this.sessionManager.setSession({
+      ...this.session,
+      conversation_id: conversationId
+    });
+    this.emitState();
+  }
   destroy() {
     this.stopUnreadPolling();
     this.resetRuntimeState();
     this.emitState();
     this.identifyCallbacks.clear();
+    this.conversationCreatedCallbacks.clear();
     this.unreadCallbacks.clear();
     this.readyCallbacks.clear();
     this.presentCallbacks.clear();
@@ -1029,6 +1114,9 @@ var SagepilotChat = {
   logout: () => internalSagepilotChat.logout(),
   getIdentityState: () => internalSagepilotChat.getIdentityState(),
   onIdentify: (callback) => internalSagepilotChat.onIdentify(callback),
+  onConversationCreated: (callback) => {
+    return internalSagepilotChat.onConversationCreated(callback);
+  },
   getUnreadCount: () => internalSagepilotChat.getUnreadCount(),
   onUnreadChange: (callback) => internalSagepilotChat.onUnreadChange(callback),
   startUnreadPolling: (intervalMs) => internalSagepilotChat.startUnreadPolling(intervalMs),
@@ -1061,14 +1149,295 @@ function createAsyncStorageCacheStorage(asyncStorage) {
     removeItem: (key) => asyncStorage.removeItem(key)
   };
 }
+function createJsonCache(storage, namespace) {
+  return {
+    async get(key) {
+      const value = await storage.getItem(`${namespace}:${key}`);
+      if (!value) return null;
+      try {
+        return JSON.parse(value);
+      } catch {
+        return null;
+      }
+    },
+    async set(key, value) {
+      await storage.setItem(`${namespace}:${key}`, JSON.stringify(value));
+    },
+    async remove(key) {
+      await storage.removeItem(`${namespace}:${key}`);
+    }
+  };
+}
+
+// src/core/storage/fileStore.ts
+var DEFAULT_DIRECTORY_NAME = "sagepilot-attachments";
+function sanitizeKey(key) {
+  return key.replace(/[^a-zA-Z0-9._-]/g, "_").replace(/\.{2,}/g, "_");
+}
+function createSagepilotFileStore(blobUtil, options = {}) {
+  const directory = `${blobUtil.fs.dirs.DocumentDir}/${options.directoryName ?? DEFAULT_DIRECTORY_NAME}`;
+  const pathFor = (key) => `${directory}/${sanitizeKey(key)}`;
+  let dirReady = null;
+  function ensureDirectory() {
+    if (!dirReady) {
+      dirReady = (async () => {
+        if (!await blobUtil.fs.exists(directory)) {
+          await blobUtil.fs.mkdir(directory);
+        }
+      })().catch((error) => {
+        dirReady = null;
+        throw error;
+      });
+    }
+    return dirReady;
+  }
+  return {
+    async write(key, base64) {
+      await ensureDirectory();
+      await blobUtil.fs.writeFile(pathFor(key), base64, "base64");
+    },
+    async read(key) {
+      const content = await blobUtil.fs.readFile(pathFor(key), "base64");
+      if (typeof content !== "string" || content.length === 0) {
+        throw new Error("Persisted attachment is empty or unreadable.");
+      }
+      return content;
+    },
+    async remove(key) {
+      try {
+        if (await blobUtil.fs.exists(pathFor(key))) {
+          await blobUtil.fs.unlink(pathFor(key));
+        }
+      } catch {
+      }
+    },
+    async prune(keepKeys) {
+      try {
+        if (!await blobUtil.fs.exists(directory)) return;
+        const keep = new Set(keepKeys.map(sanitizeKey));
+        const entries = await blobUtil.fs.ls(directory);
+        await Promise.all(
+          entries.filter((entry) => !keep.has(entry)).map((entry) => blobUtil.fs.unlink(`${directory}/${entry}`).catch(() => void 0))
+        );
+      } catch {
+      }
+    }
+  };
+}
+
+// src/core/native/filePicker.ts
+import { PermissionsAndroid, Platform } from "react-native";
+var DEFAULT_IMAGE_MAX_DIMENSION = 1920;
+var DEFAULT_IMAGE_QUALITY = 0.8;
+var DEFAULT_IMAGE_MIME_TYPE = "image/jpeg";
+var DEFAULT_DOCUMENT_MIME_TYPE = "application/octet-stream";
+var DEFAULT_IMAGE_SELECTION_LIMIT = 5;
+var DEFAULT_DOCUMENT_MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024;
+var DEFAULT_IMAGE_MAX_FILE_SIZE_BYTES = 15 * 1024 * 1024;
+var SagepilotFilePickerError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "SagepilotFilePickerError";
+    this.code = code;
+  }
+};
+function bytesToMb(bytes) {
+  return Math.round(bytes / (1024 * 1024) * 10) / 10;
+}
+function estimateBase64ByteSize(dataBase64) {
+  return Math.floor(dataBase64.length * 3 / 4);
+}
+function stripFileScheme(uri) {
+  return uri.startsWith("file://") ? uri.replace("file://", "") : uri;
+}
+async function ensureAndroidCameraPermission() {
+  if (Platform.OS !== "android") return;
+  let result;
+  try {
+    result = await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.CAMERA);
+  } catch {
+    return;
+  }
+  if (result === PermissionsAndroid.RESULTS.NEVER_ASK_AGAIN) {
+    throw new SagepilotFilePickerError(
+      "permission_denied",
+      "Camera access is turned off. Enable it for this app in Settings to take a photo."
+    );
+  }
+  if (result === PermissionsAndroid.RESULTS.DENIED) {
+    throw new SagepilotFilePickerError(
+      "permission_denied",
+      "Camera permission is required to take a photo."
+    );
+  }
+}
+function mapImagePickerErrorCode(errorCode) {
+  switch (errorCode) {
+    case "permission":
+      return "permission_denied";
+    case "camera_unavailable":
+      return "camera_unavailable";
+    default:
+      return "unknown";
+  }
+}
+function imageAssetsToPickedFiles(result, maxFileSizeBytes) {
+  if (result.didCancel) return [];
+  if (result.errorCode) {
+    throw new SagepilotFilePickerError(
+      mapImagePickerErrorCode(result.errorCode),
+      result.errorMessage || `Could not capture the photo (${result.errorCode}).`
+    );
+  }
+  const assets = result.assets ?? [];
+  const usable = assets.filter((asset) => typeof asset.base64 === "string" && asset.base64.length > 0);
+  if (assets.length > usable.length) {
+    throw new SagepilotFilePickerError(
+      "encode_failed",
+      assets.length === 1 ? "The photo could not be processed. Please try again." : "Some photos could not be processed. Please try selecting them again."
+    );
+  }
+  return usable.map((asset, index) => {
+    const dataBase64 = asset.base64;
+    const size = asset.fileSize ?? estimateBase64ByteSize(dataBase64);
+    if (maxFileSizeBytes > 0 && size > maxFileSizeBytes) {
+      throw new SagepilotFilePickerError(
+        "file_too_large",
+        `Image is too large (max ${bytesToMb(maxFileSizeBytes)}MB).`
+      );
+    }
+    return {
+      file_name: asset.fileName || `photo-${Date.now()}-${index + 1}.jpg`,
+      mime_type: asset.type || DEFAULT_IMAGE_MIME_TYPE,
+      size,
+      data_base64: dataBase64
+    };
+  });
+}
+async function readUriAsBase64(uri, fileReader) {
+  if (fileReader) {
+    const content = await fileReader.fs.readFile(stripFileScheme(uri), "base64");
+    if (typeof content !== "string") {
+      throw new Error("File reader returned unexpected content.");
+    }
+    return content;
+  }
+  const response = await fetch(uri);
+  const blob = await response.blob();
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const dataUrl = typeof reader.result === "string" ? reader.result : "";
+      const [, payload = ""] = dataUrl.split(",");
+      if (!payload) {
+        reject(new Error("Could not read the selected file."));
+        return;
+      }
+      resolve(payload);
+    };
+    reader.onerror = () => reject(new Error("Could not read the selected file."));
+    reader.readAsDataURL(blob);
+  });
+}
+function createSagepilotFilePicker(options) {
+  const { imagePicker, documentsPicker, fileReader } = options;
+  const imageMaxDimension = options.imageMaxDimension ?? DEFAULT_IMAGE_MAX_DIMENSION;
+  const imageQuality = options.imageQuality ?? DEFAULT_IMAGE_QUALITY;
+  const imageSelectionLimit = options.imageSelectionLimit ?? DEFAULT_IMAGE_SELECTION_LIMIT;
+  const documentMaxFileSizeBytes = options.documentMaxFileSizeBytes ?? DEFAULT_DOCUMENT_MAX_FILE_SIZE_BYTES;
+  const imageMaxFileSizeBytes = options.imageMaxFileSizeBytes ?? DEFAULT_IMAGE_MAX_FILE_SIZE_BYTES;
+  const sources = [];
+  if (imagePicker) sources.push("camera", "library");
+  if (documentsPicker) sources.push("documents");
+  if (sources.length === 0) return void 0;
+  const imageOptions = {
+    mediaType: "photo",
+    includeBase64: true,
+    maxWidth: imageMaxDimension,
+    maxHeight: imageMaxDimension,
+    quality: imageQuality,
+    saveToPhotos: false
+  };
+  async function pickFromCamera() {
+    if (!imagePicker) return [];
+    await ensureAndroidCameraPermission();
+    return imageAssetsToPickedFiles(await imagePicker.launchCamera(imageOptions), imageMaxFileSizeBytes);
+  }
+  async function pickFromLibrary(multiple) {
+    if (!imagePicker) return [];
+    return imageAssetsToPickedFiles(await imagePicker.launchImageLibrary({
+      ...imageOptions,
+      // Bounded multi-select: 0 (unlimited) lets a huge batch OOM the bridge.
+      selectionLimit: multiple ? Math.max(0, imageSelectionLimit) : 1
+    }), imageMaxFileSizeBytes);
+  }
+  async function pickDocuments(multiple) {
+    if (!documentsPicker) return [];
+    let picked;
+    try {
+      picked = await documentsPicker.pick({ allowMultiSelection: multiple });
+    } catch (error) {
+      if (error && typeof error === "object" && error.code === "OPERATION_CANCELED") {
+        return [];
+      }
+      throw error;
+    }
+    const files = [];
+    for (const file of picked) {
+      if (documentMaxFileSizeBytes > 0 && typeof file.size === "number" && file.size > documentMaxFileSizeBytes) {
+        throw new SagepilotFilePickerError(
+          "file_too_large",
+          `"${file.name || "File"}" is too large (max ${bytesToMb(documentMaxFileSizeBytes)}MB).`
+        );
+      }
+      let readableUri = file.uri;
+      if (documentsPicker.keepLocalCopy) {
+        const fileName = file.name || `file-${Date.now()}`;
+        const [copy] = await documentsPicker.keepLocalCopy({
+          files: [{ uri: file.uri, fileName }],
+          destination: "cachesDirectory"
+        });
+        if (copy?.status === "success" && copy.localUri) {
+          readableUri = copy.localUri;
+        }
+      }
+      let dataBase64;
+      try {
+        dataBase64 = await readUriAsBase64(readableUri, fileReader);
+      } catch (error) {
+        throw new SagepilotFilePickerError(
+          "read_failed",
+          error instanceof Error && error.message ? error.message : "Could not read the selected file."
+        );
+      }
+      files.push({
+        file_name: file.name || `file-${Date.now()}`,
+        mime_type: file.type || DEFAULT_DOCUMENT_MIME_TYPE,
+        size: file.size ?? estimateBase64ByteSize(dataBase64),
+        data_base64: dataBase64
+      });
+    }
+    return files;
+  }
+  return {
+    sources,
+    async pickFiles(request) {
+      if (request.source === "camera") return pickFromCamera();
+      if (request.source === "library") return pickFromLibrary(request.multiple);
+      return pickDocuments(request.multiple);
+    }
+  };
+}
 
 // src/ui/SagepilotChatProvider.ts
 import { createElement, useCallback, useEffect, useRef, useState } from "react";
 import {
   ActivityIndicator,
+  AppState,
   KeyboardAvoidingView,
+  Linking,
   Modal,
-  Platform,
+  Platform as Platform2,
   Pressable,
   SafeAreaView,
   StyleSheet,
@@ -1078,6 +1447,37 @@ import {
 import { WebView } from "react-native-webview";
 
 // src/core/webview/mobileBridge.ts
+var FILE_PICKER_PROTOCOL_VERSION = 2;
+function buildBridgeCapabilitiesScript(capabilities) {
+  const payload = { ...capabilities, filePickerProtocol: FILE_PICKER_PROTOCOL_VERSION };
+  return [
+    "(function(){",
+    "try {",
+    "if (window.SagepilotMobileBridge) {",
+    `window.SagepilotMobileBridge.capabilities = Object.assign({}, window.SagepilotMobileBridge.capabilities, ${JSON.stringify(payload)});`,
+    "}",
+    "} catch (_) {}",
+    "true;",
+    "})();"
+  ].join("\n");
+}
+function buildLivenessPingScript(nonce, staleMs) {
+  return [
+    "(function(){",
+    "try {",
+    "var hb = window.__sagepilotWidgetHeartbeat;",
+    "var supports = typeof hb === 'number';",
+    `var alive = !supports ? true : (Date.now() - hb < ${Math.max(0, Math.floor(staleMs))});`,
+    "var send = function(){",
+    "  var msg = JSON.stringify({ type: 'sagepilot:pong', nonce: " + JSON.stringify(nonce) + ", alive: alive, supportsHeartbeat: supports });",
+    "  if (window.ReactNativeWebView && window.ReactNativeWebView.postMessage) { window.ReactNativeWebView.postMessage(msg); }",
+    "};",
+    "send();",
+    "} catch (_) {}",
+    "true;",
+    "})();"
+  ].join("\n");
+}
 function isHostedBridgeMessage(value) {
   if (!value || typeof value !== "object") return false;
   const message = value;
@@ -1203,9 +1603,70 @@ function readPresentationState() {
 function getInjectedWebViewScript() {
   return [
     internalSagepilotChat.getHostedAuthScript(),
-    mobileWebViewBridgeScript
+    mobileWebViewBridgeScript,
+    buildBridgeCapabilitiesScript({
+      nativeFilePicker: Boolean(internalSagepilotChat.getConfig()?.filePicker)
+    })
   ].filter(Boolean).join("\n");
 }
+var FILE_PICKER_SOURCE_LABELS = {
+  camera: "Take photo",
+  library: "Choose from gallery",
+  documents: "Browse files"
+};
+var DELIVERY_RETRY_MS = 1500;
+var DELIVERY_LEGACY_FALLBACK_ATTEMPTS = 2;
+var DELIVERY_MAX_ATTEMPTS = 8;
+var PERSIST_MAX_TOTAL_BYTES = 2 * 1024 * 1024;
+var PENDING_FILES_CACHE_NAMESPACE = "sagepilot_rn_picker";
+var PENDING_FILES_CACHE_KEY = "pending_batch";
+var LIVENESS_HEARTBEAT_STALE_MS = 4e3;
+var LIVENESS_PONG_TIMEOUT_MS = 1500;
+var LIVENESS_MAX_PING_ATTEMPTS = 2;
+var LIVENESS_MAX_REMOUNTS = 2;
+var batchSequence = 0;
+function nextBatchId() {
+  batchSequence += 1;
+  const entropy = Math.random().toString(36).slice(2, 8);
+  return `b_${Date.now().toString(36)}_${batchSequence}_${entropy}`;
+}
+function totalBase64Bytes(files) {
+  return files.reduce((sum, file) => sum + (file.data_base64?.length ?? 0), 0);
+}
+function storageKeyFor(batchId, index) {
+  return `${batchId}_${index}.bin`;
+}
+function buildDispatchScript(messageLiteral) {
+  return [
+    "(function(){",
+    "try {",
+    `var message = ${messageLiteral};`,
+    "window.dispatchEvent(new MessageEvent('message', { data: message, origin: window.location.origin, source: window.parent || window }));",
+    "} catch (_) {}",
+    "true;",
+    "})();"
+  ].join("\n");
+}
+function buildFilesPickedScript(files, batchId) {
+  return buildDispatchScript(`{ type: "sagepilot:files_picked", batch_id: ${JSON.stringify(batchId)}, files: ${JSON.stringify(files)} }`);
+}
+function buildFilePickerErrorScript(message, code) {
+  return buildDispatchScript(
+    `{ type: "sagepilot:file_picker_error", message: ${JSON.stringify(message)}${code ? `, code: ${JSON.stringify(code)}` : ""} }`
+  );
+}
+function buildFilePickerCancelledScript() {
+  return buildDispatchScript(`{ type: "sagepilot:file_picker_cancelled" }`);
+}
+function readFilePickerError(error) {
+  if (error && typeof error === "object") {
+    const candidate = error;
+    const message = typeof candidate.message === "string" && candidate.message ? candidate.message : "Could not attach the selected file.";
+    const code = typeof candidate.code === "string" ? candidate.code : void 0;
+    return { message, code };
+  }
+  return { message: "Could not attach the selected file." };
+}
 function getHostedIdentityDispatchScript() {
   const message = internalSagepilotChat.getHostedIdentityMessage();
   if (!message) return "";
@@ -1228,19 +1689,28 @@ function readUrlOrigin(url) {
     return null;
   }
 }
+function isInternalWebViewScheme(url) {
+  return url.startsWith("about:") || url.startsWith("data:") || url.startsWith("blob:") || url.startsWith("javascript:") || url.startsWith("file:");
+}
 var hostedChatWebViewProps = {
   allowFileAccess: true,
   allowFileAccessFromFileURLs: true,
+  ...Platform2.OS === "ios" ? {
+    automaticallyAdjustContentInsets: false,
+    contentInsetAdjustmentBehavior: "never",
+    hideKeyboardAccessoryView: true
+  } : null,
   bounces: false,
   domStorageEnabled: true,
   javaScriptEnabled: true,
   overScrollMode: "never",
-  scrollEnabled: Platform.OS !== "android",
+  // The hosted widget owns feed scrolling internally; outer WebView scrolling lets iOS focus-scroll the page over the keyboard.
+  scrollEnabled: false,
   setSupportMultipleWindows: false,
   sharedCookiesEnabled: true,
   thirdPartyCookiesEnabled: true
 };
-var AndroidInsetsView = Platform.OS === "android" ? SagepilotInsetsViewNativeComponent_default : View;
+var AndroidInsetsView = Platform2.OS === "android" ? SagepilotInsetsViewNativeComponent_default : View;
 var emptyAndroidInsets = { top: 0, bottom: 0 };
 function SagepilotChatProvider({
   children,
@@ -1249,13 +1719,292 @@ function SagepilotChatProvider({
 }) {
   const [state, setState] = useState(readPresentationState);
   const [androidModalInsets, setAndroidModalInsets] = useState(emptyAndroidInsets);
+  const [nativeWebViewKey, setNativeWebViewKey] = useState(0);
+  const [preloadWebViewKey, setPreloadWebViewKey] = useState(0);
   const webFrameRef = useRef(null);
   const nativeWebViewRef = useRef(null);
+  const pendingBatchesRef = useRef([]);
+  const widgetReadyRef = useRef(false);
+  const deliveryTimerRef = useRef(null);
+  const deliveryAttemptsRef = useRef(0);
+  const pendingPingRef = useRef(null);
+  const pingTimeoutRef = useRef(null);
+  const livenessRemountCountRef = useRef(0);
+  const appStateRef = useRef(AppState.currentState);
+  const didReconcileRef = useRef(false);
+  const [androidRepaintTick, setAndroidRepaintTick] = useState(0);
+  const [sourceChooser, setSourceChooser] = useState(null);
+  const getPendingCache = useCallback(() => {
+    const cacheStorage = internalSagepilotChat.getConfig()?.cacheStorage;
+    if (!cacheStorage) return null;
+    return createJsonCache(cacheStorage, PENDING_FILES_CACHE_NAMESPACE);
+  }, []);
+  const writeManifest = useCallback(() => {
+    const cache = getPendingCache();
+    if (!cache) return;
+    const queue = pendingBatchesRef.current;
+    if (queue.length === 0) {
+      void cache.remove(PENDING_FILES_CACHE_KEY).catch(() => void 0);
+      return;
+    }
+    const hasFileStore = Boolean(internalSagepilotChat.getConfig()?.fileStore);
+    if (hasFileStore) {
+      const manifest = queue.filter((batch) => batch.storageKeys && batch.storageKeys.length === batch.files.length).map((batch) => ({
+        batchId: batch.batchId,
+        files: batch.files.map((file, index) => ({
+          file_name: file.file_name,
+          mime_type: file.mime_type,
+          size: file.size,
+          storageKey: batch.storageKeys[index]
+        }))
+      }));
+      if (manifest.length === 0) {
+        void cache.remove(PENDING_FILES_CACHE_KEY).catch(() => void 0);
+      } else {
+        void cache.set(PENDING_FILES_CACHE_KEY, manifest).catch(() => void 0);
+      }
+      return;
+    }
+    const totalBytes = queue.reduce((sum, batch) => sum + totalBase64Bytes(batch.files), 0);
+    if (totalBytes <= PERSIST_MAX_TOTAL_BYTES) {
+      const manifest = queue.map((batch) => ({
+        batchId: batch.batchId,
+        files: batch.files.map((file) => ({
+          file_name: file.file_name,
+          mime_type: file.mime_type,
+          size: file.size,
+          data_base64: file.data_base64
+        }))
+      }));
+      void cache.set(PENDING_FILES_CACHE_KEY, manifest).catch(() => void 0);
+    } else {
+      void cache.remove(PENDING_FILES_CACHE_KEY).catch(() => void 0);
+    }
+  }, [getPendingCache]);
+  const writeBatchBytes = useCallback(async (batch) => {
+    const fileStore = internalSagepilotChat.getConfig()?.fileStore;
+    if (!fileStore) return;
+    const entries = batch.files.map((file, index) => ({
+      key: storageKeyFor(batch.batchId, index),
+      base64: file.data_base64
+    }));
+    try {
+      await Promise.all(entries.map((entry) => fileStore.write(entry.key, entry.base64)));
+    } catch {
+      return;
+    }
+    if (!pendingBatchesRef.current.some((queued) => queued.batchId === batch.batchId)) {
+      void Promise.all(entries.map((entry) => fileStore.remove(entry.key).catch(() => void 0)));
+    }
+  }, []);
+  const discardBatchFiles = useCallback((batch) => {
+    if (!batch?.storageKeys) return;
+    const fileStore = internalSagepilotChat.getConfig()?.fileStore;
+    if (!fileStore) return;
+    void Promise.all(batch.storageKeys.map((key) => fileStore.remove(key).catch(() => void 0)));
+  }, []);
+  const pumpDelivery = useCallback(() => {
+    if (deliveryTimerRef.current) {
+      clearTimeout(deliveryTimerRef.current);
+      deliveryTimerRef.current = null;
+    }
+    const batch = pendingBatchesRef.current[0];
+    if (!batch) return;
+    deliveryAttemptsRef.current += 1;
+    const attempts = deliveryAttemptsRef.current;
+    const ref = nativeWebViewRef.current;
+    const shouldDeliver = ref && (widgetReadyRef.current || attempts >= DELIVERY_LEGACY_FALLBACK_ATTEMPTS);
+    if (shouldDeliver && ref) {
+      ref.injectJavaScript(buildFilesPickedScript(batch.files, batch.batchId));
+    }
+    if (attempts < DELIVERY_MAX_ATTEMPTS) {
+      deliveryTimerRef.current = setTimeout(() => pumpDelivery(), DELIVERY_RETRY_MS);
+    }
+  }, []);
+  const startDelivery = useCallback(() => {
+    deliveryAttemptsRef.current = 0;
+    pumpDelivery();
+  }, [pumpDelivery]);
+  const ensureDelivery = useCallback(() => {
+    if (pendingBatchesRef.current.length === 0) return;
+    if (deliveryTimerRef.current) return;
+    startDelivery();
+  }, [startDelivery]);
+  const acknowledgeHeadBatch = useCallback(() => {
+    const head = pendingBatchesRef.current[0];
+    pendingBatchesRef.current = pendingBatchesRef.current.slice(1);
+    deliveryAttemptsRef.current = 0;
+    if (deliveryTimerRef.current) {
+      clearTimeout(deliveryTimerRef.current);
+      deliveryTimerRef.current = null;
+    }
+    discardBatchFiles(head);
+    writeManifest();
+    if (pendingBatchesRef.current.length > 0) startDelivery();
+  }, [discardBatchFiles, writeManifest, startDelivery]);
+  const queuePickedFiles = useCallback((files) => {
+    const batchId = nextBatchId();
+    const hasFileStore = Boolean(internalSagepilotChat.getConfig()?.fileStore);
+    const storageKeys = hasFileStore ? files.map((_, index) => storageKeyFor(batchId, index)) : void 0;
+    const batch = { batchId, files, storageKeys };
+    pendingBatchesRef.current = [...pendingBatchesRef.current, batch];
+    ensureDelivery();
+    writeManifest();
+    void writeBatchBytes(batch);
+  }, [ensureDelivery, writeManifest, writeBatchBytes]);
+  const recoverNativeWebView = useCallback(() => {
+    widgetReadyRef.current = false;
+    setNativeWebViewKey((key) => key + 1);
+  }, []);
+  const recoverPreloadWebView = useCallback(() => {
+    setPreloadWebViewKey((key) => key + 1);
+  }, []);
+  const runNativeFilePicker = useCallback((source, multiple) => {
+    const filePicker = internalSagepilotChat.getConfig()?.filePicker;
+    if (!filePicker) return;
+    filePicker.pickFiles({ source, multiple }).then((files) => {
+      if (files.length === 0) {
+        nativeWebViewRef.current?.injectJavaScript(buildFilePickerCancelledScript());
+        return;
+      }
+      queuePickedFiles(files);
+    }).catch((error) => {
+      const { message, code } = readFilePickerError(error);
+      nativeWebViewRef.current?.injectJavaScript(buildFilePickerErrorScript(message, code));
+    });
+  }, [queuePickedFiles]);
+  const openNativeFilePicker = useCallback((multiple) => {
+    const filePicker = internalSagepilotChat.getConfig()?.filePicker;
+    if (!filePicker || filePicker.sources.length === 0) return;
+    const [onlySource] = filePicker.sources;
+    if (filePicker.sources.length === 1 && onlySource) {
+      runNativeFilePicker(onlySource, multiple);
+      return;
+    }
+    setSourceChooser({ multiple });
+  }, [runNativeFilePicker]);
+  const handleSourceChoice = useCallback((source) => {
+    const chooser = sourceChooser;
+    setSourceChooser(null);
+    if (chooser) runNativeFilePicker(source, chooser.multiple);
+  }, [sourceChooser, runNativeFilePicker]);
   useEffect(() => {
     return internalSagepilotChat.onStateChange(() => {
       setState(readPresentationState());
     });
   }, []);
+  useEffect(() => {
+    let cancelled = false;
+    const cache = getPendingCache();
+    if (!cache) return;
+    const reconcile = async () => {
+      if (didReconcileRef.current) return;
+      const manifest = await cache.get(PENDING_FILES_CACHE_KEY).catch(() => null);
+      if (cancelled || didReconcileRef.current || !Array.isArray(manifest) || manifest.length === 0) return;
+      const fileStore = internalSagepilotChat.getConfig()?.fileStore;
+      const restored = [];
+      for (const batch of manifest) {
+        if (!batch || typeof batch.batchId !== "string" || !Array.isArray(batch.files) || batch.files.length === 0) continue;
+        const files = [];
+        const storageKeys = [];
+        let intact = true;
+        for (const file of batch.files) {
+          let dataBase64 = null;
+          if (typeof file.storageKey === "string" && fileStore) {
+            try {
+              dataBase64 = await fileStore.read(file.storageKey);
+              storageKeys.push(file.storageKey);
+            } catch {
+              intact = false;
+            }
+          } else if (typeof file.data_base64 === "string" && file.data_base64) {
+            dataBase64 = file.data_base64;
+          }
+          if (!dataBase64) {
+            intact = false;
+            break;
+          }
+          files.push({ file_name: file.file_name, mime_type: file.mime_type, size: file.size, data_base64: dataBase64 });
+        }
+        if (intact && files.length === batch.files.length) {
+          restored.push({
+            batchId: batch.batchId,
+            files,
+            storageKeys: storageKeys.length === files.length ? storageKeys : void 0
+          });
+        }
+      }
+      if (cancelled || didReconcileRef.current) return;
+      didReconcileRef.current = true;
+      pendingBatchesRef.current = [...restored, ...pendingBatchesRef.current];
+      writeManifest();
+      if (fileStore) {
+        const keep = pendingBatchesRef.current.flatMap(
+          (batch) => batch.files.map((_, index) => storageKeyFor(batch.batchId, index))
+        );
+        void fileStore.prune(keep).catch(() => void 0);
+      }
+      startDelivery();
+    };
+    void reconcile();
+    return () => {
+      cancelled = true;
+    };
+  }, [getPendingCache, startDelivery, writeManifest]);
+  useEffect(() => {
+    return () => {
+      if (deliveryTimerRef.current) {
+        clearTimeout(deliveryTimerRef.current);
+        deliveryTimerRef.current = null;
+      }
+      if (pingTimeoutRef.current) {
+        clearTimeout(pingTimeoutRef.current);
+        pingTimeoutRef.current = null;
+      }
+    };
+  }, []);
+  const clearPing = useCallback(() => {
+    pendingPingRef.current = null;
+    if (pingTimeoutRef.current) {
+      clearTimeout(pingTimeoutRef.current);
+      pingTimeoutRef.current = null;
+    }
+  }, []);
+  const runLivenessProbe = useCallback(() => {
+    if (Platform2.OS !== "android") return;
+    const ref = nativeWebViewRef.current;
+    if (!ref || !internalSagepilotChat.isPresented()) return;
+    setAndroidRepaintTick((tick) => tick + 1);
+    const attempts = (pendingPingRef.current?.attempts ?? 0) + 1;
+    const nonce = `${Date.now().toString(36)}_${attempts}`;
+    pendingPingRef.current = { nonce, attempts };
+    ref.injectJavaScript(buildLivenessPingScript(nonce, LIVENESS_HEARTBEAT_STALE_MS));
+    if (pingTimeoutRef.current) clearTimeout(pingTimeoutRef.current);
+    pingTimeoutRef.current = setTimeout(() => {
+      if (attempts >= LIVENESS_MAX_PING_ATTEMPTS) {
+        clearPing();
+        recoverNativeWebView();
+        return;
+      }
+      runLivenessProbe();
+    }, LIVENESS_PONG_TIMEOUT_MS);
+  }, [clearPing, recoverNativeWebView]);
+  useEffect(() => {
+    const subscription = AppState.addEventListener("change", (nextState) => {
+      const prev = appStateRef.current;
+      appStateRef.current = nextState;
+      if (nextState === "active" && (prev === "background" || prev === "inactive")) {
+        clearPing();
+        livenessRemountCountRef.current = 0;
+        runLivenessProbe();
+        ensureDelivery();
+      }
+    });
+    return () => {
+      subscription.remove();
+      clearPing();
+    };
+  }, [clearPing, runLivenessProbe, ensureDelivery]);
   const handleAndroidInsetsChange = useCallback((event) => {
     const nextBottomInset = event.nativeEvent?.bottom;
     const nextTopInset = event.nativeEvent?.top;
@@ -1269,11 +2018,11 @@ function SagepilotChatProvider({
   const presentationStyle = state.presentation?.style ?? "sheet";
   const isFullScreenModal = presentationStyle === "fullScreen";
   const animationType = presentationStyle === "fullScreen" || presentationStyle === "push" ? "slide" : "fade";
-  const ModalContainer = Platform.OS === "ios" && isFullScreenModal ? SafeAreaView : View;
-  const NativeModalContainer = Platform.OS === "android" ? AndroidInsetsView : ModalContainer;
-  const ChatContentContainer = Platform.OS === "ios" ? KeyboardAvoidingView : View;
-  const nativeModalContainerProps = Platform.OS === "android" ? { style: styles.container, onInsetsChange: handleAndroidInsetsChange } : { style: styles.container };
-  const chatContentContainerProps = Platform.OS === "ios" ? {
+  const ModalContainer = Platform2.OS === "ios" && isFullScreenModal ? SafeAreaView : View;
+  const NativeModalContainer = Platform2.OS === "android" ? AndroidInsetsView : ModalContainer;
+  const ChatContentContainer = Platform2.OS === "ios" ? KeyboardAvoidingView : View;
+  const nativeModalContainerProps = Platform2.OS === "android" ? { style: styles.container, onInsetsChange: handleAndroidInsetsChange } : { style: styles.container };
+  const chatContentContainerProps = Platform2.OS === "ios" ? {
     behavior: "padding",
     enabled: true,
     keyboardVerticalOffset: 0,
@@ -1281,14 +2030,48 @@ function SagepilotChatProvider({
   } : {
     style: [
       styles.modalContent,
-      Platform.OS === "android" ? {
+      Platform2.OS === "android" ? {
         paddingTop: androidModalInsets.top,
         paddingBottom: androidModalInsets.bottom
       } : null
     ].filter(Boolean)
   };
   const handleWebViewMessage = (event) => {
-    internalSagepilotChat.handleHostedBridgeMessage(parseHostedBridgeMessage(event.nativeEvent?.data));
+    const message = parseHostedBridgeMessage(event.nativeEvent?.data);
+    if (message?.type === "sagepilot:open_file_picker") {
+      openNativeFilePicker(message.multiple ?? true);
+      return;
+    }
+    if (message?.type === "sagepilot:widget_listener_ready") {
+      widgetReadyRef.current = true;
+      startDelivery();
+      return;
+    }
+    if (message?.type === "sagepilot:files_received") {
+      const ackBatchId = message.batch_id;
+      const head = pendingBatchesRef.current[0];
+      if (head && (!ackBatchId || ackBatchId === head.batchId)) {
+        acknowledgeHeadBatch();
+      }
+      return;
+    }
+    if (message?.type === "sagepilot:pong") {
+      const pending = pendingPingRef.current;
+      if (pending && (!message.nonce || message.nonce === pending.nonce)) {
+        if (message.alive === false) {
+          clearPing();
+          if (livenessRemountCountRef.current < LIVENESS_MAX_REMOUNTS) {
+            livenessRemountCountRef.current += 1;
+            recoverNativeWebView();
+          }
+        } else {
+          livenessRemountCountRef.current = 0;
+          clearPing();
+        }
+      }
+      return;
+    }
+    internalSagepilotChat.handleHostedBridgeMessage(message);
   };
   const postIdentityToWebFrame = () => {
     const message = internalSagepilotChat.getHostedIdentityMessage();
@@ -1301,8 +2084,25 @@ function SagepilotChatProvider({
     if (!script || !nativeWebViewRef.current) return;
     nativeWebViewRef.current.injectJavaScript(script);
   };
+  const handleNativeWebViewLoadEnd = () => {
+    postIdentityToNativeWebView();
+    widgetReadyRef.current = false;
+    startDelivery();
+  };
+  const handleShouldStartLoadWithRequest = useCallback((request) => {
+    const url = request?.url ?? "";
+    if (!url || request?.isTopFrame === false || isInternalWebViewScheme(url)) {
+      return true;
+    }
+    const widgetOrigin = readUrlOrigin(state.conversationUrl ?? state.preloadUrl);
+    if (widgetOrigin && readUrlOrigin(url) === widgetOrigin) {
+      return true;
+    }
+    Linking.openURL(url).catch(() => void 0);
+    return false;
+  }, [state.conversationUrl, state.preloadUrl]);
   useEffect(() => {
-    if (Platform.OS !== "web" || typeof window === "undefined") return;
+    if (Platform2.OS !== "web" || typeof window === "undefined") return;
     const trustedWidgetOrigin = readUrlOrigin(state.conversationUrl);
     if (!trustedWidgetOrigin) return;
     const handleWindowMessage = (event) => {
@@ -1313,14 +2113,14 @@ function SagepilotChatProvider({
     return () => window.removeEventListener("message", handleWindowMessage);
   }, [state.conversationUrl]);
   useEffect(() => {
-    if (Platform.OS !== "web" || !state.isPresented) return;
+    if (Platform2.OS !== "web" || !state.isPresented) return;
     postIdentityToWebFrame();
   }, [state.isPresented, state.conversationUrl, state.configured]);
   useEffect(() => {
-    if (Platform.OS === "web" || !state.isPresented) return;
+    if (Platform2.OS === "web" || !state.isPresented) return;
     postIdentityToNativeWebView();
   }, [state.isPresented, state.conversationUrl, state.configured]);
-  if (Platform.OS === "web") {
+  if (Platform2.OS === "web") {
     return createElement(
       View,
       { style: styles.root },
@@ -1363,10 +2163,18 @@ function SagepilotChatProvider({
     children,
     state.configured && !state.isPresented && state.shouldPreload && state.preloadUrl ? createElement(WebView, {
       ...hostedChatWebViewProps,
+      // Separate key from the hosted WebView: a hidden-preload renderer crash
+      // must not bump the hosted key (which would reset widgetReadyRef and
+      // disrupt an in-flight delivery). onRenderProcessGone must still be
+      // handled here or an unhandled renderer kill crashes the whole app.
+      key: `sagepilot-preload-webview-${preloadWebViewKey}`,
       source: { uri: state.preloadUrl },
       style: styles.preloadWebview,
       injectedJavaScriptBeforeContentLoaded: getInjectedWebViewScript(),
-      onMessage: handleWebViewMessage
+      onMessage: handleWebViewMessage,
+      onShouldStartLoadWithRequest: handleShouldStartLoadWithRequest,
+      onRenderProcessGone: recoverPreloadWebView,
+      onContentProcessDidTerminate: recoverPreloadWebView
     }) : null,
     createElement(
       Modal,
@@ -1374,8 +2182,8 @@ function SagepilotChatProvider({
         visible: state.configured && state.isPresented,
         animationType,
         presentationStyle: isFullScreenModal ? "fullScreen" : "pageSheet",
-        statusBarTranslucent: Platform.OS === "android",
-        navigationBarTranslucent: Platform.OS === "android",
+        statusBarTranslucent: Platform2.OS === "android",
+        navigationBarTranslucent: Platform2.OS === "android",
         onRequestClose: () => internalSagepilotChat.dismiss()
       },
       createElement(
@@ -1400,13 +2208,23 @@ function SagepilotChatProvider({
           ) : null,
           state.conversationUrl ? createElement(WebView, {
             ...hostedChatWebViewProps,
+            key: `sagepilot-hosted-webview-${nativeWebViewKey}`,
             ref: nativeWebViewRef,
             source: { uri: state.conversationUrl },
-            style: styles.webview,
+            // The imperceptible opacity toggle forces the Android WebView
+            // surface to re-composite on resume, clearing the blank-but-alive
+            // surface bug without a reload (see runLivenessProbe).
+            style: Platform2.OS === "android" ? [styles.webview, { opacity: 1 - androidRepaintTick % 2 * 1e-3 }] : styles.webview,
             startInLoadingState: true,
             injectedJavaScriptBeforeContentLoaded: getInjectedWebViewScript(),
             onMessage: handleWebViewMessage,
-            onLoadEnd: postIdentityToNativeWebView,
+            onLoadEnd: handleNativeWebViewLoadEnd,
+            onShouldStartLoadWithRequest: handleShouldStartLoadWithRequest,
+            // Android: render process killed (commonly while the camera/file
+            // chooser activity is foregrounded). Remount to recover.
+            onRenderProcessGone: recoverNativeWebView,
+            // iOS equivalent: WKWebView content process terminated.
+            onContentProcessDidTerminate: recoverNativeWebView,
             renderLoading: () => createElement(
               View,
               { style: styles.loading },
@@ -1416,6 +2234,48 @@ function SagepilotChatProvider({
           }) : null
         )
       )
+    ),
+    // Native attachment-source chooser. Replaces the Android Alert (capped at
+    // 3 buttons) so camera/library/documents all show on every platform.
+    createElement(
+      Modal,
+      {
+        visible: sourceChooser !== null,
+        transparent: true,
+        animationType: "fade",
+        statusBarTranslucent: true,
+        onRequestClose: () => setSourceChooser(null)
+      },
+      createElement(
+        Pressable,
+        { style: styles.sheetBackdrop, onPress: () => setSourceChooser(null) },
+        createElement(
+          View,
+          { style: styles.sheetCard },
+          createElement(Text, { style: styles.sheetTitle }, "Add attachment"),
+          ...(internalSagepilotChat.getConfig()?.filePicker?.sources ?? []).map(
+            (source) => createElement(
+              Pressable,
+              {
+                key: source,
+                accessibilityRole: "button",
+                style: styles.sheetButton,
+                onPress: () => handleSourceChoice(source)
+              },
+              createElement(Text, { style: styles.sheetButtonText }, FILE_PICKER_SOURCE_LABELS[source])
+            )
+          ),
+          createElement(
+            Pressable,
+            {
+              accessibilityRole: "button",
+              style: [styles.sheetButton, styles.sheetCancelButton],
+              onPress: () => setSourceChooser(null)
+            },
+            createElement(Text, { style: styles.sheetCancelText }, "Cancel")
+          )
+        )
+      )
     )
   );
 }
@@ -1514,6 +2374,46 @@ var styles = StyleSheet.create({
     marginTop: 12,
     color: "#4b5563",
     fontSize: 14
+  },
+  sheetBackdrop: {
+    flex: 1,
+    justifyContent: "flex-end",
+    backgroundColor: "rgba(17, 24, 39, 0.36)"
+  },
+  sheetCard: {
+    backgroundColor: "#ffffff",
+    borderTopLeftRadius: 16,
+    borderTopRightRadius: 16,
+    paddingTop: 8,
+    paddingBottom: 24,
+    paddingHorizontal: 8
+  },
+  sheetTitle: {
+    textAlign: "center",
+    color: "#6b7280",
+    fontSize: 13,
+    fontWeight: "600",
+    paddingVertical: 10
+  },
+  sheetButton: {
+    minHeight: 52,
+    alignItems: "center",
+    justifyContent: "center",
+    borderRadius: 12
+  },
+  sheetButtonText: {
+    color: "#111827",
+    fontSize: 16,
+    fontWeight: "500"
+  },
+  sheetCancelButton: {
+    marginTop: 6,
+    backgroundColor: "#f3f4f6"
+  },
+  sheetCancelText: {
+    color: "#111827",
+    fontSize: 16,
+    fontWeight: "600"
   }
 });
 
@@ -1549,6 +2449,9 @@ function useSagepilotChat() {
   }, []);
   const logout = useCallback2(() => SagepilotChat.logout(), []);
   const getUnreadCount = useCallback2(() => SagepilotChat.getUnreadCount(), []);
+  const onConversationCreated = useCallback2((callback) => {
+    return SagepilotChat.onConversationCreated(callback);
+  }, []);
   return {
     ...state,
     present,
@@ -1559,14 +2462,18 @@ function useSagepilotChat() {
     toggle,
     identify,
     logout,
-    getUnreadCount
+    getUnreadCount,
+    onConversationCreated
   };
 }
 export {
   SagepilotChat,
   SagepilotChatError,
   SagepilotChatProvider,
+  SagepilotFilePickerError,
   createAsyncStorageCacheStorage,
   createKeychainTokenStorage,
+  createSagepilotFilePicker,
+  createSagepilotFileStore,
   useSagepilotChat
 };