@reverbia/sdk 1.0.0-next.20251217134403 → 1.0.0-next.20251217144909

package/dist/react/index.cjs

@@ -26,17 +26,30 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
 
 // src/react/index.ts
 var index_exports = {};
 __export(index_exports, {
   ChatConversation: () => Conversation,
   ChatMessage: () => Message,
+  DEFAULT_BACKUP_FOLDER: () => DEFAULT_BACKUP_FOLDER,
+  DEFAULT_DRIVE_CONVERSATIONS_FOLDER: () => DEFAULT_CONVERSATIONS_FOLDER,
+  DEFAULT_DRIVE_ROOT_FOLDER: () => DEFAULT_ROOT_FOLDER,
   DEFAULT_TOOL_SELECTOR_MODEL: () => DEFAULT_TOOL_SELECTOR_MODEL,
+  DropboxAuthProvider: () => DropboxAuthProvider,
   StoredMemoryModel: () => Memory,
   StoredModelPreferenceModel: () => ModelPreference,
   chatStorageMigrations: () => chatStorageMigrations,
   chatStorageSchema: () => chatStorageSchema,
+  clearDropboxToken: () => clearToken,
   createMemoryContextSystemMessage: () => createMemoryContextSystemMessage,
   decryptData: () => decryptData,
   decryptDataBytes: () => decryptDataBytes,
@@ -47,14 +60,19 @@ __export(index_exports, {
   generateCompositeKey: () => generateCompositeKey,
   generateConversationId: () => generateConversationId,
   generateUniqueKey: () => generateUniqueKey,
+  getDropboxToken: () => getStoredToken,
   hasEncryptionKey: () => hasEncryptionKey,
   memoryStorageSchema: () => memoryStorageSchema,
   requestEncryptionKey: () => requestEncryptionKey,
   selectTool: () => selectTool,
   settingsStorageSchema: () => settingsStorageSchema,
+  storeDropboxToken: () => storeToken,
   useChat: () => useChat,
   useChatStorage: () => useChatStorage,
+  useDropboxAuth: () => useDropboxAuth,
+  useDropboxBackup: () => useDropboxBackup,
   useEncryption: () => useEncryption,
+  useGoogleDriveBackup: () => useGoogleDriveBackup,
   useImageGeneration: () => useImageGeneration,
   useMemoryStorage: () => useMemoryStorage,
   useModels: () => useModels,
@@ -1058,11 +1076,11 @@ async function generateLocalChatCompletion(messages, options = {}) {
       });
       this.cb = cb;
     }
-    on_finalized_text(text) {
+    on_finalized_text(text4) {
       if (signal?.aborted) {
         throw new Error("AbortError");
       }
-      this.cb(text);
+      this.cb(text4);
     }
   }
   const streamer = onToken ? new CallbackStreamer(chatPipeline.tokenizer, onToken) : void 0;
@@ -1736,7 +1754,134 @@ function useEncryption(signMessage) {
 // src/react/useChatStorage.ts
 var import_react2 = require("react");
 
-// src/lib/chatStorage/types.ts
+// src/lib/db/chat/schema.ts
+var import_watermelondb = require("@nozbe/watermelondb");
+var import_migrations = require("@nozbe/watermelondb/Schema/migrations");
+var chatStorageSchema = (0, import_watermelondb.appSchema)({
+  version: 2,
+  tables: [
+    (0, import_watermelondb.tableSchema)({
+      name: "history",
+      columns: [
+        { name: "message_id", type: "number" },
+        { name: "conversation_id", type: "string", isIndexed: true },
+        { name: "role", type: "string", isIndexed: true },
+        { name: "content", type: "string" },
+        { name: "model", type: "string", isOptional: true },
+        { name: "files", type: "string", isOptional: true },
+        { name: "created_at", type: "number", isIndexed: true },
+        { name: "updated_at", type: "number" },
+        { name: "vector", type: "string", isOptional: true },
+        { name: "embedding_model", type: "string", isOptional: true },
+        { name: "usage", type: "string", isOptional: true },
+        { name: "sources", type: "string", isOptional: true },
+        { name: "response_duration", type: "number", isOptional: true },
+        { name: "was_stopped", type: "boolean", isOptional: true }
+      ]
+    }),
+    (0, import_watermelondb.tableSchema)({
+      name: "conversations",
+      columns: [
+        { name: "conversation_id", type: "string", isIndexed: true },
+        { name: "title", type: "string" },
+        { name: "created_at", type: "number" },
+        { name: "updated_at", type: "number" },
+        { name: "is_deleted", type: "boolean", isIndexed: true }
+      ]
+    })
+  ]
+});
+var chatStorageMigrations = (0, import_migrations.schemaMigrations)({
+  migrations: [
+    {
+      toVersion: 2,
+      steps: [
+        (0, import_migrations.addColumns)({
+          table: "history",
+          columns: [{ name: "was_stopped", type: "boolean", isOptional: true }]
+        })
+      ]
+    }
+  ]
+});
+
+// src/lib/db/chat/models.ts
+var import_watermelondb2 = require("@nozbe/watermelondb");
+var import_decorators = require("@nozbe/watermelondb/decorators");
+var Message = class extends import_watermelondb2.Model {
+};
+Message.table = "history";
+Message.associations = {
+  conversations: { type: "belongs_to", key: "conversation_id" }
+};
+__decorateClass([
+  (0, import_decorators.field)("message_id")
+], Message.prototype, "messageId", 2);
+__decorateClass([
+  (0, import_decorators.text)("conversation_id")
+], Message.prototype, "conversationId", 2);
+__decorateClass([
+  (0, import_decorators.text)("role")
+], Message.prototype, "role", 2);
+__decorateClass([
+  (0, import_decorators.text)("content")
+], Message.prototype, "content", 2);
+__decorateClass([
+  (0, import_decorators.text)("model")
+], Message.prototype, "model", 2);
+__decorateClass([
+  (0, import_decorators.json)("files", (json3) => json3)
+], Message.prototype, "files", 2);
+__decorateClass([
+  (0, import_decorators.date)("created_at")
+], Message.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_decorators.date)("updated_at")
+], Message.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_decorators.json)("vector", (json3) => json3)
+], Message.prototype, "vector", 2);
+__decorateClass([
+  (0, import_decorators.text)("embedding_model")
+], Message.prototype, "embeddingModel", 2);
+__decorateClass([
+  (0, import_decorators.json)("usage", (json3) => json3)
+], Message.prototype, "usage", 2);
+__decorateClass([
+  (0, import_decorators.json)("sources", (json3) => json3)
+], Message.prototype, "sources", 2);
+__decorateClass([
+  (0, import_decorators.field)("response_duration")
+], Message.prototype, "responseDuration", 2);
+__decorateClass([
+  (0, import_decorators.field)("was_stopped")
+], Message.prototype, "wasStopped", 2);
+var Conversation = class extends import_watermelondb2.Model {
+};
+Conversation.table = "conversations";
+Conversation.associations = {
+  history: { type: "has_many", foreignKey: "conversation_id" }
+};
+__decorateClass([
+  (0, import_decorators.text)("conversation_id")
+], Conversation.prototype, "conversationId", 2);
+__decorateClass([
+  (0, import_decorators.text)("title")
+], Conversation.prototype, "title", 2);
+__decorateClass([
+  (0, import_decorators.date)("created_at")
+], Conversation.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_decorators.date)("updated_at")
+], Conversation.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_decorators.field)("is_deleted")
+], Conversation.prototype, "isDeleted", 2);
+
+// src/lib/db/chat/types.ts
+function generateConversationId() {
+  return `conv_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
 function convertUsageToStored(usage) {
   if (!usage) return void 0;
   return {
@@ -1746,12 +1891,9 @@ function convertUsageToStored(usage) {
     costMicroUsd: usage.cost_micro_usd
   };
 }
-function generateConversationId() {
-  return `conv_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-}
 
