@sagepilot-ai/react-native-sdk 0.2.4 → 0.3.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sagepilot AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -12,13 +12,21 @@ The SDK opens the Sagepilot-hosted chat experience inside a React Native WebView
 - A Sagepilot workspace id and chat channel id
 - Secure token storage for production apps
 
-## Install
+## Install And Configure
+
+### 1. Install The Base Chat SDK
+
+Use this install when your app wants Sagepilot chat without Sagepilot's Android CameraX implementation:
 
 ```bash
 npm install @sagepilot-ai/react-native-sdk react-native-webview
 ```
 
-For secure persisted sessions, also install one storage library:
+This installs the base SDK only. It includes `SagepilotChat.configure`, hosted chat WebView, auth/session handling, the native bridge, attachment bridge protocol, `SagepilotFilePickerAdapter`, and custom picker support. It does not include CameraX or Android CameraX Gradle dependencies.
+
+### 2. Add Secure Session Storage
+
+For production apps, install one secure storage library so Sagepilot customer sessions survive app restarts.
 
 ```bash
 npm install react-native-keychain
@@ -30,6 +38,92 @@ Expo apps can use `expo-secure-store` instead:
 npx expo install expo-secure-store
 ```
 
+### 3. Configure The SDK
+
+Configure Sagepilot once when your app starts. The minimum working setup is:
+
+```ts
+import { SagepilotChat } from "@sagepilot-ai/react-native-sdk";
+
+await SagepilotChat.configure({
+  key: "workspace_id:channel_id"
+});
+```
+
+For production, pass secure token storage:
+
+```ts
+import * as Keychain from "react-native-keychain";
+import {
+  SagepilotChat,
+  createKeychainTokenStorage
+} from "@sagepilot-ai/react-native-sdk";
+
+await SagepilotChat.configure({
+  key: "workspace_id:channel_id",
+  tokenStorage: createKeychainTokenStorage(Keychain)
+});
+```
+
+Then mount `SagepilotChatProvider` once near the top of your app so the SDK can render the hosted chat WebView when you open it:
+
+```tsx
+import { useEffect, type ReactNode } from "react";
+import * as Keychain from "react-native-keychain";
+import {
+  SagepilotChat,
+  SagepilotChatProvider,
+  createKeychainTokenStorage
+} from "@sagepilot-ai/react-native-sdk";
+
+function SagepilotProvider({ children }: { children: ReactNode }) {
+  useEffect(() => {
+    void SagepilotChat.configure({
+      key: "workspace_id:channel_id",
+      tokenStorage: createKeychainTokenStorage(Keychain)
+    });
+
+    return () => {
+      SagepilotChat.destroy();
+    };
+  }, []);
+
+  return <SagepilotChatProvider>{children}</SagepilotChatProvider>;
+}
+
+export function App() {
+  return (
+    <SagepilotProvider>
+      <RootNavigator />
+    </SagepilotProvider>
+  );
+}
+```
+
+### 4. Optional: Add Sagepilot Android CameraX
+
+Install this addon only when you want Sagepilot's Android in-app CameraX picker. Apps that skip this step keep the smaller base SDK install.
+
+```bash
+npm install @sagepilot-ai/react-native-camera-addon
+```
+
+After installing the addon, run a fresh native Android build. A Metro reload is not enough for React Native autolinking to register `NativeModules.SagepilotInAppCamera`.
+
+Then pass the addon picker into `SagepilotChat.configure`:
+
+```ts
+import { SagepilotChat } from "@sagepilot-ai/react-native-sdk";
+import { createSagepilotCameraXFilePicker } from "@sagepilot-ai/react-native-camera-addon";
+
+await SagepilotChat.configure({
+  key: "workspace_id:channel_id",
+  filePicker: createSagepilotCameraXFilePicker()
+});
+```
+
+With this setup, the base SDK still owns chat configuration, hosted WebView rendering, auth/session, and the bridge. The camera addon owns CameraX dependencies, native module registration, camera activity, overlay, and image processing.
+
 ## Configuration Values
 
 You configure the SDK with:
