@reverbia/sdk 1.0.0-next.20260110032702 → 1.0.0-next.20260110210906

package/dist/react/index.mjs

@@ -2255,7 +2255,7 @@ function useEncryption(signMessage, embeddedWalletSigner) {
 }
 
 // src/react/useChatStorage.ts
-import { useCallback as useCallback2, useState as useState2, useMemo } from "react";
+import { useCallback as useCallback2, useState as useState2, useMemo, useRef as useRef2, useEffect as useEffect2 } from "react";
 
 // src/lib/db/chat/schema.ts
 import { appSchema, tableSchema } from "@nozbe/watermelondb";
@@ -2700,21 +2700,262 @@ 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 storedToLlmapiMessage(stored) {
-  const content = [
-    { type: "text", text: stored.content }
-  ];
+function replaceUrlWithMCPPlaceholder(content, url, fileId) {
+  const escapedUrl = url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const placeholder = `![MCP_IMAGE:${fileId}]`;
+  let result = content;
+  const markdownImagePattern = new RegExp(
+    `!\\[[^\\]]*\\]\\([\\s]*${escapedUrl}[\\s]*\\)`,
+    "g"
+  );
+  result = result.replace(markdownImagePattern, placeholder);
+  result = result.replace(new RegExp(escapedUrl, "g"), placeholder);
+  const orphanedMarkdownPattern = new RegExp(
+    `!\\[[^\\]]*\\]\\([\\s]*\\!\\[MCP_IMAGE:${fileId}\\][\\s]*\\)`,
+    "g"
+  );
+  result = result.replace(orphanedMarkdownPattern, placeholder);
+  return result;
+}
+function findFileIdBySourceUrl(files, sourceUrl) {
+  return files?.find((f) => f.sourceUrl === sourceUrl)?.id;
+}
+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
@@ -2731,9 +2972,17 @@ function useChatStorage(options) {
     onData,
     onFinish,
     onError,
-    apiType
+    apiType,
+    walletAddress
   } = options;
   const [currentConversationId, setCurrentConversationId] = useState2(initialConversationId || null);
+  const blobManagerRef = useRef2(new BlobUrlManager());
+  useEffect2(() => {
+    const manager = blobManagerRef.current;
+    return () => {
+      manager.revokeAll();
+    };
+  }, []);
   const messagesCollection = useMemo(
     () => database.get("history"),
     [database]
@@ -2801,9 +3050,49 @@ function useChatStorage(options) {
   );
   const getMessages = useCallback2(
     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 = useCallback2(
     async (convId) => {
@@ -2927,7 +3216,8 @@ function useChatStorage(options) {
     []
   );
   const extractAndStoreMCPImages = useCallback2(
-    async (content, writeFile) => {
+    async (content, writeFile, options2) => {
+      const { replaceUrls = true } = options2 ?? {};
       try {
         const MCP_IMAGE_URL_PATTERN = new RegExp(
           `https://${MCP_R2_DOMAIN.replace(/\./g, "\\.")}[^\\s)]*`,
@@ -3001,9 +3291,10 @@ function useChatStorage(options) {
               id: fileId,
               name: fileName,
               type: mimeType,
-              size
+              size,
+              sourceUrl: imageUrl
             });
-            if (imageUrl) {
+            if (replaceUrls && imageUrl) {
               replaceUrlWithPlaceholder(imageUrl, fileId);
             }
           } else {
@@ -3025,6 +3316,89 @@ function useChatStorage(options) {
     },
     []
   );
+  const extractAndStoreEncryptedMCPImages = useCallback2(
+    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 = useCallback2(
     async (args) => {
       const {
@@ -3076,10 +3450,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];
       }
@@ -3217,7 +3591,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
@@ -3253,7 +3634,7 @@ function useChatStorage(options) {
         assistantMessage: storedAssistantMessage
       };
     },
-    [ensureConversation, getMessages, storageCtx, baseSendMessage]
+    [ensureConversation, getMessages, storageCtx, baseSendMessage, walletAddress, extractAndStoreEncryptedMCPImages]
   );
   const searchMessages = useCallback2(
     async (queryVector, options2) => {
@@ -3576,7 +3957,7 @@ var sdkModelClasses = [
 ];
 
 // src/react/useMemoryStorage.ts
-import { useCallback as useCallback3, useState as useState3, useMemo as useMemo2, useRef as useRef2 } from "react";
+import { useCallback as useCallback3, useState as useState3, useMemo as useMemo2, useRef as useRef3 } from "react";
 import { postApiV1ChatCompletions } from "@reverbia/sdk";
 
 // src/lib/db/memory/schema.ts
@@ -4368,7 +4749,7 @@ function useMemoryStorage(options) {
   } = options;
   const embeddingModel = userEmbeddingModel === void 0 ? DEFAULT_API_EMBEDDING_MODEL : userEmbeddingModel;
   const [memories, setMemories] = useState3([]);
-  const extractionInProgressRef = useRef2(false);
+  const extractionInProgressRef = useRef3(false);
   const memoriesCollection = useMemo2(
     () => database.get("memories"),
     [database]
@@ -4892,7 +5273,7 @@ function useMemoryStorage(options) {
 
 // src/react/useSettings.ts
 import { Q as Q5 } from "@nozbe/watermelondb";
-import { useCallback as useCallback4, useState as useState4, useMemo as useMemo3, useEffect as useEffect2 } from "react";
+import { useCallback as useCallback4, useState as useState4, useMemo as useMemo3, useEffect as useEffect3 } from "react";
 
 // src/lib/db/settings/schema.ts
 import { appSchema as appSchema4, tableSchema as tableSchema4 } from "@nozbe/watermelondb";
@@ -5369,7 +5750,7 @@ function useSettings(options) {
     },
     [storageCtx, walletAddress]
   );
-  useEffect2(() => {
+  useEffect3(() => {
     if (!walletAddress) {
       setModelPreferenceState(null);
       setUserPreferenceState(null);
@@ -5407,7 +5788,7 @@ function useSettings(options) {
       cancelled = true;
     };
   }, [walletAddress, storageCtx, legacyStorageCtx]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (!walletAddress) return;
     const subscription = userPreferencesCollection.query(Q5.where("wallet_address", walletAddress)).observeWithColumns([
       "nickname",
@@ -5648,22 +6029,22 @@ ${text5}`;
 }
 
 // src/react/useModels.ts
-import { useCallback as useCallback7, useEffect as useEffect3, useRef as useRef3, useState as useState7 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect4, useRef as useRef4, useState as useState7 } from "react";
 function useModels(options = {}) {
   const { getToken, baseUrl = BASE_URL, provider, autoFetch = true } = options;
   const [models, setModels] = useState7([]);
   const [isLoading, setIsLoading] = useState7(false);
   const [error, setError] = useState7(null);
-  const getTokenRef = useRef3(getToken);
-  const baseUrlRef = useRef3(baseUrl);
-  const providerRef = useRef3(provider);
-  const abortControllerRef = useRef3(null);
-  useEffect3(() => {
+  const getTokenRef = useRef4(getToken);
+  const baseUrlRef = useRef4(baseUrl);
+  const providerRef = useRef4(provider);
+  const abortControllerRef = useRef4(null);
+  useEffect4(() => {
     getTokenRef.current = getToken;
     baseUrlRef.current = baseUrl;
     providerRef.current = provider;
   });
-  useEffect3(() => {
+  useEffect4(() => {
     return () => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -5733,8 +6114,8 @@ function useModels(options = {}) {
     setModels([]);
     await fetchModels();
   }, [fetchModels]);
-  const hasFetchedRef = useRef3(false);
-  useEffect3(() => {
+  const hasFetchedRef = useRef4(false);
+  useEffect4(() => {
     if (autoFetch && !hasFetchedRef.current) {
       hasFetchedRef.current = true;
       fetchModels();
@@ -5752,15 +6133,15 @@ function useModels(options = {}) {
 }
 
 // src/react/useSearch.ts
-import { useCallback as useCallback8, useEffect as useEffect4, useRef as useRef4, useState as useState8 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect5, useRef as useRef5, useState as useState8 } from "react";
 function useSearch(options = {}) {
   const { getToken, baseUrl = BASE_URL, onError } = options;
   const [isLoading, setIsLoading] = useState8(false);
   const [results, setResults] = useState8(null);
   const [response, setResponse] = useState8(null);
   const [error, setError] = useState8(null);
-  const abortControllerRef = useRef4(null);
-  useEffect4(() => {
+  const abortControllerRef = useRef5(null);
+  useEffect5(() => {
     return () => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -5836,12 +6217,12 @@ function useSearch(options = {}) {
 }
 
 // src/react/useImageGeneration.ts
-import { useCallback as useCallback9, useEffect as useEffect5, useRef as useRef5, useState as useState9 } from "react";
+import { useCallback as useCallback9, useEffect as useEffect6, useRef as useRef6, useState as useState9 } from "react";
 function useImageGeneration(options = {}) {
   const { getToken, baseUrl = BASE_URL, onFinish, onError } = options;
   const [isLoading, setIsLoading] = useState9(false);
-  const abortControllerRef = useRef5(null);
-  useEffect5(() => {
+  const abortControllerRef = useRef6(null);
+  useEffect6(() => {
     return () => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -6223,7 +6604,7 @@ import {
   createElement,
   useCallback as useCallback10,
   useContext,
-  useEffect as useEffect6,
+  useEffect as useEffect7,
   useState as useState10
 } from "react";
 
@@ -6554,7 +6935,7 @@ function DropboxAuthProvider({
 }) {
   const [accessToken, setAccessToken] = useState10(null);
   const isConfigured = !!appKey;
-  useEffect6(() => {
+  useEffect7(() => {
     const checkStoredToken = async () => {
       if (walletAddress) {
         await migrateUnencryptedTokens("dropbox", walletAddress);
@@ -6568,7 +6949,7 @@ function DropboxAuthProvider({
     };
     checkStoredToken();
   }, [apiClient, walletAddress]);
-  useEffect6(() => {
+  useEffect7(() => {
     if (!isConfigured) return;
     const handleCallback = async () => {
       if (isDropboxCallback()) {
@@ -6740,7 +7121,7 @@ import {
   createElement as createElement2,
   useCallback as useCallback12,
   useContext as useContext2,
-  useEffect as useEffect7,
+  useEffect as useEffect8,
   useState as useState11
 } from "react";
 
@@ -6974,7 +7355,7 @@ function GoogleDriveAuthProvider({
 }) {
   const [accessToken, setAccessToken] = useState11(null);
   const isConfigured = !!clientId;
-  useEffect7(() => {
+  useEffect8(() => {
     const checkStoredToken = async () => {
       if (walletAddress) {
         await migrateUnencryptedTokens("google-drive", walletAddress);
@@ -6988,7 +7369,7 @@ function GoogleDriveAuthProvider({
     };
     checkStoredToken();
   }, [apiClient, walletAddress]);
-  useEffect7(() => {
+  useEffect8(() => {
     if (!isConfigured) return;
     const handleCallback = async () => {
       if (isGoogleDriveCallback()) {
@@ -7471,7 +7852,7 @@ import {
   createElement as createElement3,
   useCallback as useCallback14,
   useContext as useContext3,
-  useEffect as useEffect8,
+  useEffect as useEffect9,
   useState as useState12
 } from "react";
 
@@ -7721,7 +8102,7 @@ function ICloudAuthProvider({
   const [isAvailable, setIsAvailable] = useState12(false);
   const [isConfigured, setIsConfigured] = useState12(false);
   const [isLoading, setIsLoading] = useState12(false);
-  useEffect8(() => {
+  useEffect9(() => {
     if (!apiToken || typeof window === "undefined") {
       return;
     }
@@ -8037,7 +8418,7 @@ import {
   createElement as createElement4,
   useCallback as useCallback16,
   useContext as useContext4,
-  useEffect as useEffect9,
+  useEffect as useEffect10,
   useState as useState13
 } from "react";
 var BackupAuthContext = createContext4(null);
@@ -8061,7 +8442,7 @@ function BackupAuthProvider({
   const [icloudUserRecordName, setIcloudUserRecordName] = useState13(null);
   const [isIcloudAvailable, setIsIcloudAvailable] = useState13(false);
   const isIcloudConfigured = isIcloudAvailable && !!icloudApiToken;
-  useEffect9(() => {
+  useEffect10(() => {
     const checkStoredTokens = async () => {
       if (walletAddress) {
         await Promise.all([
@@ -8084,7 +8465,7 @@ function BackupAuthProvider({
     };
     checkStoredTokens();
   }, [apiClient, walletAddress]);
-  useEffect9(() => {
+  useEffect10(() => {
     if (!icloudApiToken || typeof window === "undefined") {
       return;
     }
@@ -8112,7 +8493,7 @@ function BackupAuthProvider({
     };
     initCloudKit();
   }, [icloudApiToken, icloudContainerIdentifier, icloudEnvironment]);
-  useEffect9(() => {
+  useEffect10(() => {
     if (!isDropboxConfigured) return;
     const handleCallback = async () => {
       if (isDropboxCallback()) {
@@ -8132,7 +8513,7 @@ function BackupAuthProvider({
     };
     handleCallback();
   }, [dropboxCallbackPath, isDropboxConfigured, apiClient, walletAddress]);
-  useEffect9(() => {
+  useEffect10(() => {
     if (!isGoogleConfigured) return;
     const handleCallback = async () => {
       if (isGoogleDriveCallback()) {
@@ -9060,6 +9441,7 @@ export {
   DEFAULT_ROOT_FOLDER as BACKUP_DRIVE_ROOT_FOLDER,
   DEFAULT_BACKUP_FOLDER2 as BACKUP_ICLOUD_FOLDER,
   BackupAuthProvider,
+  BlobUrlManager,
   Conversation as ChatConversation,
   Message as ChatMessage,
   DEFAULT_BACKUP_FOLDER,
@@ -9089,9 +9471,12 @@ export {
   createMemoryContextSystemMessage,
   decryptData,
   decryptDataBytes,
+  deleteEncryptedFile,
   encryptData,
   exportPublicKey,
   extractConversationContext,
+  fileExists,
+  findFileIdBySourceUrl,
   formatMemoriesForChat,
   generateCompositeKey,
   generateConversationId,
@@ -9102,6 +9487,7 @@ export {
   getAndClearDriveReturnUrl,
   getCalendarAccessToken,
   getDriveAccessToken,
+  getEncryptionKey,
   getGoogleDriveStoredToken,
   getValidCalendarToken,
   getValidDriveToken,
@@ -9116,9 +9502,12 @@ export {
   hasKeyPair,
   isCalendarCallback,
   isDriveCallback,
+  isOPFSSupported,
   memoryStorageSchema,
+  readEncryptedFile,
   refreshCalendarToken,
   refreshDriveToken,
+  replaceUrlWithMCPPlaceholder,
   requestEncryptionKey,
   requestKeyPair,
   revokeCalendarToken,
@@ -9153,5 +9542,6 @@ export {
   usePdf,
   useSearch,
   useSettings,
-  userPreferencesStorageSchema
+  userPreferencesStorageSchema,
+  writeEncryptedFile
 };