@reverbia/sdk 1.0.0-next.20251217123222 → 1.0.0-next.20251217144159

package/dist/react/index.mjs

@@ -1440,20 +1440,42 @@ Please inform the user about this issue and try to help them alternatively.`
             }
           });
           const accumulator = createStreamAccumulator();
-          for await (const chunk of sseResult.stream) {
-            if (isDoneMarker(chunk)) {
-              continue;
-            }
-            if (chunk && typeof chunk === "object") {
-              const contentDelta = processStreamingChunk(
-                chunk,
-                accumulator
-              );
-              if (contentDelta) {
-                if (onData) onData(contentDelta);
-                if (globalOnData) globalOnData(contentDelta);
+          try {
+            for await (const chunk of sseResult.stream) {
+              if (isDoneMarker(chunk)) {
+                continue;
+              }
+              if (chunk && typeof chunk === "object") {
+                const contentDelta = processStreamingChunk(
+                  chunk,
+                  accumulator
+                );
+                if (contentDelta) {
+                  if (onData) onData(contentDelta);
+                  if (globalOnData) globalOnData(contentDelta);
+                }
               }
             }
+          } catch (streamErr) {
+            if (isAbortError(streamErr) || abortController.signal.aborted) {
+              setIsLoading(false);
+              const partialCompletion = buildCompletionResponse(accumulator);
+              return {
+                data: partialCompletion,
+                error: "Request aborted",
+                toolExecution: toolExecutionResult
+              };
+            }
+            throw streamErr;
+          }
+          if (abortController.signal.aborted) {
+            setIsLoading(false);
+            const partialCompletion = buildCompletionResponse(accumulator);
+            return {
+              data: partialCompletion,
+              error: "Request aborted",
+              toolExecution: toolExecutionResult
+            };
           }
           if (sseError) {
             throw sseError;
@@ -1678,7 +1700,8 @@ function messageToStored(message) {
     embeddingModel: message.embeddingModel,
     usage: message.usage,
     sources: message.sources,
-    responseDuration: message.responseDuration
+    responseDuration: message.responseDuration,
+    wasStopped: message.wasStopped
   };
 }
 function conversationToStored(conversation) {
@@ -1767,6 +1790,7 @@ async function createMessageOp(ctx, opts) {
         msg._setRaw("response_duration", opts.responseDuration);
       if (opts.vector) msg._setRaw("vector", JSON.stringify(opts.vector));
       if (opts.embeddingModel) msg._setRaw("embedding_model", opts.embeddingModel);
+      if (opts.wasStopped) msg._setRaw("was_stopped", opts.wasStopped);
     });
   });
   return messageToStored(created);
@@ -2057,6 +2081,45 @@ function useChatStorage(options) {
       });
       const responseDuration = (Date.now() - startTime) / 1e3;
       if (result.error || !result.data) {
+        const abortedResult = result;
+        if (abortedResult.error === "Request aborted") {
+          const assistantContent2 = abortedResult.data?.choices?.[0]?.message?.content?.map((part) => part.text || "").join("") || "";
+          const responseModel = abortedResult.data?.model || model || "";
+          let storedAssistantMessage2;
+          try {
+            storedAssistantMessage2 = await createMessageOp(storageCtx, {
+              conversationId: convId,
+              role: "assistant",
+              content: assistantContent2,
+              model: responseModel,
+              usage: convertUsageToStored(abortedResult.data?.usage),
+              responseDuration,
+              wasStopped: true
+            });
+            const completionData = abortedResult.data || {
+              id: `aborted-${Date.now()}`,
+              model: responseModel,
+              choices: [{
+                index: 0,
+                message: {
+                  role: "assistant",
+                  content: [{ type: "text", text: assistantContent2 }]
+                },
+                finish_reason: "stop"
+              }],
+              usage: void 0
+            };
+            return {
+              data: completionData,
+              error: null,
+              // Treat as success to the caller
+              toolExecution: abortedResult.toolExecution,
+              userMessage: storedUserMessage,
+              assistantMessage: storedAssistantMessage2
+            };
+          } catch (err) {
+          }
+        }
         return {
           data: null,
           error: result.error || "No response data received",
@@ -2128,8 +2191,9 @@ function useChatStorage(options) {
 
 // src/lib/chatStorage/schema.ts
 import { appSchema, tableSchema } from "@nozbe/watermelondb";
+import { schemaMigrations, addColumns } from "@nozbe/watermelondb/Schema/migrations";
 var chatStorageSchema = appSchema({
-  version: 1,
+  version: 2,
   tables: [
     tableSchema({
       name: "history",
@@ -2152,7 +2216,8 @@ var chatStorageSchema = appSchema({
         // JSON stringified ChatCompletionUsage
         { name: "sources", type: "string", isOptional: true },
         // JSON stringified SearchSource[]
-        { name: "response_duration", type: "number", isOptional: true }
+        { name: "response_duration", type: "number", isOptional: true },
+        { name: "was_stopped", type: "boolean", isOptional: true }
       ]
     }),
     tableSchema({
@@ -2167,6 +2232,21 @@ var chatStorageSchema = appSchema({
     })
   ]
 });
+var chatStorageMigrations = schemaMigrations({
+  migrations: [
+    {
+      toVersion: 2,
+      steps: [
+        addColumns({
+          table: "history",
+          columns: [
+            { name: "was_stopped", type: "boolean", isOptional: true }
+          ]
+        })
+      ]
+    }
+  ]
+});
 
 // src/lib/chatStorage/models.ts
 import { Model } from "@nozbe/watermelondb";
@@ -2250,6 +2330,10 @@ var Message = class extends Model {
     const value = this._getRaw("response_duration");
     return value !== null && value !== void 0 ? value : void 0;
   }
+  /** Whether the message generation was stopped by the user */
+  get wasStopped() {
+    return this._getRaw("was_stopped");
+  }
 };
 Message.table = "history";
 Message.associations = {
@@ -3452,8 +3536,180 @@ var Memory = class extends Model2 {
 };
 Memory.table = "memories";
 
+// src/react/useSettings.ts
+import { useCallback as useCallback4, useState as useState4, useMemo as useMemo3, useEffect as useEffect2 } from "react";
+
+// src/lib/settingsStorage/operations.ts
+import { Q as Q3 } from "@nozbe/watermelondb";
+function modelPreferenceToStored(preference) {
+  return {
+    uniqueId: preference.id,
+    walletAddress: preference.walletAddress,
+    models: preference.models
+  };
+}
+async function getModelPreferenceOp(ctx, walletAddress) {
+  const results = await ctx.modelPreferencesCollection.query(Q3.where("wallet_address", walletAddress)).fetch();
+  return results.length > 0 ? modelPreferenceToStored(results[0]) : null;
+}
+async function setModelPreferenceOp(ctx, walletAddress, models) {
+  const result = await ctx.database.write(async () => {
+    const results = await ctx.modelPreferencesCollection.query(Q3.where("wallet_address", walletAddress)).fetch();
+    if (results.length > 0) {
+      const preference = results[0];
+      await preference.update((pref) => {
+        if (models !== void 0) {
+          pref._setRaw("models", models || null);
+        }
+      });
+      return preference;
+    }
+    return await ctx.modelPreferencesCollection.create((pref) => {
+      pref._setRaw("wallet_address", walletAddress);
+      if (models) pref._setRaw("models", models);
+    });
+  });
+  return modelPreferenceToStored(result);
+}
+async function deleteModelPreferenceOp(ctx, walletAddress) {
+  const results = await ctx.modelPreferencesCollection.query(Q3.where("wallet_address", walletAddress)).fetch();
+  if (results.length === 0) return false;
+  await ctx.database.write(async () => {
+    await results[0].destroyPermanently();
+  });
+  return true;
+}
+
+// src/react/useSettings.ts
+function useSettings(options) {
+  const { database, walletAddress } = options;
+  const [modelPreference, setModelPreferenceState] = useState4(null);
+  const [isLoading, setIsLoading] = useState4(false);
+  const modelPreferencesCollection = useMemo3(
+    () => database.get("modelPreferences"),
+    [database]
+  );
+  const storageCtx = useMemo3(
+    () => ({
+      database,
+      modelPreferencesCollection
+    }),
+    [database, modelPreferencesCollection]
+  );
+  const getModelPreference = useCallback4(
+    async (address) => {
+      try {
+        if (!address) throw new Error("Wallet address is required");
+        const result = await getModelPreferenceOp(storageCtx, address);
+        return result;
+      } catch (error) {
+        throw new Error(
+          error instanceof Error ? error.message : "An unknown error occurred"
+        );
+      }
+    },
+    [storageCtx]
+  );
+  const setModelPreference = useCallback4(
+    async (address, models) => {
+      try {
+        if (!address) throw new Error("Wallet address is required");
+        const result = await setModelPreferenceOp(storageCtx, address, models);
+        if (walletAddress && address === walletAddress) {
+          setModelPreferenceState(result);
+        }
+        return result;
+      } catch (error) {
+        throw new Error(
+          error instanceof Error ? error.message : "An unknown error occurred"
+        );
+      }
+    },
+    [storageCtx, walletAddress]
+  );
+  const deleteModelPreference = useCallback4(
+    async (address) => {
+      try {
+        if (!address) throw new Error("Wallet address is required");
+        const deleted = await deleteModelPreferenceOp(storageCtx, address);
+        if (deleted && walletAddress && address === walletAddress) {
+          setModelPreferenceState(null);
+        }
+        return deleted;
+      } catch (error) {
+        throw new Error(
+          error instanceof Error ? error.message : "An unknown error occurred"
+        );
+      }
+    },
+    [storageCtx, walletAddress]
+  );
+  useEffect2(() => {
+    if (!walletAddress) {
+      setModelPreferenceState(null);
+      return;
+    }
+    let cancelled = false;
+    const loadPreference = async () => {
+      setIsLoading(true);
+      try {
+        const preference = await getModelPreference(walletAddress);
+        if (!cancelled) {
+          setModelPreferenceState(preference);
+        }
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    };
+    loadPreference();
+    return () => {
+      cancelled = true;
+    };
+  }, [walletAddress, getModelPreference]);
+  return {
+    modelPreference,
+    isLoading,
+    getModelPreference,
+    setModelPreference,
+    deleteModelPreference
+  };
+}
+
+// src/lib/settingsStorage/schema.ts
+import { appSchema as appSchema3, tableSchema as tableSchema3 } from "@nozbe/watermelondb";
+var settingsStorageSchema = appSchema3({
+  version: 1,
+  tables: [
+    tableSchema3({
+      name: "modelPreferences",
+      columns: [
+        { name: "wallet_address", type: "string", isIndexed: true },
+        { name: "models", type: "string", isOptional: true }
+        // stored as JSON stringified ModelPreference[]
+      ]
+    })
+  ]
+});
+
+// src/lib/settingsStorage/models.ts
+import { Model as Model3 } from "@nozbe/watermelondb";
+var ModelPreference = class extends Model3 {
+  /** User's wallet address */
+  get walletAddress() {
+    return this._getRaw("wallet_address");
+  }
+  /** Preferred model identifier */
+  get models() {
+    const value = this._getRaw("models");
+    return value ? value : void 0;
+  }
+};
+ModelPreference.table = "modelPreferences";
+
 // src/react/usePdf.ts
-import { useCallback as useCallback4, useState as useState4 } from "react";
+import { useCallback as useCallback5, useState as useState5 } from "react";
 
 // src/lib/pdf.ts
 import * as pdfjs from "pdfjs-dist";
@@ -3506,9 +3762,9 @@ async function convertPdfToImages(pdfDataUrl) {
 // src/react/usePdf.ts
 var PDF_MIME_TYPE = "application/pdf";
 function usePdf() {
-  const [isProcessing, setIsProcessing] = useState4(false);
-  const [error, setError] = useState4(null);
-  const extractPdfContext = useCallback4(
+  const [isProcessing, setIsProcessing] = useState5(false);
+  const [error, setError] = useState5(null);
+  const extractPdfContext = useCallback5(
     async (files) => {
       setIsProcessing(true);
       setError(null);
@@ -3555,12 +3811,12 @@ ${text}`;
 }
 
 // src/react/useOCR.ts