@@ -178,6 +272,105 @@ export function ChatLauncher() {
 }
 ```
 
+## Native File Picker
+
+By default, the hosted chat widget's attach button uses the WebView's `<input type="file">`. On low-RAM Android devices this is unreliable: while the system camera is in the foreground, Android can kill the WebView render process, leaving a dead white screen and losing the captured photo.
+
+Configure `filePicker` so the attach button uses native pickers instead. Captured files are delivered to the widget over a hardened bridge (protocol v2): they are held in app memory **and** mirrored to `cacheStorage`, then **re-delivered until the widget acknowledges them** — surviving the WebView hydration race, renderer crashes, and (for small batches) full app-process death. Pending batches are pinned to the hosted chat route that requested them, so a recovered photo is re-delivered to the originating thread. On Android the SDK also runs a liveness watchdog on app-resume that repaints and, if the widget is confirmed dead, remounts the WebView.
+
+The base package does not include CameraX. Apps that want the smallest install can use only:
+
+```bash
+npm install @sagepilot-ai/react-native-sdk react-native-webview
+```
+
+### Optional Android CameraX Addon
+
+Install the CameraX addon only when you want Sagepilot's Android in-app camera implementation:
+
+```bash
+npm install @sagepilot-ai/react-native-camera-addon
+```
+
+Run a clean native Android rebuild after installing the addon. If you only Metro-reload, the native module is not linked yet and `createSagepilotCameraXFilePicker()` returns `undefined`, so the hosted widget falls back to the WebView file input.
+
+Then configure the addon adapter:
+
+```ts
+import { SagepilotChat } from "@sagepilot-ai/react-native-sdk";
+import { createSagepilotCameraXFilePicker } from "@sagepilot-ai/react-native-camera-addon";
+
+await SagepilotChat.configure({
+  key: "workspace_id:channel_id",
+  filePicker: createSagepilotCameraXFilePicker()
+});
+```
+
+The addon owns the Android CameraX Gradle dependencies, `CAMERA` permission merge, native module, camera activity, overlay, and image processing. The base SDK continues to own the hosted chat WebView, auth/session, bridge, attachment protocol, and `SagepilotFilePickerAdapter` type.
+
+For the strongest resilience (a photo captured right before the OS kills the app survives the restart, at any size), pass BOTH `cacheStorage` (stores the tiny manifest) and `fileStore` (stores the bytes on disk). `cacheStorage` alone keeps only small (≤~2MB) batches durable, because Android's AsyncStorage caps a single row near 2MB; `fileStore` lifts that limit by writing bytes to an app-private file and persisting only file keys in the manifest:
+
+```ts
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import ReactNativeBlobUtil from "react-native-blob-util";
+import { createAsyncStorageCacheStorage, createSagepilotFileStore } from "@sagepilot-ai/react-native-sdk";
+import { createSagepilotCameraXFilePicker } from "@sagepilot-ai/react-native-camera-addon";
+
+await SagepilotChat.configure({
+  key: "workspace_id:channel_id",
+  cacheStorage: createAsyncStorageCacheStorage(AsyncStorage),
+  fileStore: createSagepilotFileStore(ReactNativeBlobUtil),
+  filePicker: createSagepilotCameraXFilePicker()
+});
+```
+
+### Host-Provided Pickers
+
+You can also provide your own picker modules to the base SDK. Modules are passed in rather than imported by the SDK, so Metro never resolves packages your app did not install.
+
+Install the optional dependencies your app needs:
+
+```sh
+# Camera/gallery through react-native-image-picker
+npm install react-native-image-picker
+
+# Document/file picking (optional)
+npm install @react-native-documents/picker
+
+# Reliable document reads (optional, recommended with the documents picker)
+npm install react-native-blob-util
+```
+
+Then pass the modules to `createSagepilotFilePicker`:
+
+```ts
+import * as imagePicker from "react-native-image-picker";
+import * as documentsPicker from "@react-native-documents/picker";
+import ReactNativeBlobUtil from "react-native-blob-util";
+import {
+  SagepilotChat,
+  createSagepilotFilePicker
+} from "@sagepilot-ai/react-native-sdk";
+
+await SagepilotChat.configure({
+  key: "workspace_id:channel_id",
+  filePicker: createSagepilotFilePicker({
+    imagePicker,
+    documentsPicker,
+    fileReader: ReactNativeBlobUtil
+  })
+});
+```
+
+Notes:
+
+- Android CameraX images are captured by `@sagepilot-ai/react-native-camera-addon` and downscaled natively (1920px longest edge, JPEG quality 0.8 by default; override with `imageMaxDimension` / `imageQuality`). This keeps memory and upload sizes low on constrained devices.
+- The CameraX addon can also expose Android Photo Picker and document sources from its native module. The base `createSagepilotFilePicker(...)` helper uses only the host-provided modules you pass into it.
+- Gallery multi-select is capped at 5 by default (`imageSelectionLimit`); documents are rejected above 20MB (`documentMaxFileSizeBytes`) and images above 15MB (`imageMaxFileSizeBytes`) **before** they are read into memory, preventing out-of-memory crashes on large files.
+- Failures are never silent: the picker distinguishes user-cancel from real errors and surfaces a typed `code` (`permission_denied`, `camera_unavailable`, `encode_failed`, `file_too_large`, `read_failed`) to the widget.
+- Android apps that install the CameraX addon must grant `CAMERA` at runtime; the addon requests it automatically before opening the camera and surfaces a clear message (with a Settings hint) when it is denied. iOS apps using `react-native-image-picker` need `NSCameraUsageDescription` and `NSPhotoLibraryUsageDescription` in `Info.plist`.
+- Apps that skip `filePicker` keep the WebView file input. The SDK still recovers from WebView renderer crashes by reloading the widget, but a photo captured at crash time cannot be restored in that mode.
+
 ## Secure Session Storage
 
 The SDK creates opaque customer session tokens at runtime. These tokens are not exposed through hooks or public session APIs.
@@ -225,7 +418,7 @@ Configure the SDK after your app knows the current workspace/channel and, if ava
 
 ```tsx
 import * as Keychain from "react-native-keychain";