-// src/lib/chatStorage/operations.ts
-var import_watermelondb = require("@nozbe/watermelondb");
+// src/lib/db/chat/operations.ts
+var import_watermelondb3 = require("@nozbe/watermelondb");
 function messageToStored(message) {
   return {
     uniqueId: message.id,
@@ -1794,15 +1936,15 @@ async function createConversationOp(ctx, opts, defaultTitle = "New Conversation"
   return conversationToStored(created);
 }
 async function getConversationOp(ctx, id) {
-  const results = await ctx.conversationsCollection.query(import_watermelondb.Q.where("conversation_id", id), import_watermelondb.Q.where("is_deleted", false)).fetch();
+  const results = await ctx.conversationsCollection.query(import_watermelondb3.Q.where("conversation_id", id), import_watermelondb3.Q.where("is_deleted", false)).fetch();
   return results.length > 0 ? conversationToStored(results[0]) : null;
 }
 async function getConversationsOp(ctx) {
-  const results = await ctx.conversationsCollection.query(import_watermelondb.Q.where("is_deleted", false), import_watermelondb.Q.sortBy("created_at", import_watermelondb.Q.desc)).fetch();
+  const results = await ctx.conversationsCollection.query(import_watermelondb3.Q.where("is_deleted", false), import_watermelondb3.Q.sortBy("created_at", import_watermelondb3.Q.desc)).fetch();
   return results.map(conversationToStored);
 }
 async function updateConversationTitleOp(ctx, id, title) {
-  const results = await ctx.conversationsCollection.query(import_watermelondb.Q.where("conversation_id", id), import_watermelondb.Q.where("is_deleted", false)).fetch();
+  const results = await ctx.conversationsCollection.query(import_watermelondb3.Q.where("conversation_id", id), import_watermelondb3.Q.where("is_deleted", false)).fetch();
   if (results.length > 0) {
     await ctx.database.write(async () => {
       await results[0].update((conv) => {
@@ -1814,7 +1956,7 @@ async function updateConversationTitleOp(ctx, id, title) {
   return false;
 }
 async function deleteConversationOp(ctx, id) {
-  const results = await ctx.conversationsCollection.query(import_watermelondb.Q.where("conversation_id", id), import_watermelondb.Q.where("is_deleted", false)).fetch();
+  const results = await ctx.conversationsCollection.query(import_watermelondb3.Q.where("conversation_id", id), import_watermelondb3.Q.where("is_deleted", false)).fetch();
   if (results.length > 0) {
     await ctx.database.write(async () => {
       await results[0].update((conv) => {
@@ -1826,14 +1968,14 @@ async function deleteConversationOp(ctx, id) {
   return false;
 }
 async function getMessagesOp(ctx, convId) {
-  const results = await ctx.messagesCollection.query(import_watermelondb.Q.where("conversation_id", convId), import_watermelondb.Q.sortBy("message_id", import_watermelondb.Q.asc)).fetch();
+  const results = await ctx.messagesCollection.query(import_watermelondb3.Q.where("conversation_id", convId), import_watermelondb3.Q.sortBy("message_id", import_watermelondb3.Q.asc)).fetch();
   return results.map(messageToStored);
 }
 async function getMessageCountOp(ctx, convId) {
-  return await ctx.messagesCollection.query(import_watermelondb.Q.where("conversation_id", convId)).fetchCount();
+  return await ctx.messagesCollection.query(import_watermelondb3.Q.where("conversation_id", convId)).fetchCount();
 }
 async function clearMessagesOp(ctx, convId) {
-  const messages = await ctx.messagesCollection.query(import_watermelondb.Q.where("conversation_id", convId)).fetch();
+  const messages = await ctx.messagesCollection.query(import_watermelondb3.Q.where("conversation_id", convId)).fetch();
   await ctx.database.write(async () => {
     for (const message of messages) {
       await message.destroyPermanently();
@@ -1892,11 +2034,11 @@ function cosineSimilarity(a, b) {
 }
 async function searchMessagesOp(ctx, queryVector, options) {
   const { limit = 10, minSimilarity = 0.5, conversationId } = options || {};
-  const activeConversations = await ctx.conversationsCollection.query(import_watermelondb.Q.where("is_deleted", false)).fetch();
+  const activeConversations = await ctx.conversationsCollection.query(import_watermelondb3.Q.where("is_deleted", false)).fetch();
   const activeConversationIds = new Set(
     activeConversations.map((c) => c.conversationId)
   );
-  const queryConditions = conversationId ? [import_watermelondb.Q.where("conversation_id", conversationId)] : [];
+  const queryConditions = conversationId ? [import_watermelondb3.Q.where("conversation_id", conversationId)] : [];
   const messages = await ctx.messagesCollection.query(...queryConditions).fetch();
   const resultsWithSimilarity = [];
   for (const message of messages) {
@@ -2256,191 +2398,87 @@ function useChatStorage(options) {
   };
 }
 
-// src/lib/chatStorage/schema.ts
-var import_watermelondb2 = require("@nozbe/watermelondb");
-var import_migrations = require("@nozbe/watermelondb/Schema/migrations");
-var chatStorageSchema = (0, import_watermelondb2.appSchema)({
-  version: 2,
+// src/react/useMemoryStorage.ts
+var import_react3 = require("react");
+var import_client6 = require("@reverbia/sdk");
+
+// src/lib/db/memory/schema.ts
+var import_watermelondb4 = require("@nozbe/watermelondb");
+var memoryStorageSchema = (0, import_watermelondb4.appSchema)({
+  version: 1,
   tables: [
-    (0, import_watermelondb2.tableSchema)({
-      name: "history",
+    (0, import_watermelondb4.tableSchema)({
+      name: "memories",
       columns: [
-        { name: "message_id", type: "number" },
-        // Sequential ID within conversation
-        { name: "conversation_id", type: "string", isIndexed: true },
-        { name: "role", type: "string", isIndexed: true },
-        // 'user' | 'assistant' | 'system'
-        { name: "content", type: "string" },
-        { name: "model", type: "string", isOptional: true },
-        { name: "files", type: "string", isOptional: true },
-        // JSON stringified FileMetadata[]
+        { name: "type", type: "string", isIndexed: true },
+        { name: "namespace", type: "string", isIndexed: true },
+        { name: "key", type: "string", isIndexed: true },
+        { name: "value", type: "string" },
+        { name: "raw_evidence", type: "string" },
+        { name: "confidence", type: "number" },
+        { name: "pii", type: "boolean", isIndexed: true },
+        { name: "composite_key", type: "string", isIndexed: true },
+        { name: "unique_key", type: "string", isIndexed: true },
         { name: "created_at", type: "number", isIndexed: true },
         { name: "updated_at", type: "number" },
-        { name: "vector", type: "string", isOptional: true },
-        // JSON stringified number[]
+        { name: "embedding", type: "string", isOptional: true },
         { name: "embedding_model", type: "string", isOptional: true },
-        { name: "usage", type: "string", isOptional: true },
-        // JSON stringified ChatCompletionUsage
-        { name: "sources", type: "string", isOptional: true },
-        // JSON stringified SearchSource[]
-        { name: "response_duration", type: "number", isOptional: true },
-        { name: "was_stopped", type: "boolean", isOptional: true }
-      ]
-    }),
-    (0, import_watermelondb2.tableSchema)({
-      name: "conversations",
-      columns: [
-        { name: "conversation_id", type: "string", isIndexed: true },
-        { name: "title", type: "string" },
-        { name: "created_at", type: "number" },
-        { name: "updated_at", type: "number" },
         { name: "is_deleted", type: "boolean", isIndexed: true }
       ]
     })
   ]
 });
-var chatStorageMigrations = (0, import_migrations.schemaMigrations)({
-  migrations: [
-    {
-      toVersion: 2,
-      steps: [
-        (0, import_migrations.addColumns)({
-          table: "history",
-          columns: [
-            { name: "was_stopped", type: "boolean", isOptional: true }
-          ]
-        })
-      ]
-    }
-  ]
-});
 
-// src/lib/chatStorage/models.ts
-var import_watermelondb3 = require("@nozbe/watermelondb");
-var Message = class extends import_watermelondb3.Model {
-  /** Sequential message ID within conversation */
-  get messageId() {
-    return this._getRaw("message_id");
-  }
-  /** Links message to its conversation */
-  get conversationId() {
-    return this._getRaw("conversation_id");
-  }
-  /** Who sent the message: 'user' | 'assistant' | 'system' */
-  get role() {
-    return this._getRaw("role");
-  }
-  /** The message text content */
-  get content() {
-    return this._getRaw("content");
-  }
-  /** LLM model used (e.g., GPT-4, Claude) */
-  get model() {
-    const value = this._getRaw("model");
-    return value ? value : void 0;
-  }
-  /** Optional attached files */
-  get files() {
-    const raw = this._getRaw("files");
-    if (!raw) return void 0;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return void 0;
-    }
-  }
-  /** Created timestamp */
-  get createdAt() {
-    return new Date(this._getRaw("created_at"));
-  }
-  /** Updated timestamp */
-  get updatedAt() {
-    return new Date(this._getRaw("updated_at"));
-  }
-  /** Embedding vector for semantic search */
-  get vector() {
-    const raw = this._getRaw("vector");
-    if (!raw) return void 0;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return void 0;
-    }
-  }
-  /** Model used to generate embedding */
-  get embeddingModel() {
-    const value = this._getRaw("embedding_model");
-    return value ? value : void 0;
-  }
-  /** Token counts and cost */
-  get usage() {
-    const raw = this._getRaw("usage");
-    if (!raw) return void 0;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return void 0;
-    }
-  }
-  /** Web search sources */
-  get sources() {
-    const raw = this._getRaw("sources");
-    if (!raw) return void 0;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return void 0;
-    }
-  }
-  /** Response time in seconds */
-  get responseDuration() {
-    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 = {
-  conversations: { type: "belongs_to", key: "conversation_id" }
-};
-var Conversation = class extends import_watermelondb3.Model {
-  /** Unique conversation identifier */
-  get conversationId() {
-    return this._getRaw("conversation_id");
-  }
-  /** Conversation title */
-  get title() {
-    return this._getRaw("title");
-  }
-  /** Created timestamp */
-  get createdAt() {
-    return new Date(this._getRaw("created_at"));
-  }
-  /** Updated timestamp */
-  get updatedAt() {
-    return new Date(this._getRaw("updated_at"));
-  }
-  /** Soft delete flag */
-  get isDeleted() {
-    return this._getRaw("is_deleted");
-  }
-};
-Conversation.table = "conversations";
-Conversation.associations = {
-  history: { type: "has_many", foreignKey: "conversation_id" }
+// src/lib/db/memory/models.ts
+var import_watermelondb5 = require("@nozbe/watermelondb");
+var import_decorators2 = require("@nozbe/watermelondb/decorators");
+var Memory = class extends import_watermelondb5.Model {
 };
+Memory.table = "memories";
+__decorateClass([
+  (0, import_decorators2.text)("type")
+], Memory.prototype, "type", 2);
+__decorateClass([
+  (0, import_decorators2.text)("namespace")
+], Memory.prototype, "namespace", 2);
+__decorateClass([
+  (0, import_decorators2.text)("key")
+], Memory.prototype, "key", 2);
+__decorateClass([
+  (0, import_decorators2.text)("value")
+], Memory.prototype, "value", 2);
+__decorateClass([
+  (0, import_decorators2.text)("raw_evidence")
+], Memory.prototype, "rawEvidence", 2);
+__decorateClass([
+  (0, import_decorators2.field)("confidence")
+], Memory.prototype, "confidence", 2);
+__decorateClass([
+  (0, import_decorators2.field)("pii")
+], Memory.prototype, "pii", 2);
+__decorateClass([
+  (0, import_decorators2.text)("composite_key")
+], Memory.prototype, "compositeKey", 2);
+__decorateClass([
+  (0, import_decorators2.text)("unique_key")
+], Memory.prototype, "uniqueKey", 2);
+__decorateClass([
+  (0, import_decorators2.date)("created_at")
+], Memory.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_decorators2.date)("updated_at")
+], Memory.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_decorators2.json)("embedding", (json3) => json3)
+], Memory.prototype, "embedding", 2);
+__decorateClass([
+  (0, import_decorators2.text)("embedding_model")
+], Memory.prototype, "embeddingModel", 2);
+__decorateClass([
+  (0, import_decorators2.field)("is_deleted")
+], Memory.prototype, "isDeleted", 2);
 
-// src/react/useMemoryStorage.ts
-var import_react3 = require("react");
-var import_client6 = require("@reverbia/sdk");
-
-// src/lib/memoryStorage/operations.ts
-var import_watermelondb4 = require("@nozbe/watermelondb");
-
-// src/lib/memoryStorage/types.ts
+// src/lib/db/memory/types.ts
 function generateCompositeKey(namespace, key) {
   return `${namespace}:${key}`;
 }
@@ -2466,7 +2504,8 @@ function cosineSimilarity2(a, b) {
   return dotProduct / denominator;
 }
 
-// src/lib/memoryStorage/operations.ts
+// src/lib/db/memory/operations.ts
+var import_watermelondb6 = require("@nozbe/watermelondb");
 function memoryToStored(memory) {
   return {
     uniqueId: memory.id,
@@ -2487,7 +2526,7 @@ function memoryToStored(memory) {
   };
 }
 async function getAllMemoriesOp(ctx) {
-  const results = await ctx.memoriesCollection.query(import_watermelondb4.Q.where("is_deleted", false), import_watermelondb4.Q.sortBy("created_at", import_watermelondb4.Q.desc)).fetch();
+  const results = await ctx.memoriesCollection.query(import_watermelondb6.Q.where("is_deleted", false), import_watermelondb6.Q.sortBy("created_at", import_watermelondb6.Q.desc)).fetch();
   return results.map(memoryToStored);
 }
 async function getMemoryByIdOp(ctx, id) {
@@ -2501,18 +2540,18 @@ async function getMemoryByIdOp(ctx, id) {
 }
 async function getMemoriesByNamespaceOp(ctx, namespace) {
   const results = await ctx.memoriesCollection.query(
-    import_watermelondb4.Q.where("namespace", namespace),
-    import_watermelondb4.Q.where("is_deleted", false),
-    import_watermelondb4.Q.sortBy("created_at", import_watermelondb4.Q.desc)
+    import_watermelondb6.Q.where("namespace", namespace),
+    import_watermelondb6.Q.where("is_deleted", false),
+    import_watermelondb6.Q.sortBy("created_at", import_watermelondb6.Q.desc)
   ).fetch();
   return results.map(memoryToStored);
 }
 async function getMemoriesByKeyOp(ctx, namespace, key) {
   const compositeKey = generateCompositeKey(namespace, key);
   const results = await ctx.memoriesCollection.query(
-    import_watermelondb4.Q.where("composite_key", compositeKey),
-    import_watermelondb4.Q.where("is_deleted", false),
-    import_watermelondb4.Q.sortBy("created_at", import_watermelondb4.Q.desc)
+    import_watermelondb6.Q.where("composite_key", compositeKey),
+    import_watermelondb6.Q.where("is_deleted", false),
+    import_watermelondb6.Q.sortBy("created_at", import_watermelondb6.Q.desc)
   ).fetch();
   return results.map(memoryToStored);
 }
@@ -2520,7 +2559,7 @@ async function saveMemoryOp(ctx, opts) {
   const compositeKey = generateCompositeKey(opts.namespace, opts.key);
   const uniqueKey = generateUniqueKey(opts.namespace, opts.key, opts.value);
   const result = await ctx.database.write(async () => {
-    const existing = await ctx.memoriesCollection.query(import_watermelondb4.Q.where("unique_key", uniqueKey)).fetch();
+    const existing = await ctx.memoriesCollection.query(import_watermelondb6.Q.where("unique_key", uniqueKey)).fetch();
     if (existing.length > 0) {
       const existingMemory = existing[0];
       const shouldPreserveEmbedding = existingMemory.value === opts.value && existingMemory.rawEvidence === opts.rawEvidence && existingMemory.type === opts.type && existingMemory.namespace === opts.namespace && existingMemory.key === opts.key && existingMemory.embedding !== void 0 && existingMemory.embedding.length > 0 && !opts.embedding;
@@ -2593,7 +2632,7 @@ async function updateMemoryOp(ctx, id, updates) {
   const newCompositeKey = generateCompositeKey(newNamespace, newKey);
   const newUniqueKey = generateUniqueKey(newNamespace, newKey, newValue);
   if (newUniqueKey !== memory.uniqueKey) {
-    const existing = await ctx.memoriesCollection.query(import_watermelondb4.Q.where("unique_key", newUniqueKey), import_watermelondb4.Q.where("is_deleted", false)).fetch();
+    const existing = await ctx.memoriesCollection.query(import_watermelondb6.Q.where("unique_key", newUniqueKey), import_watermelondb6.Q.where("is_deleted", false)).fetch();
     if (existing.length > 0) {
       return { ok: false, reason: "conflict", conflictingKey: newUniqueKey };
     }
@@ -2649,7 +2688,7 @@ async function deleteMemoryByIdOp(ctx, id) {
 }
 async function deleteMemoryOp(ctx, namespace, key, value) {
   const uniqueKey = generateUniqueKey(namespace, key, value);
-  const results = await ctx.memoriesCollection.query(import_watermelondb4.Q.where("unique_key", uniqueKey)).fetch();
+  const results = await ctx.memoriesCollection.query(import_watermelondb6.Q.where("unique_key", uniqueKey)).fetch();
   if (results.length > 0) {
     await ctx.database.write(async () => {
       await results[0].update((mem) => {
@@ -2660,7 +2699,7 @@ async function deleteMemoryOp(ctx, namespace, key, value) {
 }
 async function deleteMemoriesByKeyOp(ctx, namespace, key) {
   const compositeKey = generateCompositeKey(namespace, key);
-  const results = await ctx.memoriesCollection.query(import_watermelondb4.Q.where("composite_key", compositeKey), import_watermelondb4.Q.where("is_deleted", false)).fetch();
+  const results = await ctx.memoriesCollection.query(import_watermelondb6.Q.where("composite_key", compositeKey), import_watermelondb6.Q.where("is_deleted", false)).fetch();
   await ctx.database.write(async () => {
     for (const memory of results) {
       await memory.update((mem) => {
@@ -2670,7 +2709,7 @@ async function deleteMemoriesByKeyOp(ctx, namespace, key) {
   });
 }
 async function clearAllMemoriesOp(ctx) {
-  const results = await ctx.memoriesCollection.query(import_watermelondb4.Q.where("is_deleted", false)).fetch();
+  const results = await ctx.memoriesCollection.query(import_watermelondb6.Q.where("is_deleted", false)).fetch();
   await ctx.database.write(async () => {
     for (const memory of results) {
       await memory.update((mem) => {
@@ -2680,7 +2719,7 @@ async function clearAllMemoriesOp(ctx) {
   });
 }
 async function searchSimilarMemoriesOp(ctx, queryEmbedding, limit = 10, minSimilarity = 0.6) {
-  const allMemories = await ctx.memoriesCollection.query(import_watermelondb4.Q.where("is_deleted", false)).fetch();
+  const allMemories = await ctx.memoriesCollection.query(import_watermelondb6.Q.where("is_deleted", false)).fetch();
   const memoriesWithEmbeddings = allMemories.filter(
     (m) => m.embedding && m.embedding.length > 0
   );
@@ -2883,7 +2922,7 @@ var DEFAULT_COMPLETION_MODEL = "openai/gpt-4o";
 
 // src/lib/memory/embeddings.ts
 var embeddingPipeline = null;
-var generateEmbeddingForText = async (text, options = {}) => {
+var generateEmbeddingForText = async (text4, options = {}) => {
   const { baseUrl = BASE_URL, provider = "local" } = options;
   if (provider === "api") {
     const { getToken, model: model2 } = options;
@@ -2897,7 +2936,7 @@ var generateEmbeddingForText = async (text, options = {}) => {
     const response = await postApiV1Embeddings({
       baseUrl,
       body: {
-        input: text,
+        input: text4,
         model: model2 ?? DEFAULT_API_EMBEDDING_MODEL
       },
       headers: {
@@ -2923,7 +2962,7 @@ var generateEmbeddingForText = async (text, options = {}) => {
       const { pipeline } = await import("@huggingface/transformers");
       embeddingPipeline = await pipeline("feature-extraction", model);
     }
-    const output = await embeddingPipeline(text, {
+    const output = await embeddingPipeline(text4, {
       pooling: "cls",
       normalize: true
     });
@@ -2937,14 +2976,14 @@ var generateEmbeddingForText = async (text, options = {}) => {
   }
 };
 var generateEmbeddingForMemory = async (memory, options = {}) => {
-  const text = [
+  const text4 = [
     memory.rawEvidence,
     memory.type,
     memory.namespace,
     memory.key,
     memory.value
   ].filter(Boolean).join(" ");
-  return generateEmbeddingForText(text, options);
+  return generateEmbeddingForText(text4, options);
 };
 
 // src/react/useMemoryStorage.ts
@@ -3496,118 +3535,39 @@ function useMemoryStorage(options) {
   };
 }
 
-// src/lib/memoryStorage/schema.ts
-var import_watermelondb5 = require("@nozbe/watermelondb");
-var memoryStorageSchema = (0, import_watermelondb5.appSchema)({
+// src/react/useSettings.ts
+var import_react4 = require("react");
+
+// src/lib/db/settings/schema.ts
+var import_watermelondb7 = require("@nozbe/watermelondb");
+var settingsStorageSchema = (0, import_watermelondb7.appSchema)({
   version: 1,
   tables: [
-    (0, import_watermelondb5.tableSchema)({
-      name: "memories",
+    (0, import_watermelondb7.tableSchema)({
+      name: "modelPreferences",
       columns: [
-        // Memory type classification
-        { name: "type", type: "string", isIndexed: true },
-        // 'identity' | 'preference' | 'project' | 'skill' | 'constraint'
-        // Hierarchical key structure
-        { name: "namespace", type: "string", isIndexed: true },
-        { name: "key", type: "string", isIndexed: true },
-        { name: "value", type: "string" },
-        // Evidence and confidence
-        { name: "raw_evidence", type: "string" },
-        { name: "confidence", type: "number" },
-        { name: "pii", type: "boolean", isIndexed: true },
-        // Composite keys for efficient lookups
-        { name: "composite_key", type: "string", isIndexed: true },
-        // namespace:key
-        { name: "unique_key", type: "string", isIndexed: true },
-        // namespace:key:value
-        // Timestamps
-        { name: "created_at", type: "number", isIndexed: true },
-        { name: "updated_at", type: "number" },
-        // Vector embeddings for semantic search
-        { name: "embedding", type: "string", isOptional: true },
-        // JSON stringified number[]
-        { name: "embedding_model", type: "string", isOptional: true },
-        // Soft delete flag
-        { name: "is_deleted", type: "boolean", isIndexed: true }
+        { name: "wallet_address", type: "string", isIndexed: true },
+        { name: "models", type: "string", isOptional: true }
       ]
     })
   ]
 });
 
-// src/lib/memoryStorage/models.ts
-var import_watermelondb6 = require("@nozbe/watermelondb");
-var Memory = class extends import_watermelondb6.Model {
-  /** Memory type classification */
-  get type() {
-    return this._getRaw("type");
-  }
-  /** Namespace for grouping related memories */
-  get namespace() {
-    return this._getRaw("namespace");
-  }
-  /** Key within the namespace */
-  get key() {
-    return this._getRaw("key");
-  }
-  /** The memory value/content */
-  get value() {
-    return this._getRaw("value");
-  }
-  /** Raw evidence from which this memory was extracted */
-  get rawEvidence() {
-    return this._getRaw("raw_evidence");
-  }
-  /** Confidence score (0-1) */
-  get confidence() {
-    return this._getRaw("confidence");
-  }
-  /** Whether this memory contains PII */
-  get pii() {
-    return this._getRaw("pii");
-  }
-  /** Composite key (namespace:key) for efficient lookups */
-  get compositeKey() {
-    return this._getRaw("composite_key");
-  }
-  /** Unique key (namespace:key:value) for deduplication */
-  get uniqueKey() {
-    return this._getRaw("unique_key");
-  }
-  /** Created timestamp */
-  get createdAt() {
-    return new Date(this._getRaw("created_at"));
-  }
-  /** Updated timestamp */
-  get updatedAt() {
-    return new Date(this._getRaw("updated_at"));
-  }
-  /** Embedding vector for semantic search */
-  get embedding() {
-    const raw = this._getRaw("embedding");
-    if (!raw) return void 0;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return void 0;
-    }
-  }
-  /** Model used to generate embedding */
-  get embeddingModel() {
-    const value = this._getRaw("embedding_model");
-    return value ? value : void 0;
-  }
-  /** Soft delete flag */
-  get isDeleted() {
-    return this._getRaw("is_deleted");
-  }
+// src/lib/db/settings/models.ts
+var import_watermelondb8 = require("@nozbe/watermelondb");
+var import_decorators3 = require("@nozbe/watermelondb/decorators");
+var ModelPreference = class extends import_watermelondb8.Model {
 };
-Memory.table = "memories";
-
-// src/react/useSettings.ts
-var import_react4 = require("react");
+ModelPreference.table = "modelPreferences";
+__decorateClass([
+  (0, import_decorators3.text)("wallet_address")
+], ModelPreference.prototype, "walletAddress", 2);
+__decorateClass([
+  (0, import_decorators3.text)("models")
+], ModelPreference.prototype, "models", 2);
 
-// src/lib/settingsStorage/operations.ts
-var import_watermelondb7 = require("@nozbe/watermelondb");
+// src/lib/db/settings/operations.ts
+var import_watermelondb9 = require("@nozbe/watermelondb");
 function modelPreferenceToStored(preference) {
   return {
     uniqueId: preference.id,
@@ -3616,12 +3576,12 @@ function modelPreferenceToStored(preference) {
   };
 }
 async function getModelPreferenceOp(ctx, walletAddress) {
-  const results = await ctx.modelPreferencesCollection.query(import_watermelondb7.Q.where("wallet_address", walletAddress)).fetch();
+  const results = await ctx.modelPreferencesCollection.query(import_watermelondb9.Q.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(import_watermelondb7.Q.where("wallet_address", walletAddress)).fetch();
+    const results = await ctx.modelPreferencesCollection.query(import_watermelondb9.Q.where("wallet_address", walletAddress)).fetch();
     if (results.length > 0) {
       const preference = results[0];
       await preference.update((pref) => {
@@ -3639,7 +3599,7 @@ async function setModelPreferenceOp(ctx, walletAddress, models) {
   return modelPreferenceToStored(result);
 }
 async function deleteModelPreferenceOp(ctx, walletAddress) {
-  const results = await ctx.modelPreferencesCollection.query(import_watermelondb7.Q.where("wallet_address", walletAddress)).fetch();
+  const results = await ctx.modelPreferencesCollection.query(import_watermelondb9.Q.where("wallet_address", walletAddress)).fetch();
   if (results.length === 0) return false;
   await ctx.database.write(async () => {
     await results[0].destroyPermanently();
@@ -3744,37 +3704,6 @@ function useSettings(options) {
   };
 }
 
-// src/lib/settingsStorage/schema.ts
-var import_watermelondb8 = require("@nozbe/watermelondb");
-var settingsStorageSchema = (0, import_watermelondb8.appSchema)({
-  version: 1,
-  tables: [
-    (0, import_watermelondb8.tableSchema)({
-      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
-var import_watermelondb9 = require("@nozbe/watermelondb");
-var ModelPreference = class extends import_watermelondb9.Model {
-  /** 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
 var import_react5 = require("react");
 
@@ -3845,13 +3774,13 @@ function usePdf() {
         const contexts = await Promise.all(
           pdfFiles.map(async (file) => {
             try {
-              const text = await extractTextFromPdf(file.url);
-              if (!text.trim()) {
+              const text4 = await extractTextFromPdf(file.url);
+              if (!text4.trim()) {
                 console.warn(`No text found in PDF ${file.filename}`);
                 return null;
               }
               return `[Context from PDF attachment ${file.filename}]:
-${text}`;
+${text4}`;
             } catch (err) {
               console.error(`Failed to process PDF ${file.filename}:`, err);
               return null;
@@ -3931,15 +3860,15 @@ function useOCR() {
                 const result = await import_tesseract.default.recognize(image, language);
                 pageTexts.push(result.data.text);
               }
-              const text = pageTexts.join("\n\n");
-              if (!text.trim()) {
+              const text4 = pageTexts.join("\n\n");
+              if (!text4.trim()) {
                 console.warn(
                   `No text found in OCR source ${filename || "unknown"}`
                 );
                 return null;
               }
               return `[Context from OCR attachment ${filename || "unknown"}]:
-${text}`;
+${text4}`;
             } catch (err) {
               console.error(
                 `Failed to process OCR for ${file.filename || "unknown"}:`,
@@ -4292,15 +4221,934 @@ 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
+var import_react11 = require("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
+var import_react10 = require("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 = (0, import_react10.createContext)(null);
+function DropboxAuthProvider({
+  appKey,
+  callbackPath = "/auth/dropbox/callback",
+  children
+}) {
+  const [accessToken, setAccessToken] = (0, import_react10.useState)(null);
+  const isConfigured = !!appKey;
+  (0, import_react10.useEffect)(() => {
+    const storedToken = getStoredToken();
+    if (storedToken) {
+      setAccessToken(storedToken);
+    }
+  }, []);
+  (0, import_react10.useEffect)(() => {
+    if (!isConfigured || !appKey) return;
+    const handleCallback = async () => {
+      const token = await handleDropboxCallback(appKey, callbackPath);
+      if (token) {
+        setAccessToken(token);
+      }
+    };
+    handleCallback();
+  }, [appKey, callbackPath, isConfigured]);
+  const requestAccess = (0, import_react10.useCallback)(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 = (0, import_react10.useCallback)(() => {
+    clearToken();
+    setAccessToken(null);
+  }, []);
+  return (0, import_react10.createElement)(
+    DropboxAuthContext.Provider,
+    {
+      value: {
+        accessToken,
+        isAuthenticated: !!accessToken,
+        isConfigured,
+        requestAccess,
+        logout
+      }
+    },
+    children
+  );
+}
+function useDropboxAuth() {
+  const context = (0, import_react10.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 = (0, import_react11.useMemo)(
+    () => ({
+      requestDropboxAccess: requestDropboxAccess2,
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [requestDropboxAccess2, requestEncryptionKey2, exportConversation, importConversation]
+  );
+  const ensureToken = (0, import_react11.useCallback)(async () => {
+    if (dropboxToken) return dropboxToken;
+    try {
+      return await requestDropboxAccess2();
+    } catch {
+      return null;
+    }
+  }, [dropboxToken, requestDropboxAccess2]);
+  const backup = (0, import_react11.useCallback)(
+    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 = (0, import_react11.useCallback)(
+    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
+var import_react12 = require("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 = (0, import_react12.useMemo)(
+    () => ({
+      requestDriveAccess,
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [
+      requestDriveAccess,
+      requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    ]
+  );
+  const ensureToken = (0, import_react12.useCallback)(async () => {
+    if (accessToken) return accessToken;
+    try {
+      return await requestDriveAccess();
+    } catch {
+      return null;
+    }
+  }, [accessToken, requestDriveAccess]);
+  const backup = (0, import_react12.useCallback)(
+    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 = (0, import_react12.useCallback)(
+    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
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ChatConversation,
   ChatMessage,
+  DEFAULT_BACKUP_FOLDER,
+  DEFAULT_DRIVE_CONVERSATIONS_FOLDER,
+  DEFAULT_DRIVE_ROOT_FOLDER,
   DEFAULT_TOOL_SELECTOR_MODEL,
+  DropboxAuthProvider,
   StoredMemoryModel,
   StoredModelPreferenceModel,
   chatStorageMigrations,
   chatStorageSchema,
+  clearDropboxToken,
   createMemoryContextSystemMessage,
   decryptData,
   decryptDataBytes,
@@ -4311,14 +5159,19 @@ var extractConversationContext = (messages, maxMessages = 3) => {
   generateCompositeKey,
   generateConversationId,
   generateUniqueKey,
+  getDropboxToken,
   hasEncryptionKey,
   memoryStorageSchema,
   requestEncryptionKey,
   selectTool,
   settingsStorageSchema,
+  storeDropboxToken,
   useChat,
   useChatStorage,
+  useDropboxAuth,
+  useDropboxBackup,
   useEncryption,
+  useGoogleDriveBackup,
   useImageGeneration,
   useMemoryStorage,
   useModels,