-import { useCallback as useCallback5, useState as useState5 } from "react";
+import { useCallback as useCallback6, useState as useState6 } from "react";
 import Tesseract from "tesseract.js";
 function useOCR() {
-  const [isProcessing, setIsProcessing] = useState5(false);
-  const [error, setError] = useState5(null);
-  const extractOCRContext = useCallback5(
+  const [isProcessing, setIsProcessing] = useState6(false);
+  const [error, setError] = useState6(null);
+  const extractOCRContext = useCallback6(
     async (files) => {
       setIsProcessing(true);
       setError(null);
@@ -3646,22 +3902,22 @@ ${text}`;
 }
 
 // src/react/useModels.ts
-import { useCallback as useCallback6, useEffect as useEffect2, useRef as useRef3, useState as useState6 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect3, useRef as useRef3, useState as useState7 } from "react";
 function useModels(options = {}) {
   const { getToken, baseUrl = BASE_URL, provider, autoFetch = true } = options;
-  const [models, setModels] = useState6([]);
-  const [isLoading, setIsLoading] = useState6(false);
-  const [error, setError] = useState6(null);
+  const [models, setModels] = useState7([]);
+  const [isLoading, setIsLoading] = useState7(false);
+  const [error, setError] = useState7(null);
   const getTokenRef = useRef3(getToken);
   const baseUrlRef = useRef3(baseUrl);
   const providerRef = useRef3(provider);
   const abortControllerRef = useRef3(null);
-  useEffect2(() => {
+  useEffect3(() => {
     getTokenRef.current = getToken;
     baseUrlRef.current = baseUrl;
     providerRef.current = provider;
   });
-  useEffect2(() => {
+  useEffect3(() => {
     return () => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -3669,7 +3925,7 @@ function useModels(options = {}) {
       }
     };
   }, []);
-  const fetchModels = useCallback6(async () => {
+  const fetchModels = useCallback7(async () => {
     if (abortControllerRef.current) {
       abortControllerRef.current.abort();
     }
@@ -3727,12 +3983,12 @@ function useModels(options = {}) {
       }
     }
   }, []);
-  const refetch = useCallback6(async () => {
+  const refetch = useCallback7(async () => {
     setModels([]);
     await fetchModels();
   }, [fetchModels]);
   const hasFetchedRef = useRef3(false);
-  useEffect2(() => {
+  useEffect3(() => {
     if (autoFetch && !hasFetchedRef.current) {
       hasFetchedRef.current = true;
       fetchModels();
@@ -3750,15 +4006,15 @@ function useModels(options = {}) {
 }
 
 // src/react/useSearch.ts
-import { useCallback as useCallback7, useEffect as useEffect3, useRef as useRef4, useState as useState7 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect4, useRef as useRef4, useState as useState8 } from "react";
 function useSearch(options = {}) {
   const { getToken, baseUrl = BASE_URL, onError } = options;
-  const [isLoading, setIsLoading] = useState7(false);
-  const [results, setResults] = useState7(null);
-  const [response, setResponse] = useState7(null);
-  const [error, setError] = useState7(null);
+  const [isLoading, setIsLoading] = useState8(false);
+  const [results, setResults] = useState8(null);
+  const [response, setResponse] = useState8(null);
+  const [error, setError] = useState8(null);
   const abortControllerRef = useRef4(null);
-  useEffect3(() => {
+  useEffect4(() => {
     return () => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -3766,7 +4022,7 @@ function useSearch(options = {}) {
       }
     };
   }, []);
-  const search = useCallback7(
+  const search = useCallback8(
     async (query, searchOptions = {}) => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -3834,12 +4090,12 @@ function useSearch(options = {}) {
 }
 
 // src/react/useImageGeneration.ts
-import { useCallback as useCallback8, useEffect as useEffect4, useRef as useRef5, useState as useState8 } from "react";
+import { useCallback as useCallback9, useEffect as useEffect5, useRef as useRef5, useState as useState9 } from "react";
 function useImageGeneration(options = {}) {
   const { getToken, baseUrl = BASE_URL, onFinish, onError } = options;
-  const [isLoading, setIsLoading] = useState8(false);
+  const [isLoading, setIsLoading] = useState9(false);
   const abortControllerRef = useRef5(null);
-  useEffect4(() => {
+  useEffect5(() => {
     return () => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -3847,13 +4103,13 @@ function useImageGeneration(options = {}) {
       }
     };
   }, []);
-  const stop = useCallback8(() => {
+  const stop = useCallback9(() => {
     if (abortControllerRef.current) {
       abortControllerRef.current.abort();
       abortControllerRef.current = null;
     }
   }, []);
-  const generateImage = useCallback8(
+  const generateImage = useCallback9(
     async (args) => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -3969,12 +4225,875 @@ var extractConversationContext = (messages, maxMessages = 3) => {
   const userMessages = messages.filter((msg) => msg.role === "user").slice(-maxMessages).map((msg) => msg.content).join(" ");
   return userMessages.trim();
 };
+
+// src/react/useDropboxBackup.ts
+import { useCallback as useCallback11, useMemo as useMemo4 } from "react";
+
+// src/lib/backup/dropbox/api.ts
+var DROPBOX_API_URL = "https://api.dropboxapi.com/2";
+var DROPBOX_CONTENT_URL = "https://content.dropboxapi.com/2";
+var DEFAULT_BACKUP_FOLDER = "/ai-chat-app/conversations";
+async function ensureBackupFolder(accessToken, folder = DEFAULT_BACKUP_FOLDER) {
+  try {
+    await fetch(`${DROPBOX_API_URL}/files/create_folder_v2`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        path: folder,
+        autorename: false
+      })
+    });
+  } catch {
+  }
+}
+async function uploadFileToDropbox(accessToken, filename, content, folder = DEFAULT_BACKUP_FOLDER) {
+  await ensureBackupFolder(accessToken, folder);
+  const path = `${folder}/${filename}`;
+  const response = await fetch(`${DROPBOX_CONTENT_URL}/files/upload`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/octet-stream",
+      "Dropbox-API-Arg": JSON.stringify({
+        path,
+        mode: "overwrite",
+        autorename: false,
+        mute: true
+      })
+    },
+    body: content
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Dropbox upload failed: ${response.status} - ${errorText}`);
+  }
+  return response.json();
+}
+async function listDropboxFiles(accessToken, folder = DEFAULT_BACKUP_FOLDER) {
+  await ensureBackupFolder(accessToken, folder);
+  const response = await fetch(`${DROPBOX_API_URL}/files/list_folder`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      path: folder,
+      recursive: false,
+      include_deleted: false
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    if (error.error?.path?.[".tag"] === "not_found") {
+      return [];
+    }
+    throw new Error(`Dropbox list failed: ${error.error_summary}`);
+  }
+  let data = await response.json();
+  const allEntries = [...data.entries];
+  while (data.has_more) {
+    const continueResponse = await fetch(`${DROPBOX_API_URL}/files/list_folder/continue`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        cursor: data.cursor
+      })
+    });
+    if (!continueResponse.ok) {
+      const errorText = await continueResponse.text();
+      throw new Error(`Dropbox list continue failed: ${continueResponse.status} - ${errorText}`);
+    }
+    data = await continueResponse.json();
+    allEntries.push(...data.entries);
+  }
+  const files = allEntries.filter((entry) => entry[".tag"] === "file").map((entry) => ({
+    id: entry.id,
+    name: entry.name,
+    path_lower: entry.path_lower,
+    path_display: entry.path_display,
+    client_modified: entry.client_modified || "",
+    server_modified: entry.server_modified || "",
+    size: entry.size || 0
+  }));
+  return files;
+}
+async function downloadDropboxFile(accessToken, path) {
+  const response = await fetch(`${DROPBOX_CONTENT_URL}/files/download`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Dropbox-API-Arg": JSON.stringify({ path })
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Dropbox download failed: ${response.status}`);
+  }
+  return response.blob();
+}
+async function findDropboxFile(accessToken, filename, folder = DEFAULT_BACKUP_FOLDER) {
+  const files = await listDropboxFiles(accessToken, folder);
+  return files.find((f) => f.name === filename) || null;
+}
+
+// src/lib/backup/dropbox/backup.ts
+var isAuthError = (err) => err instanceof Error && (err.message.includes("401") || err.message.includes("invalid_access_token"));
+async function pushConversationToDropbox(database, conversationId, userAddress, token, deps, backupFolder = DEFAULT_BACKUP_FOLDER, _retried = false) {
+  try {
+    await deps.requestEncryptionKey(userAddress);
+    const filename = `${conversationId}.json`;
+    const existingFile = await findDropboxFile(token, filename, backupFolder);
+    if (existingFile) {
+      const { Q: Q4 } = await import("@nozbe/watermelondb");
+      const conversationsCollection = database.get("conversations");
+      const records = await conversationsCollection.query(Q4.where("conversation_id", conversationId)).fetch();
+      if (records.length > 0) {
+        const conversation = conversationToStored(records[0]);
+        const localUpdated = conversation.updatedAt.getTime();
+        const remoteModified = new Date(existingFile.server_modified).getTime();
+        if (localUpdated <= remoteModified) {
+          return "skipped";
+        }
+      }
+    }
+    const exportResult = await deps.exportConversation(conversationId, userAddress);
+    if (!exportResult.success || !exportResult.blob) {
+      return "failed";
+    }
+    await uploadFileToDropbox(token, filename, exportResult.blob, backupFolder);
+    return "uploaded";
+  } catch (err) {
+    if (isAuthError(err) && !_retried) {
+      try {
+        const newToken = await deps.requestDropboxAccess();
+        return pushConversationToDropbox(database, conversationId, userAddress, newToken, deps, backupFolder, true);
+      } catch {
+        return "failed";
+      }
+    }
+    return "failed";
+  }
+}
+async function performDropboxExport(database, userAddress, token, deps, onProgress, backupFolder = DEFAULT_BACKUP_FOLDER) {
+  await deps.requestEncryptionKey(userAddress);
+  const { Q: Q4 } = await import("@nozbe/watermelondb");
+  const conversationsCollection = database.get("conversations");
+  const records = await conversationsCollection.query(Q4.where("is_deleted", false)).fetch();
+  const conversations = records.map(conversationToStored);
+  const total = conversations.length;
+  if (total === 0) {
+    return { success: true, uploaded: 0, skipped: 0, total: 0 };
+  }
+  let uploaded = 0;
+  let skipped = 0;
+  for (let i = 0; i < conversations.length; i++) {
+    const conv = conversations[i];
+    onProgress?.(i + 1, total);
+    const result = await pushConversationToDropbox(
+      database,
+      conv.conversationId,
+      userAddress,
+      token,
+      deps,
+      backupFolder
+    );
+    if (result === "uploaded") uploaded++;
+    if (result === "skipped") skipped++;
+  }
+  return { success: true, uploaded, skipped, total };
+}
+async function performDropboxImport(userAddress, token, deps, onProgress, backupFolder = DEFAULT_BACKUP_FOLDER) {
+  await deps.requestEncryptionKey(userAddress);
+  const remoteFiles = await listDropboxFiles(token, backupFolder);
+  if (remoteFiles.length === 0) {
+    return { success: false, restored: 0, failed: 0, total: 0, noBackupsFound: true };
+  }
+  const jsonFiles = remoteFiles.filter((file) => file.name.endsWith(".json"));
+  const total = jsonFiles.length;
+  let restored = 0;
+  let failed = 0;
+  let currentToken = token;
+  for (let i = 0; i < jsonFiles.length; i++) {
+    const file = jsonFiles[i];
+    onProgress?.(i + 1, total);
+    try {
+      const blob = await downloadDropboxFile(currentToken, file.path_lower);
+      const result = await deps.importConversation(blob, userAddress);
+      if (result.success) {
+        restored++;
+      } else {
+        failed++;
+      }
+    } catch (err) {
+      if (isAuthError(err)) {
+        try {
+          currentToken = await deps.requestDropboxAccess();
+          const blob = await downloadDropboxFile(currentToken, file.path_lower);
+          const result = await deps.importConversation(blob, userAddress);
+          if (result.success) {
+            restored++;
+          } else {
+            failed++;
+          }
+        } catch {
+          failed++;
+        }
+      } else {
+        failed++;
+      }
+    }
+  }
+  return { success: true, restored, failed, total };
+}
+
+// src/react/useDropboxAuth.ts
+import {
+  createContext,
+  createElement,
+  useCallback as useCallback10,
+  useContext,
+  useEffect as useEffect6,
+  useState as useState10
+} from "react";
+
+// src/lib/backup/dropbox/auth.ts
+var DROPBOX_AUTH_URL = "https://www.dropbox.com/oauth2/authorize";
+var DROPBOX_TOKEN_URL = "https://api.dropboxapi.com/oauth2/token";
+var TOKEN_STORAGE_KEY = "dropbox_access_token";
+var VERIFIER_STORAGE_KEY = "dropbox_code_verifier";
+function generateCodeVerifier() {
+  const array = new Uint8Array(32);
+  crypto.getRandomValues(array);
+  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function generateCodeChallenge(verifier) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(verifier);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  const base64 = btoa(String.fromCharCode(...new Uint8Array(hash)));
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function getStoredToken() {
+  if (typeof window === "undefined") return null;
+  return sessionStorage.getItem(TOKEN_STORAGE_KEY);
+}
+function storeToken(token) {
+  if (typeof window === "undefined") return;
+  sessionStorage.setItem(TOKEN_STORAGE_KEY, token);
+}
+function clearToken() {
+  if (typeof window === "undefined") return;
+  sessionStorage.removeItem(TOKEN_STORAGE_KEY);
+}
+function getStoredVerifier() {
+  if (typeof window === "undefined") return null;
+  return sessionStorage.getItem(VERIFIER_STORAGE_KEY);
+}
+function storeVerifier(verifier) {
+  if (typeof window === "undefined") return;
+  sessionStorage.setItem(VERIFIER_STORAGE_KEY, verifier);
+}
+function clearVerifier() {
+  if (typeof window === "undefined") return;
+  sessionStorage.removeItem(VERIFIER_STORAGE_KEY);
+}
+function getRedirectUri(callbackPath) {
+  if (typeof window === "undefined") return "";
+  return `${window.location.origin}${callbackPath}`;
+}
+async function handleDropboxCallback(appKey, callbackPath) {
+  if (typeof window === "undefined") return null;
+  const url = new URL(window.location.href);
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  if (!code || state !== "dropbox_auth") return null;
+  const verifier = getStoredVerifier();
+  if (!verifier) return null;
+  try {
+    const response = await fetch(DROPBOX_TOKEN_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        code,
+        grant_type: "authorization_code",
+        client_id: appKey,
+        redirect_uri: getRedirectUri(callbackPath),
+        code_verifier: verifier
+      })
+    });
+    if (!response.ok) {
+      throw new Error("Token exchange failed");
+    }
+    const data = await response.json();
+    const token = data.access_token;
+    if (typeof token !== "string" || token.trim() === "") {
+      throw new Error("Invalid token response: access_token is missing or empty");
+    }
+    storeToken(token);
+    clearVerifier();
+    window.history.replaceState({}, "", window.location.pathname);
+    return token;
+  } catch {
+    clearVerifier();
+    return null;
+  }
+}
+async function startDropboxAuth(appKey, callbackPath) {
+  const verifier = generateCodeVerifier();
+  const challenge = await generateCodeChallenge(verifier);
+  storeVerifier(verifier);
+  const params = new URLSearchParams({
+    client_id: appKey,
+    redirect_uri: getRedirectUri(callbackPath),
+    response_type: "code",
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    state: "dropbox_auth",
+    token_access_type: "offline"
+  });
+  window.location.href = `${DROPBOX_AUTH_URL}?${params.toString()}`;
+  return new Promise(() => {
+  });
+}
+async function requestDropboxAccess(appKey, callbackPath) {
+  if (!appKey) {
+    throw new Error("Dropbox is not configured");
+  }
+  const storedToken = getStoredToken();
+  if (storedToken) {
+    return storedToken;
+  }
+  return startDropboxAuth(appKey, callbackPath);
+}
+
+// src/react/useDropboxAuth.ts
+var DropboxAuthContext = createContext(null);
+function DropboxAuthProvider({
+  appKey,
+  callbackPath = "/auth/dropbox/callback",
+  children
+}) {
+  const [accessToken, setAccessToken] = useState10(null);
+  const isConfigured = !!appKey;
+  useEffect6(() => {
+    const storedToken = getStoredToken();
+    if (storedToken) {
+      setAccessToken(storedToken);
+    }
+  }, []);
+  useEffect6(() => {
+    if (!isConfigured || !appKey) return;
+    const handleCallback = async () => {
+      const token = await handleDropboxCallback(appKey, callbackPath);
+      if (token) {
+        setAccessToken(token);
+      }
+    };
+    handleCallback();
+  }, [appKey, callbackPath, isConfigured]);
+  const requestAccess = useCallback10(async () => {
+    if (!isConfigured || !appKey) {
+      throw new Error("Dropbox is not configured");
+    }
+    if (accessToken) {
+      return accessToken;
+    }
+    const storedToken = getStoredToken();
+    if (storedToken) {
+      setAccessToken(storedToken);
+      return storedToken;
+    }
+    return requestDropboxAccess(appKey, callbackPath);
+  }, [accessToken, appKey, callbackPath, isConfigured]);
+  const logout = useCallback10(() => {
+    clearToken();
+    setAccessToken(null);
+  }, []);
+  return createElement(
+    DropboxAuthContext.Provider,
+    {
+      value: {
+        accessToken,
+        isAuthenticated: !!accessToken,
+        isConfigured,
+        requestAccess,
+        logout
+      }
+    },
+    children
+  );
+}
+function useDropboxAuth() {
+  const context = useContext(DropboxAuthContext);
+  if (!context) {
+    throw new Error("useDropboxAuth must be used within DropboxAuthProvider");
+  }
+  return context;
+}
+
+// src/react/useDropboxBackup.ts
+function useDropboxBackup(options) {
+  const {
+    database,
+    userAddress,
+    requestEncryptionKey: requestEncryptionKey2,
+    exportConversation,
+    importConversation,
+    backupFolder = DEFAULT_BACKUP_FOLDER
+  } = options;
+  const {
+    accessToken: dropboxToken,
+    isConfigured: isDropboxConfigured,
+    requestAccess: requestDropboxAccess2
+  } = useDropboxAuth();
+  const deps = useMemo4(
+    () => ({
+      requestDropboxAccess: requestDropboxAccess2,
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [requestDropboxAccess2, requestEncryptionKey2, exportConversation, importConversation]
+  );
+  const ensureToken = useCallback11(async () => {
+    if (dropboxToken) return dropboxToken;
+    try {
+      return await requestDropboxAccess2();
+    } catch {
+      return null;
+    }
+  }, [dropboxToken, requestDropboxAccess2]);
+  const backup = useCallback11(
+    async (backupOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to backup to Dropbox" };
+      }
+      const token = await ensureToken();
+      if (!token) {
+        return { error: "Dropbox access denied" };
+      }
+      try {
+        return await performDropboxExport(
+          database,
+          userAddress,
+          token,
+          deps,
+          backupOptions?.onProgress,
+          backupFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to backup to Dropbox"
+        };
+      }
+    },
+    [database, userAddress, ensureToken, deps, backupFolder]
+  );
+  const restore = useCallback11(
+    async (restoreOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to restore from Dropbox" };
+      }
+      const token = await ensureToken();
+      if (!token) {
+        return { error: "Dropbox access denied" };
+      }
+      try {
+        return await performDropboxImport(
+          userAddress,
+          token,
+          deps,
+          restoreOptions?.onProgress,
+          backupFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to restore from Dropbox"
+        };
+      }
+    },
+    [userAddress, ensureToken, deps, backupFolder]
+  );
+  return {
+    backup,
+    restore,
+    isConfigured: isDropboxConfigured,
+    isAuthenticated: !!dropboxToken
+  };
+}
+
+// src/react/useGoogleDriveBackup.ts
+import { useCallback as useCallback12, useMemo as useMemo5 } from "react";
+
+// src/lib/backup/google/api.ts
+var DRIVE_API_URL = "https://www.googleapis.com/drive/v3";
+var DRIVE_UPLOAD_URL = "https://www.googleapis.com/upload/drive/v3";
+var FOLDER_MIME_TYPE = "application/vnd.google-apps.folder";
+function escapeQueryValue(value) {
+  return value.replace(/'/g, "''");
+}
+var DEFAULT_ROOT_FOLDER = "ai-chat-app";
+var DEFAULT_CONVERSATIONS_FOLDER = "conversations";
+async function ensureFolder(accessToken, name, parentId) {
+  const parentQuery = parentId ? `'${escapeQueryValue(parentId)}' in parents and ` : "";
+  const query = `${parentQuery}mimeType='${FOLDER_MIME_TYPE}' and name='${escapeQueryValue(name)}' and trashed=false`;
+  const response = await fetch(
+    `${DRIVE_API_URL}/files?q=${encodeURIComponent(query)}&fields=files(id)`,
+    {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to search for folder ${name}: ${response.status}`);
+  }
+  const data = await response.json();
+  if (data.files && data.files.length > 0) {
+    return data.files[0].id;
+  }
+  const body = {
+    name,
+    mimeType: FOLDER_MIME_TYPE
+  };
+  if (parentId) {
+    body.parents = [parentId];
+  }
+  const createResponse = await fetch(`${DRIVE_API_URL}/files`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!createResponse.ok) {
+    throw new Error(`Failed to create folder ${name}: ${createResponse.status}`);
+  }
+  const folderData = await createResponse.json();
+  return folderData.id;
+}
+async function getBackupFolder(accessToken, rootFolder = DEFAULT_ROOT_FOLDER, subfolder = DEFAULT_CONVERSATIONS_FOLDER) {
+  const rootId = await ensureFolder(accessToken, rootFolder);
+  return ensureFolder(accessToken, subfolder, rootId);
+}
+async function uploadFileToDrive(accessToken, folderId, content, filename) {
+  const metadata = {
+    name: filename,
+    parents: [folderId],
+    mimeType: "application/json"
+  };
+  const form = new FormData();
+  form.append("metadata", new Blob([JSON.stringify(metadata)], { type: "application/json" }));
+  form.append("file", content);
+  const response = await fetch(`${DRIVE_UPLOAD_URL}/files?uploadType=multipart`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${accessToken}` },
+    body: form
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Drive upload failed: ${response.status} - ${errorText}`);
+  }
+  return response.json();
+}
+async function updateDriveFile(accessToken, fileId, content) {
+  const response = await fetch(`${DRIVE_UPLOAD_URL}/files/${fileId}?uploadType=media`, {
+    method: "PATCH",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: content
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Drive update failed: ${response.status} - ${errorText}`);
+  }
+  return response.json();
+}
+async function listDriveFiles(accessToken, folderId) {
+  const query = `'${escapeQueryValue(folderId)}' in parents and mimeType='application/json' and trashed=false`;
+  const fields = "files(id,name,createdTime,modifiedTime,size)";
+  const response = await fetch(
+    `${DRIVE_API_URL}/files?q=${encodeURIComponent(query)}&fields=${fields}&pageSize=1000`,
+    {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to list files: ${response.status}`);
+  }
+  const data = await response.json();
+  return data.files ?? [];
+}
+async function downloadDriveFile(accessToken, fileId) {
+  const response = await fetch(`${DRIVE_API_URL}/files/${fileId}?alt=media`, {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to download file: ${response.status}`);
+  }
+  return response.blob();
+}
+async function findDriveFile(accessToken, folderId, filename) {
+  const query = `'${escapeQueryValue(folderId)}' in parents and name='${escapeQueryValue(filename)}' and trashed=false`;
+  const fields = "files(id,name,createdTime,modifiedTime,size)";
+  const response = await fetch(
+    `${DRIVE_API_URL}/files?q=${encodeURIComponent(query)}&fields=${fields}&pageSize=1`,
+    {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to find file: ${response.status}`);
+  }
+  const data = await response.json();
+  return data.files?.[0] ?? null;
+}
+
+// src/lib/backup/google/backup.ts
+var isAuthError2 = (err) => err instanceof Error && (err.message.includes("401") || err.message.includes("403"));
+async function getConversationsFolder(token, requestDriveAccess, rootFolder, subfolder) {
+  try {
+    const folderId = await getBackupFolder(token, rootFolder, subfolder);
+    return { folderId, token };
+  } catch (err) {
+    if (isAuthError2(err)) {
+      try {
+        const newToken = await requestDriveAccess();
+        const folderId = await getBackupFolder(newToken, rootFolder, subfolder);
+        return { folderId, token: newToken };
+      } catch {
+        return null;
+      }
+    }
+    throw err;
+  }
+}
+async function pushConversationToDrive(database, conversationId, userAddress, token, deps, rootFolder = DEFAULT_ROOT_FOLDER, subfolder = DEFAULT_CONVERSATIONS_FOLDER, _retried = false) {
+  try {
+    await deps.requestEncryptionKey(userAddress);
+    const folderResult = await getConversationsFolder(token, deps.requestDriveAccess, rootFolder, subfolder);
+    if (!folderResult) return "failed";
+    const { folderId, token: activeToken } = folderResult;
+    const filename = `${conversationId}.json`;
+    const existingFile = await findDriveFile(activeToken, folderId, filename);
+    if (existingFile) {
+      const { Q: Q4 } = await import("@nozbe/watermelondb");
+      const conversationsCollection = database.get("conversations");
+      const records = await conversationsCollection.query(Q4.where("conversation_id", conversationId)).fetch();
+      if (records.length > 0) {
+        const conversation = conversationToStored(records[0]);
+        const localUpdated = conversation.updatedAt.getTime();
+        const remoteModified = new Date(existingFile.modifiedTime).getTime();
+        if (localUpdated <= remoteModified) {
+          return "skipped";
+        }
+      }
+    }
+    const exportResult = await deps.exportConversation(conversationId, userAddress);
+    if (!exportResult.success || !exportResult.blob) {
+      return "failed";
+    }
+    if (existingFile) {
+      await updateDriveFile(activeToken, existingFile.id, exportResult.blob);
+    } else {
+      await uploadFileToDrive(activeToken, folderId, exportResult.blob, filename);
+    }
+    return "uploaded";
+  } catch (err) {
+    if (isAuthError2(err) && !_retried) {
+      try {
+        const newToken = await deps.requestDriveAccess();
+        return pushConversationToDrive(database, conversationId, userAddress, newToken, deps, rootFolder, subfolder, true);
+      } catch {
+        return "failed";
+      }
+    }
+    return "failed";
+  }
+}
+async function performGoogleDriveExport(database, userAddress, token, deps, onProgress, rootFolder = DEFAULT_ROOT_FOLDER, subfolder = DEFAULT_CONVERSATIONS_FOLDER) {
+  await deps.requestEncryptionKey(userAddress);
+  const folderResult = await getConversationsFolder(token, deps.requestDriveAccess, rootFolder, subfolder);
+  if (!folderResult) {
+    return { success: false, uploaded: 0, skipped: 0, total: 0 };
+  }
+  const { token: activeToken } = folderResult;
+  const { Q: Q4 } = await import("@nozbe/watermelondb");
+  const conversationsCollection = database.get("conversations");
+  const records = await conversationsCollection.query(Q4.where("is_deleted", false)).fetch();
+  const conversations = records.map(conversationToStored);
+  const total = conversations.length;
+  if (total === 0) {
+    return { success: true, uploaded: 0, skipped: 0, total: 0 };
+  }
+  let uploaded = 0;
+  let skipped = 0;
+  for (let i = 0; i < conversations.length; i++) {
+    const conv = conversations[i];
+    onProgress?.(i + 1, total);
+    const result = await pushConversationToDrive(
+      database,
+      conv.conversationId,
+      userAddress,
+      activeToken,
+      deps,
+      rootFolder,
+      subfolder
+    );
+    if (result === "uploaded") uploaded++;
+    if (result === "skipped") skipped++;
+  }
+  return { success: true, uploaded, skipped, total };
+}
+async function performGoogleDriveImport(userAddress, token, deps, onProgress, rootFolder = DEFAULT_ROOT_FOLDER, subfolder = DEFAULT_CONVERSATIONS_FOLDER) {
+  await deps.requestEncryptionKey(userAddress);
+  const folderResult = await getConversationsFolder(token, deps.requestDriveAccess, rootFolder, subfolder);
+  if (!folderResult) {
+    return { success: false, restored: 0, failed: 0, total: 0, noBackupsFound: true };
+  }
+  const { folderId, token: activeToken } = folderResult;
+  const remoteFiles = await listDriveFiles(activeToken, folderId);
+  if (remoteFiles.length === 0) {
+    return { success: false, restored: 0, failed: 0, total: 0, noBackupsFound: true };
+  }
+  const jsonFiles = remoteFiles.filter((file) => file.name.endsWith(".json"));
+  const total = jsonFiles.length;
+  let restored = 0;
+  let failed = 0;
+  for (let i = 0; i < jsonFiles.length; i++) {
+    const file = jsonFiles[i];
+    onProgress?.(i + 1, total);
+    try {
+      const blob = await downloadDriveFile(activeToken, file.id);
+      const result = await deps.importConversation(blob, userAddress);
+      if (result.success) {
+        restored++;
+      } else {
+        failed++;
+      }
+    } catch {
+      failed++;
+    }
+  }
+  return { success: true, restored, failed, total };
+}
+
+// src/react/useGoogleDriveBackup.ts
+function useGoogleDriveBackup(options) {
+  const {
+    database,
+    userAddress,
+    accessToken,
+    requestDriveAccess,
+    requestEncryptionKey: requestEncryptionKey2,
+    exportConversation,
+    importConversation,
+    rootFolder = DEFAULT_ROOT_FOLDER,
+    conversationsFolder = DEFAULT_CONVERSATIONS_FOLDER
+  } = options;
+  const deps = useMemo5(
+    () => ({
+      requestDriveAccess,
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [
+      requestDriveAccess,
+      requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    ]
+  );
+  const ensureToken = useCallback12(async () => {
+    if (accessToken) return accessToken;
+    try {
+      return await requestDriveAccess();
+    } catch {
+      return null;
+    }
+  }, [accessToken, requestDriveAccess]);
+  const backup = useCallback12(
+    async (backupOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to backup to Google Drive" };
+      }
+      const token = await ensureToken();
+      if (!token) {
+        return { error: "Google Drive access denied" };
+      }
+      try {
+        return await performGoogleDriveExport(
+          database,
+          userAddress,
+          token,
+          deps,
+          backupOptions?.onProgress,
+          rootFolder,
+          conversationsFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to backup to Google Drive"
+        };
+      }
+    },
+    [database, userAddress, ensureToken, deps, rootFolder, conversationsFolder]
+  );
+  const restore = useCallback12(
+    async (restoreOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to restore from Google Drive" };
+      }
+      const token = await ensureToken();
+      if (!token) {
+        return { error: "Google Drive access denied" };
+      }
+      try {
+        return await performGoogleDriveImport(
+          userAddress,
+          token,
+          deps,
+          restoreOptions?.onProgress,
+          rootFolder,
+          conversationsFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to restore from Google Drive"
+        };
+      }
+    },
+    [userAddress, ensureToken, deps, rootFolder, conversationsFolder]
+  );
+  return {
+    backup,
+    restore,
+    isAuthenticated: !!accessToken
+  };
+}
 export {
   Conversation as ChatConversation,
   Message as ChatMessage,
+  DEFAULT_BACKUP_FOLDER,
+  DEFAULT_CONVERSATIONS_FOLDER as DEFAULT_DRIVE_CONVERSATIONS_FOLDER,
+  DEFAULT_ROOT_FOLDER as DEFAULT_DRIVE_ROOT_FOLDER,
   DEFAULT_TOOL_SELECTOR_MODEL,
+  DropboxAuthProvider,
   Memory as StoredMemoryModel,
+  ModelPreference as StoredModelPreferenceModel,
+  chatStorageMigrations,
   chatStorageSchema,
+  clearToken as clearDropboxToken,
   createMemoryContextSystemMessage,
   decryptData,
   decryptDataBytes,
@@ -3985,17 +5104,24 @@ export {
   generateCompositeKey,
   generateConversationId,
   generateUniqueKey,
+  getStoredToken as getDropboxToken,
   hasEncryptionKey,
   memoryStorageSchema,
   requestEncryptionKey,
   selectTool,
+  settingsStorageSchema,
+  storeToken as storeDropboxToken,
   useChat,
   useChatStorage,
+  useDropboxAuth,
+  useDropboxBackup,
   useEncryption,
+  useGoogleDriveBackup,
   useImageGeneration,
   useMemoryStorage,
   useModels,
   useOCR,
   usePdf,
-  useSearch
+  useSearch,
+  useSettings
 };