-import { useEffect } from "react";
+import { useEffect, type ReactNode } from "react";
 import {
   SagepilotChat,
   SagepilotChatProvider,
@@ -234,7 +427,7 @@ import {
 
 const tokenStorage = createKeychainTokenStorage(Keychain);
 
-export function SagepilotProvider({ children }: { children: React.ReactNode }) {
+export function SagepilotProvider({ children }: { children: ReactNode }) {
   useEffect(() => {
     let cancelled = false;
 

package/android/build.gradle

@@ -3,18 +3,23 @@ buildscript {
     google()
     mavenCentral()
   }
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.5.0"
+  }
 }
 
-plugins {
-  id "com.android.library"
-}
+apply plugin: "com.android.library"
 
 def isNewArchitectureEnabled() {
   return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
 }
 
 if (isNewArchitectureEnabled()) {
-  apply plugin: "com.facebook.react"
+  try {
+    apply plugin: "com.facebook.react"
+  } catch (e) {
+    logger.warn("Could not apply 'com.facebook.react' plugin. This is expected if syncing the library standalone.")
+  }
 }
 
 def safeExtGet(prop, fallback) {
@@ -31,6 +36,10 @@ android {
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
   }
 
+  buildFeatures {
+    buildConfig true
+  }
+
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_17
     targetCompatibility JavaVersion.VERSION_17

package/android/src/main/java/ai/sagepilot/reactnativesdk/SagepilotReactNativeSdkPackage.java

@@ -8,11 +8,13 @@ import java.util.Collections;
 import java.util.List;
 
 public class SagepilotReactNativeSdkPackage implements ReactPackage {
+  /** Registers SDK-owned native modules exposed to JavaScript. */
   @Override
   public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
     return Collections.emptyList();
   }
 
+  /** Registers the existing SDK view managers without changing their surface. */
   @Override
   public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
     return Collections.singletonList(new SagepilotInsetsViewManager());

package/dist/index.d.mts

@@ -1,5 +1,203 @@
 import { ReactNode } from 'react';
 
+/**
+ * Wire shape delivered to the hosted widget. Matches the Customer API
+ * attachment input (`data_base64`) so the widget can reuse its existing
+ * validation and send path without backend changes.
+ */
+type SagepilotPickedFile = {
+    file_name: string;
+    mime_type: string;
+    size: number;
+    data_base64: string;
+};
+type SagepilotFilePickerErrorCode = "permission_denied" | "camera_unavailable" | "encode_failed" | "file_too_large" | "read_failed" | "unknown";
+/**
+ * Structured picker failure. The provider maps `.code` to a user-facing message
+ * and surfaces it via sagepilot:file_picker_error so a failed capture is never
+ * silently swallowed.
+ */
+declare class SagepilotFilePickerError extends Error {
+    readonly code: SagepilotFilePickerErrorCode;
+    /** Creates a typed picker error that can be surfaced over the widget bridge. */
+    constructor(code: SagepilotFilePickerErrorCode, message: string);
+}
+declare const SAGEPILOT_DEFAULT_IMAGE_MAX_DIMENSION = 1920;
+declare const SAGEPILOT_DEFAULT_IMAGE_QUALITY = 0.8;
+declare const SAGEPILOT_DEFAULT_IMAGE_MAX_FILE_SIZE_BYTES: number;
+
+type SagepilotFilePickerSource = "camera" | "library" | "documents";
+type SagepilotFilePickerRequest = {
+    source: SagepilotFilePickerSource;
+    multiple: boolean;
+};
+/**
+ * Host-app-provided native file picker. When configured, the hosted widget's
+ * attach button routes through native pickers instead of the WebView's
+ * `<input type="file">`. This is required for reliable camera capture on
+ * low-RAM Android devices: the OS can kill the WebView render process while
+ * the camera activity is foregrounded, which destroys any in-WebView file
+ * chooser state. Natively captured files survive that kill and are
+ * re-delivered after the WebView reloads.
+ */
+type SagepilotFilePickerAdapter = {
+    /** Sources offered to the customer in the attachment chooser. */
+    sources: SagepilotFilePickerSource[];
+    /** Resolves picked files, or an empty array when the customer cancels. */
+    pickFiles: (request: SagepilotFilePickerRequest) => Promise<SagepilotPickedFile[]>;
+};
+/** Structural subset of `react-native-image-picker` used by the SDK. */
+type SagepilotImagePickerModule = {
+    launchCamera: (options: Record<string, unknown>) => Promise<SagepilotImagePickerResult>;
+    launchImageLibrary: (options: Record<string, unknown>) => Promise<SagepilotImagePickerResult>;
+};
+type SagepilotImagePickerResult = {
+    didCancel?: boolean;
+    errorCode?: string;
+    errorMessage?: string;
+    assets?: Array<{
+        fileName?: string | null;
+        type?: string | null;
+        fileSize?: number | null;
+        base64?: string | null;
+        uri?: string | null;
+    }>;
+};
+/** Structural subset of `@react-native-documents/picker` used by the SDK. */
+type SagepilotDocumentsPickerModule = {
+    pick: (options?: Record<string, unknown>) => Promise<Array<{
+        uri: string;
+        name: string | null;
+        size: number | null;
+        type: string | null;
+    }>>;
+    keepLocalCopy?: (options: {
+        files: Array<{
+            uri: string;
+            fileName: string;
+        }>;
+        destination: "cachesDirectory" | "documentDirectory";
+    }) => Promise<Array<{
+        status: string;
+        sourceUri: string;
+        localUri?: string;
+        copyError?: string;
+    }>>;
+};
+/** Structural subset of `react-native-blob-util` used for document reads. */
+type SagepilotFileReaderModule = {
+    fs: {
+        readFile: (path: string, encoding: string) => Promise<unknown>;
+    };
+};
+type SagepilotCreateFilePickerOptions = {
+    imagePicker?: SagepilotImagePickerModule;
+    documentsPicker?: SagepilotDocumentsPickerModule;
+    /** Optional `react-native-blob-util` for reliable document reads. */
+    fileReader?: SagepilotFileReaderModule;
+    /**
+     * Longest image edge in pixels for camera/library picks. Downscaling
+     * natively keeps memory and upload size low on low-RAM devices.
+     */
+    imageMaxDimension?: number;
+    /** JPEG quality (0-1) applied to camera/library picks. */
+    imageQuality?: number;
+    /**
+     * Max images per gallery selection. Defaults to 5. Set 0 for unlimited
+     * (not recommended: a large batch produces a multi-megabyte bridge payload).
+     */
+    imageSelectionLimit?: number;
+    /** Reject documents larger than this (bytes) before reading them. */
+    documentMaxFileSizeBytes?: number;
+    /** Reject camera/library images larger than this (bytes). */
+    imageMaxFileSizeBytes?: number;
+};
+/** Shows an actionable Android settings prompt after permanent camera denial. */
+declare function promptOpenSagepilotCameraSettings(): Promise<void>;
+/**
+ * Android apps that declare the CAMERA permission must also hold it at runtime
+ * before the SDK-owned camera screen can open. Request it defensively; apps
+ * that never declared it are unaffected and native launch can surface the real
+ * failure.
+ */
+declare function ensureSagepilotAndroidCameraPermission(): Promise<void>;
+/**
+ * Builds the SDK file picker adapter from host-app-installed native modules.
+ * Modules are passed in (rather than required by the SDK) so Metro never
+ * tries to resolve packages the host app has not installed.
+ *
+ * @example
+ * import * as imagePicker from "react-native-image-picker";
+ * import * as documentsPicker from "@react-native-documents/picker";
+ *
+ * SagepilotChat.configure({
+ *   key: "...",
+ *   filePicker: createSagepilotFilePicker({ imagePicker, documentsPicker })
+ * });
+ */
+declare function createSagepilotFilePicker(options: SagepilotCreateFilePickerOptions): SagepilotFilePickerAdapter | undefined;
+
+/**
+ * Durable file outbox for natively-picked attachments.
+ *
+ * Persisting attachment BYTES in `cacheStorage` (AsyncStorage) does not scale:
+ * Android's SQLite-backed store caps a single row at ~2MB (CursorWindow), so a
+ * multi-megabyte capture cannot be stored there at all. Instead we write the
+ * bytes to a stable app-private file and persist only a tiny manifest of file
+ * keys + metadata in `cacheStorage`. This makes durability size-independent and
+ * lets a capture survive a full app-process death during the camera round-trip.
+ *
+ * The store is built from the host app's `react-native-blob-util` so the SDK
+ * itself depends on no filesystem package (same injection pattern as the
+ * native file picker).
+ */
+/** Structural subset of `react-native-blob-util` used by the file store. */
+type SagepilotBlobUtilLike = {
+    fs: {
+        dirs: {
+            DocumentDir: string;
+        };
+        writeFile: (path: string, data: string, encoding: string) => Promise<unknown>;
+        readFile: (path: string, encoding: string) => Promise<unknown>;
+        unlink: (path: string) => Promise<unknown>;
+        exists: (path: string) => Promise<boolean>;
+        ls: (path: string) => Promise<string[]>;
+        mkdir: (path: string) => Promise<unknown>;
+    };
+};
+/**
+ * Persists attachment bytes to disk under stable, app-private keys. Keys (not
+ * absolute paths) are stored in the manifest so persistence survives the
+ * platform relocating the app container between launches (notably iOS).
+ */
+type SagepilotPersistedFileStore = {
+    /** Writes base64 content under `key`; resolves once durably on disk. */
+    write: (key: string, base64: string) => Promise<void>;
+    /** Reads previously-written content back as base64. */
+    read: (key: string) => Promise<string>;
+    /** Best-effort delete of a single key. */
+    remove: (key: string) => Promise<void>;
+    /** Best-effort delete of every stored file whose key is not in `keepKeys`. */
+    prune: (keepKeys: string[]) => Promise<void>;
+};
+type SagepilotCreateFileStoreOptions = {
+    /** Sub-directory under DocumentDir. Defaults to "sagepilot-attachments". */
+    directoryName?: string;
+};
+/**
+ * Builds a {@link SagepilotPersistedFileStore} backed by react-native-blob-util.
+ *
+ * @example
+ * import ReactNativeBlobUtil from "react-native-blob-util";
+ * SagepilotChat.configure({
+ *   key: "...",
+ *   cacheStorage: createAsyncStorageCacheStorage(AsyncStorage),
+ *   fileStore: createSagepilotFileStore(ReactNativeBlobUtil),
+ *   filePicker: createSagepilotFilePicker({ imagePicker, documentsPicker, fileReader: ReactNativeBlobUtil })
+ * });
+ */
+declare function createSagepilotFileStore(blobUtil: SagepilotBlobUtilLike, options?: SagepilotCreateFileStoreOptions): SagepilotPersistedFileStore;
+
 type SagepilotMobilePresentationStyle = "sheet" | "fullScreen" | "push";
 type SagepilotMobileColorScheme = "system" | "light" | "dark";
 type SagepilotChatErrorCode = "invalid_config" | "not_initialized" | "already_initialized" | "network_error" | "invalid_response" | "invalid_request" | "unauthorized" | "forbidden" | "session_not_found" | "session_expired" | "channel_not_found" | "conversation_not_found" | "message_not_found" | "contact_required" | "otp_required" | "otp_invalid" | "otp_expired" | "identity_verification_failed" | "rate_limited" | "idempotency_conflict" | "not_implemented" | "internal_error";
@@ -110,6 +308,22 @@ type SagepilotMobileConfig = {
     cacheStorage?: SagepilotCacheStorage;
     deviceInfo?: SagepilotDeviceInfoAdapter;
     biometrics?: SagepilotBiometricsAdapter;
+    /**
+     * Native file picker used by the hosted chat widget's attach button.
+     * Strongly recommended: in-WebView camera capture is unreliable on
+     * low-RAM Android devices (the OS can kill the WebView render process
+     * while the camera is open). Build with createSagepilotFilePicker() or
+     * the optional @sagepilot-ai/react-native-camera-addon package.
+     */
+    filePicker?: SagepilotFilePickerAdapter;
+    /**
+     * Durable on-disk store for picked attachments. When provided, a captured
+     * photo/document survives a full app-process death during the camera
+     * round-trip (the SDK rehydrates and re-delivers it on relaunch), with no
+     * size limit. Without it, durability falls back to small batches stored in
+     * cacheStorage. Build with createSagepilotFileStore(ReactNativeBlobUtil).
+     */
+    fileStore?: SagepilotPersistedFileStore;
     presentation?: SagepilotMobilePresentationConfig;
     theme?: SagepilotMobileThemeConfig;
     behavior?: SagepilotMobileBehaviorConfig;
@@ -342,4 +556,4 @@ declare function SagepilotChatProvider({ children, closeLabel, loadingLabel }: S
 
 declare function useSagepilotChat(): SagepilotChatHookState;
 
-export { type SagepilotBiometricsAdapter, type SagepilotBootstrapChannelResponse, type SagepilotCacheStorage, SagepilotChat, SagepilotChatError, type SagepilotChatErrorCode, type SagepilotChatHookState, SagepilotChatProvider, type SagepilotChatProviderProps, type SagepilotConversationCreatedEvent, type SagepilotDeviceInfo, type SagepilotDeviceInfoAdapter, type SagepilotIdentifyResult, type SagepilotIdentity, type SagepilotIdentityState, type SagepilotLifecycleState, type SagepilotLogoutResponse, type SagepilotMessageComposerOptions, type SagepilotMobileBehaviorConfig, type SagepilotMobileColorScheme, type SagepilotMobileConfig, type SagepilotMobileConfigureResult, type SagepilotMobileLauncherConfig, type SagepilotMobilePresentationConfig, type SagepilotMobilePresentationStyle, type SagepilotMobileResolvedLauncherConfig, type SagepilotMobileState, type SagepilotMobileSubscription, type SagepilotMobileThemeConfig, type SagepilotMobileThemeState, type SagepilotSessionState, type SagepilotTokenStorage, type SagepilotUnreadState, createAsyncStorageCacheStorage, createKeychainTokenStorage, useSagepilotChat };
+export { SAGEPILOT_DEFAULT_IMAGE_MAX_DIMENSION, SAGEPILOT_DEFAULT_IMAGE_MAX_FILE_SIZE_BYTES, SAGEPILOT_DEFAULT_IMAGE_QUALITY, type SagepilotBiometricsAdapter, type SagepilotBlobUtilLike, type SagepilotBootstrapChannelResponse, type SagepilotCacheStorage, SagepilotChat, SagepilotChatError, type SagepilotChatErrorCode, type SagepilotChatHookState, SagepilotChatProvider, type SagepilotChatProviderProps, type SagepilotConversationCreatedEvent, type SagepilotCreateFilePickerOptions, type SagepilotCreateFileStoreOptions, type SagepilotDeviceInfo, type SagepilotDeviceInfoAdapter, type SagepilotDocumentsPickerModule, type SagepilotFilePickerAdapter, SagepilotFilePickerError, type SagepilotFilePickerErrorCode, type SagepilotFilePickerRequest, type SagepilotFilePickerSource, type SagepilotFileReaderModule, type SagepilotIdentifyResult, type SagepilotIdentity, type SagepilotIdentityState, type SagepilotImagePickerModule, type SagepilotImagePickerResult, type SagepilotLifecycleState, type SagepilotLogoutResponse, type SagepilotMessageComposerOptions, type SagepilotMobileBehaviorConfig, type SagepilotMobileColorScheme, type SagepilotMobileConfig, type SagepilotMobileConfigureResult, type SagepilotMobileLauncherConfig, type SagepilotMobilePresentationConfig, type SagepilotMobilePresentationStyle, type SagepilotMobileResolvedLauncherConfig, type SagepilotMobileState, type SagepilotMobileSubscription, type SagepilotMobileThemeConfig, type SagepilotMobileThemeState, type SagepilotPersistedFileStore, type SagepilotPickedFile, type SagepilotSessionState, type SagepilotTokenStorage, type SagepilotUnreadState, createAsyncStorageCacheStorage, createKeychainTokenStorage, createSagepilotFilePicker, createSagepilotFileStore, ensureSagepilotAndroidCameraPermission, promptOpenSagepilotCameraSettings, useSagepilotChat };