@reverbia/sdk 1.0.0-next.20260110155148 → 1.0.0-next.20260110214809

package/dist/expo/index.cjs

@@ -3191,17 +3191,18 @@ async function requestEncryptionKey(walletAddress, signMessage, embeddedWalletSi
   if (existingKey) {
     return;
   }
+  const signOptions = { showWalletUIs: false };
   let signature;
   try {
     if (embeddedWalletSigner) {
-      signature = await embeddedWalletSigner(SIGN_MESSAGE);
+      signature = await embeddedWalletSigner(SIGN_MESSAGE, signOptions);
     } else {
-      signature = await signMessage(SIGN_MESSAGE);
+      signature = await signMessage(SIGN_MESSAGE, signOptions);
     }
   } catch (error) {
     if (embeddedWalletSigner && error instanceof Error) {
       console.warn("Embedded wallet signing failed, falling back to standard signMessage:", error.message);
-      signature = await signMessage(SIGN_MESSAGE);
+      signature = await signMessage(SIGN_MESSAGE, signOptions);
     } else {
       throw error;
     }

package/dist/expo/index.d.mts

@@ -695,17 +695,24 @@ interface MemoryExtractionResult {
     items: MemoryItem$1[];
 }
 
+/**
+ * Options for signing messages.
+ */
+interface SignMessageOptions {
+    /** Whether to show wallet UI during signing. Default: true */
+    showWalletUIs?: boolean;
+}
 /**
  * Type for the signMessage function that client must provide.
- * This is typically from Privy's useSignMessage hook and may show a confirmation modal.
+ * This is typically from Privy's useSignMessage hook.
  */
-type SignMessageFn = (message: string) => Promise<string>;
+type SignMessageFn = (message: string, options?: SignMessageOptions) => Promise<string>;
 /**
  * Type for embedded wallet signer function that enables silent signing.
  * For Privy embedded wallets, this can sign programmatically without user interaction
  * when configured correctly in the Privy dashboard.
  */
-type EmbeddedWalletSignerFn = (message: string) => Promise<string>;
+type EmbeddedWalletSignerFn = (message: string, options?: SignMessageOptions) => Promise<string>;
 
 type MemoryType = "identity" | "preference" | "project" | "skill" | "constraint";
 interface MemoryItem {

package/dist/expo/index.d.ts

@@ -695,17 +695,24 @@ interface MemoryExtractionResult {
     items: MemoryItem$1[];
 }
 
+/**
+ * Options for signing messages.
+ */
+interface SignMessageOptions {
+    /** Whether to show wallet UI during signing. Default: true */
+    showWalletUIs?: boolean;
+}
 /**
  * Type for the signMessage function that client must provide.
- * This is typically from Privy's useSignMessage hook and may show a confirmation modal.
+ * This is typically from Privy's useSignMessage hook.
  */
-type SignMessageFn = (message: string) => Promise<string>;
+type SignMessageFn = (message: string, options?: SignMessageOptions) => Promise<string>;
 /**
  * Type for embedded wallet signer function that enables silent signing.
  * For Privy embedded wallets, this can sign programmatically without user interaction
  * when configured correctly in the Privy dashboard.
  */
-type EmbeddedWalletSignerFn = (message: string) => Promise<string>;
+type EmbeddedWalletSignerFn = (message: string, options?: SignMessageOptions) => Promise<string>;
 
 type MemoryType = "identity" | "preference" | "project" | "skill" | "constraint";
 interface MemoryItem {

package/dist/expo/index.mjs

@@ -3155,17 +3155,18 @@ async function requestEncryptionKey(walletAddress, signMessage, embeddedWalletSi
   if (existingKey) {
     return;
   }
+  const signOptions = { showWalletUIs: false };
   let signature;
   try {
     if (embeddedWalletSigner) {
-      signature = await embeddedWalletSigner(SIGN_MESSAGE);
+      signature = await embeddedWalletSigner(SIGN_MESSAGE, signOptions);
     } else {
-      signature = await signMessage(SIGN_MESSAGE);
+      signature = await signMessage(SIGN_MESSAGE, signOptions);
     }
   } catch (error) {
     if (embeddedWalletSigner && error instanceof Error) {
       console.warn("Embedded wallet signing failed, falling back to standard signMessage:", error.message);
-      signature = await signMessage(SIGN_MESSAGE);
+      signature = await signMessage(SIGN_MESSAGE, signOptions);
     } else {
       throw error;
     }

package/dist/react/index.cjs

@@ -42,6 +42,7 @@ __export(index_exports, {
   BACKUP_DRIVE_ROOT_FOLDER: () => DEFAULT_ROOT_FOLDER,
   BACKUP_ICLOUD_FOLDER: () => DEFAULT_BACKUP_FOLDER2,
   BackupAuthProvider: () => BackupAuthProvider,
+  BlobUrlManager: () => BlobUrlManager,
   ChatConversation: () => Conversation,
   ChatMessage: () => Message,
   DEFAULT_BACKUP_FOLDER: () => DEFAULT_BACKUP_FOLDER,
@@ -71,9 +72,11 @@ __export(index_exports, {
   createMemoryContextSystemMessage: () => createMemoryContextSystemMessage,
   decryptData: () => decryptData,
   decryptDataBytes: () => decryptDataBytes,
+  deleteEncryptedFile: () => deleteEncryptedFile,
   encryptData: () => encryptData,
   exportPublicKey: () => exportPublicKey,
   extractConversationContext: () => extractConversationContext,
+  fileExists: () => fileExists,
   findFileIdBySourceUrl: () => findFileIdBySourceUrl,
   formatMemoriesForChat: () => formatMemoriesForChat,
   generateCompositeKey: () => generateCompositeKey,
@@ -85,6 +88,7 @@ __export(index_exports, {
   getAndClearDriveReturnUrl: () => getAndClearDriveReturnUrl,
   getCalendarAccessToken: () => getCalendarAccessToken,
   getDriveAccessToken: () => getDriveAccessToken,
+  getEncryptionKey: () => getEncryptionKey,
   getGoogleDriveStoredToken: () => getGoogleDriveStoredToken,
   getValidCalendarToken: () => getValidCalendarToken,
   getValidDriveToken: () => getValidDriveToken,
@@ -99,7 +103,9 @@ __export(index_exports, {
   hasKeyPair: () => hasKeyPair,
   isCalendarCallback: () => isCalendarCallback,
   isDriveCallback: () => isDriveCallback,
+  isOPFSSupported: () => isOPFSSupported,
   memoryStorageSchema: () => memoryStorageSchema,
+  readEncryptedFile: () => readEncryptedFile,
   refreshCalendarToken: () => refreshCalendarToken,
   refreshDriveToken: () => refreshDriveToken,
   replaceUrlWithMCPPlaceholder: () => replaceUrlWithMCPPlaceholder,
@@ -137,7 +143,8 @@ __export(index_exports, {
   usePdf: () => usePdf,
   useSearch: () => useSearch,
   useSettings: () => useSettings,
-  userPreferencesStorageSchema: () => userPreferencesStorageSchema
+  userPreferencesStorageSchema: () => userPreferencesStorageSchema,
+  writeEncryptedFile: () => writeEncryptedFile
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -2162,17 +2169,18 @@ async function requestEncryptionKey(walletAddress, signMessage, embeddedWalletSi
   if (existingKey) {
     return;
   }
+  const signOptions = { showWalletUIs: false };
   let signature;
   try {
     if (embeddedWalletSigner) {
-      signature = await embeddedWalletSigner(SIGN_MESSAGE);
+      signature = await embeddedWalletSigner(SIGN_MESSAGE, signOptions);
     } else {
-      signature = await signMessage(SIGN_MESSAGE);
+      signature = await signMessage(SIGN_MESSAGE, signOptions);
     }
   } catch (error) {
     if (embeddedWalletSigner && error instanceof Error) {
       console.warn("Embedded wallet signing failed, falling back to standard signMessage:", error.message);
-      signature = await signMessage(SIGN_MESSAGE);
+      signature = await signMessage(SIGN_MESSAGE, signOptions);
     } else {
       throw error;
     }
@@ -2332,17 +2340,18 @@ async function requestKeyPair(walletAddress, signMessage, embeddedWalletSigner)
       `Failed to load persisted keypair, generating new one: ${error instanceof Error ? error.message : String(error)}`
     );
   }
+  const signOptions = { showWalletUIs: false };
   let signature;
   try {
     if (embeddedWalletSigner) {
-      signature = await embeddedWalletSigner(SIGN_MESSAGE);
+      signature = await embeddedWalletSigner(SIGN_MESSAGE, signOptions);
     } else {
-      signature = await signMessage(SIGN_MESSAGE);
+      signature = await signMessage(SIGN_MESSAGE, signOptions);
     }
   } catch (error) {
     if (embeddedWalletSigner && error instanceof Error) {
       console.warn("Embedded wallet signing failed, falling back to standard signMessage:", error.message);
-      signature = await signMessage(SIGN_MESSAGE);
+      signature = await signMessage(SIGN_MESSAGE, signOptions);
     } else {
       throw error;
     }
@@ -2829,6 +2838,178 @@ async function searchMessagesOp(ctx, queryVector, options) {
   return resultsWithSimilarity.sort((a, b) => b.similarity - a.similarity).slice(0, limit);
 }
 
+// src/lib/storage/opfs.ts
+var FILE_PLACEHOLDER_PREFIX = "__SDKFILE__";
+var FILE_PLACEHOLDER_SUFFIX = "__";
+var FILE_PLACEHOLDER_REGEX = /__SDKFILE__([a-f0-9-]+)__/g;
+function createFilePlaceholder(fileId) {
+  return `${FILE_PLACEHOLDER_PREFIX}${fileId}${FILE_PLACEHOLDER_SUFFIX}`;
+}
+function extractFileIds(content) {
+  const matches = content.matchAll(FILE_PLACEHOLDER_REGEX);
+  return Array.from(matches, (m) => m[1]);
+}
+function isOPFSSupported() {
+  return typeof navigator !== "undefined" && "storage" in navigator && "getDirectory" in navigator.storage;
+}
+async function getSDKDirectory() {
+  const root = await navigator.storage.getDirectory();
+  return root.getDirectoryHandle("reverbia-sdk-files", { create: true });
+}
+function bytesToHex2(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes2(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+async function encryptBlob(blob, encryptionKey) {
+  const arrayBuffer = await blob.arrayBuffer();
+  const plaintext = new Uint8Array(arrayBuffer);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    encryptionKey,
+    plaintext
+  );
+  const combined = new Uint8Array(iv.length + ciphertext.byteLength);
+  combined.set(iv, 0);
+  combined.set(new Uint8Array(ciphertext), iv.length);
+  return bytesToHex2(combined);
+}
+async function decryptToBytes(encryptedHex, encryptionKey) {
+  const combined = hexToBytes2(encryptedHex);
+  const iv = combined.slice(0, 12);
+  const ciphertext = combined.slice(12);
+  const decrypted = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv },
+    encryptionKey,
+    ciphertext
+  );
+  return new Uint8Array(decrypted);
+}
+async function writeEncryptedFile(fileId, blob, encryptionKey, metadata) {
+  if (!isOPFSSupported()) {
+    throw new Error("OPFS is not supported in this browser");
+  }
+  const dir = await getSDKDirectory();
+  const encryptedHex = await encryptBlob(blob, encryptionKey);
+  const contentHandle = await dir.getFileHandle(`${fileId}.enc`, {
+    create: true
+  });
+  const contentWritable = await contentHandle.createWritable();
+  await contentWritable.write(encryptedHex);
+  await contentWritable.close();
+  const fileMetadata = {
+    id: fileId,
+    name: metadata?.name || `file-${fileId}`,
+    type: blob.type || "application/octet-stream",
+    size: blob.size,
+    sourceUrl: metadata?.sourceUrl,
+    createdAt: Date.now()
+  };
+  const metaHandle = await dir.getFileHandle(`${fileId}.meta.json`, {
+    create: true
+  });
+  const metaWritable = await metaHandle.createWritable();
+  await metaWritable.write(JSON.stringify(fileMetadata));
+  await metaWritable.close();
+}
+async function readEncryptedFile(fileId, encryptionKey) {
+  if (!isOPFSSupported()) {
+    throw new Error("OPFS is not supported in this browser");
+  }
+  const dir = await getSDKDirectory();
+  try {
+    const contentHandle = await dir.getFileHandle(`${fileId}.enc`);
+    const contentFile = await contentHandle.getFile();
+    const encryptedHex = await contentFile.text();
+    const metaHandle = await dir.getFileHandle(`${fileId}.meta.json`);
+    const metaFile = await metaHandle.getFile();
+    const metadata = JSON.parse(await metaFile.text());
+    const decryptedBytes = await decryptToBytes(encryptedHex, encryptionKey);
+    const blob = new Blob([decryptedBytes.buffer], { type: metadata.type });
+    return { blob, metadata };
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "NotFoundError") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function deleteEncryptedFile(fileId) {
+  if (!isOPFSSupported()) {
+    throw new Error("OPFS is not supported in this browser");
+  }
+  const dir = await getSDKDirectory();
+  try {
+    await dir.removeEntry(`${fileId}.enc`);
+    await dir.removeEntry(`${fileId}.meta.json`);
+  } catch {
+  }
+}
+async function fileExists(fileId) {
+  if (!isOPFSSupported()) {
+    return false;
+  }
+  const dir = await getSDKDirectory();
+  try {
+    await dir.getFileHandle(`${fileId}.enc`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var BlobUrlManager = class {
+  constructor() {
+    this.activeUrls = /* @__PURE__ */ new Map();
+  }
+  // fileId -> blobUrl
+  /**
+   * Creates a blob URL for a file and tracks it.
+   */
+  createUrl(fileId, blob) {
+    this.revokeUrl(fileId);
+    const url = URL.createObjectURL(blob);
+    this.activeUrls.set(fileId, url);
+    return url;
+  }
+  /**
+   * Gets the active blob URL for a file, if any.
+   */
+  getUrl(fileId) {
+    return this.activeUrls.get(fileId);
+  }
+  /**
+   * Revokes a blob URL and removes it from tracking.
+   */
+  revokeUrl(fileId) {
+    const url = this.activeUrls.get(fileId);
+    if (url) {
+      URL.revokeObjectURL(url);
+      this.activeUrls.delete(fileId);
+    }
+  }
+  /**
+   * Revokes all tracked blob URLs.
+   */
+  revokeAll() {
+    for (const url of this.activeUrls.values()) {
+      URL.revokeObjectURL(url);
+    }
+    this.activeUrls.clear();
+  }
+  /**
+   * Gets the count of active blob URLs.
+   */
+  get size() {
+    return this.activeUrls.size;
+  }
+};
+
 // src/react/useChatStorage.ts
 function replaceUrlWithMCPPlaceholder(content, url, fileId) {
   const escapedUrl = url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -2850,20 +3031,69 @@ function replaceUrlWithMCPPlaceholder(content, url, fileId) {
 function findFileIdBySourceUrl(files, sourceUrl) {
   return files?.find((f) => f.sourceUrl === sourceUrl)?.id;
 }
-function storedToLlmapiMessage(stored) {
-  const content = [
-    { type: "text", text: stored.content }
-  ];
+async function isUrlValid(url, timeoutMs = 5e3) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { Range: "bytes=0-0" },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return response.ok || response.status === 206;
+  } catch {
+    return false;
+  }
+}
+async function storedToLlmapiMessage(stored) {
+  let textContent = stored.content;
+  const fileUrlMap = /* @__PURE__ */ new Map();
+  const imageParts = [];
   if (stored.files?.length) {
     for (const file of stored.files) {
       if (file.url) {
-        content.push({
+        imageParts.push({
           type: "image_url",
           image_url: { url: file.url }
         });
+      } else if (file.sourceUrl) {
+        const isValid = await isUrlValid(file.sourceUrl);
+        if (isValid) {
+          imageParts.push({
+            type: "image_url",
+            image_url: { url: file.sourceUrl }
+          });
+          fileUrlMap.set(file.id, file.sourceUrl);
+        }
       }
     }
   }
+  textContent = textContent.replace(
+    /__SDKFILE__([a-f0-9-]+)__/g,
+    (match, fileId) => {
+      const sourceUrl = fileUrlMap.get(fileId);
+      if (sourceUrl) {
+        return `![image](${sourceUrl})`;
+      }
+      return "";
+    }
+  );
+  textContent = textContent.replace(
+    /!\[MCP_IMAGE:([a-f0-9-]+)\]/g,
+    (match, fileId) => {
+      const sourceUrl = fileUrlMap.get(fileId);
+      if (sourceUrl) {
+        return `![image](${sourceUrl})`;
+      }
+      return "";
+    }
+  );
+  textContent = textContent.replace(/\n{3,}/g, "\n\n").trim();
+  const content = [
+    { type: "text", text: textContent },
+    ...imageParts
+  ];
   return {
     role: stored.role,
     content
@@ -2880,9 +3110,17 @@ function useChatStorage(options) {
     onData,
     onFinish,
     onError,
-    apiType
+    apiType,
+    walletAddress
   } = options;
   const [currentConversationId, setCurrentConversationId] = (0, import_react2.useState)(initialConversationId || null);
+  const blobManagerRef = (0, import_react2.useRef)(new BlobUrlManager());
+  (0, import_react2.useEffect)(() => {
+    const manager = blobManagerRef.current;
+    return () => {
+      manager.revokeAll();
+    };
+  }, []);
   const messagesCollection = (0, import_react2.useMemo)(
     () => database.get("history"),
     [database]
@@ -2950,9 +3188,49 @@ function useChatStorage(options) {
   );
   const getMessages = (0, import_react2.useCallback)(
     async (convId) => {
-      return getMessagesOp(storageCtx, convId);
+      const messages = await getMessagesOp(storageCtx, convId);
+      if (walletAddress && hasEncryptionKey(walletAddress) && isOPFSSupported()) {
+        try {
+          const encryptionKey = await getEncryptionKey(walletAddress);
+          const blobManager = blobManagerRef.current;
+          const resolvedMessages = await Promise.all(
+            messages.map(async (msg) => {
+              const fileIds = extractFileIds(msg.content);
+              if (fileIds.length === 0) {
+                return msg;
+              }
+              let resolvedContent = msg.content;
+              for (const fileId of fileIds) {
+                let url = blobManager.getUrl(fileId);
+                if (!url) {
+                  const result = await readEncryptedFile(fileId, encryptionKey);
+                  if (result) {
+                    url = blobManager.createUrl(fileId, result.blob);
+                  }
+                }
+                if (url) {
+                  const placeholder = createFilePlaceholder(fileId);
+                  resolvedContent = resolvedContent.replace(
+                    new RegExp(
+                      placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+                      "g"
+                    ),
+                    `![image](${url})`
+                  );
+                }
+              }
+              return { ...msg, content: resolvedContent };
+            })
+          );
+          return resolvedMessages;
+        } catch (error) {
+          console.error("[useChatStorage] Failed to resolve file placeholders:", error);
+          return messages;
+        }
+      }
+      return messages;
     },
-    [storageCtx]
+    [storageCtx, walletAddress]
   );
   const getMessageCount = (0, import_react2.useCallback)(
     async (convId) => {
@@ -3176,6 +3454,89 @@ function useChatStorage(options) {
     },
     []
   );
+  const extractAndStoreEncryptedMCPImages = (0, import_react2.useCallback)(
+    async (content, address) => {
+      try {
+        if (!isOPFSSupported()) {
+          console.warn("[extractAndStoreEncryptedMCPImages] OPFS not supported");
+          return { processedFiles: [], cleanedContent: content };
+        }
+        if (!hasEncryptionKey(address)) {
+          console.warn("[extractAndStoreEncryptedMCPImages] Encryption key not available");
+          return { processedFiles: [], cleanedContent: content };
+        }
+        const MCP_IMAGE_URL_PATTERN = new RegExp(
+          `https://${MCP_R2_DOMAIN.replace(/\./g, "\\.")}[^\\s)]*`,
+          "g"
+        );
+        const urlMatches = content.match(MCP_IMAGE_URL_PATTERN);
+        if (!urlMatches || urlMatches.length === 0) {
+          return { processedFiles: [], cleanedContent: content };
+        }
+        const uniqueUrls = [...new Set(urlMatches)];
+        const encryptionKey = await getEncryptionKey(address);
+        const processedFiles = [];
+        let cleanedContent = content;
+        const results = await Promise.allSettled(
+          uniqueUrls.map(async (imageUrl) => {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 3e4);
+            try {
+              const response = await fetch(imageUrl, {
+                signal: controller.signal,
+                cache: "no-store"
+              });
+              if (!response.ok) {
+                throw new Error(`Failed to fetch image: ${response.status}`);
+              }
+              const blob = await response.blob();
+              const fileId = crypto.randomUUID();
+              const urlPath = imageUrl.split("?")[0] ?? imageUrl;
+              const extension = urlPath.match(/\.([a-zA-Z0-9]+)$/)?.[1] || "png";
+              const mimeType = blob.type || `image/${extension}`;
+              const fileName = `mcp-image-${Date.now()}-${fileId.slice(0, 8)}.${extension}`;
+              await writeEncryptedFile(fileId, blob, encryptionKey, {
+                name: fileName,
+                sourceUrl: imageUrl
+              });
+              return { fileId, fileName, mimeType, size: blob.size, imageUrl };
+            } finally {
+              clearTimeout(timeoutId);
+            }
+          })
+        );
+        results.forEach((result, i) => {
+          const imageUrl = uniqueUrls[i];
+          if (result.status === "fulfilled") {
+            const { fileId, fileName, mimeType, size } = result.value;
+            processedFiles.push({
+              id: fileId,
+              name: fileName,
+              type: mimeType,
+              size,
+              sourceUrl: imageUrl
+            });
+            const placeholder = createFilePlaceholder(fileId);
+            const escapedUrl = imageUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const markdownImagePattern = new RegExp(
+              `!\\[[^\\]]*\\]\\([\\s]*${escapedUrl}[\\s]*\\)`,
+              "g"
+            );
+            cleanedContent = cleanedContent.replace(markdownImagePattern, placeholder);
+            cleanedContent = cleanedContent.replace(new RegExp(escapedUrl, "g"), placeholder);
+          } else {
+            console.error("[extractAndStoreEncryptedMCPImages] Failed:", result.reason);
+          }
+        });
+        cleanedContent = cleanedContent.replace(/\n{3,}/g, "\n\n").trim();
+        return { processedFiles, cleanedContent };
+      } catch (err) {
+        console.error("[extractAndStoreEncryptedMCPImages] Unexpected error:", err);
+        return { processedFiles: [], cleanedContent: content };
+      }
+    },
+    []
+  );
   const sendMessage = (0, import_react2.useCallback)(
     async (args) => {
       const {
@@ -3227,10 +3588,10 @@ function useChatStorage(options) {
         const storedMessages = await getMessages(convId);
         const validMessages = storedMessages.filter((msg) => !msg.error);
         const limitedMessages = validMessages.slice(-maxHistoryMessages);
-        messagesToSend = [
-          ...limitedMessages.map(storedToLlmapiMessage),
-          ...messages
-        ];
+        const historyMessages = await Promise.all(
+          limitedMessages.map(storedToLlmapiMessage)
+        );
+        messagesToSend = [...historyMessages, ...messages];
       } else {
         messagesToSend = [...messages];
       }
@@ -3368,7 +3729,14 @@ function useChatStorage(options) {
       let cleanedContent = assistantContent.replace(jsonSourcesBlockRegex, "").trim();
       cleanedContent = cleanedContent.replace(/\n{3,}/g, "\n\n");
       let processedFiles = [];
-      if (writeFile) {
+      if (walletAddress) {
+        const result2 = await extractAndStoreEncryptedMCPImages(
+          cleanedContent,
+          walletAddress
+        );
+        processedFiles = result2.processedFiles;
+        cleanedContent = result2.cleanedContent;
+      } else if (writeFile) {
         const result2 = await extractAndStoreMCPImages(
           cleanedContent,
           writeFile
@@ -3404,7 +3772,7 @@ function useChatStorage(options) {
         assistantMessage: storedAssistantMessage
       };
     },
-    [ensureConversation, getMessages, storageCtx, baseSendMessage]
+    [ensureConversation, getMessages, storageCtx, baseSendMessage, walletAddress, extractAndStoreEncryptedMCPImages]
   );
   const searchMessages = (0, import_react2.useCallback)(
     async (queryVector, options2) => {
@@ -9179,6 +9547,7 @@ function hasDriveCredentials() {
   BACKUP_DRIVE_ROOT_FOLDER,
   BACKUP_ICLOUD_FOLDER,
   BackupAuthProvider,
+  BlobUrlManager,
   ChatConversation,
   ChatMessage,
   DEFAULT_BACKUP_FOLDER,
@@ -9208,9 +9577,11 @@ function hasDriveCredentials() {
   createMemoryContextSystemMessage,
   decryptData,
   decryptDataBytes,
+  deleteEncryptedFile,
   encryptData,
   exportPublicKey,
   extractConversationContext,
+  fileExists,
   findFileIdBySourceUrl,
   formatMemoriesForChat,
   generateCompositeKey,
@@ -9222,6 +9593,7 @@ function hasDriveCredentials() {
   getAndClearDriveReturnUrl,
   getCalendarAccessToken,
   getDriveAccessToken,
+  getEncryptionKey,
   getGoogleDriveStoredToken,
   getValidCalendarToken,
   getValidDriveToken,
@@ -9236,7 +9608,9 @@ function hasDriveCredentials() {
   hasKeyPair,
   isCalendarCallback,
   isDriveCallback,
+  isOPFSSupported,
   memoryStorageSchema,
+  readEncryptedFile,
   refreshCalendarToken,
   refreshDriveToken,
   replaceUrlWithMCPPlaceholder,
@@ -9274,5 +9648,6 @@ function hasDriveCredentials() {
   usePdf,
   useSearch,
   useSettings,
-  userPreferencesStorageSchema
+  userPreferencesStorageSchema,
+  writeEncryptedFile
 });