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

package/dist/expo/index.d.mts

@@ -777,12 +777,38 @@ declare function generateCompositeKey(namespace: string, key: string): string;
 declare function generateUniqueKey(namespace: string, key: string, value: string): string;
 
 type ChatRole = "user" | "assistant" | "system";
+/**
+ * Metadata for files attached to messages.
+ *
+ * Note the distinction between `url` and `sourceUrl`:
+ * - `url`: Content URL that gets sent to the AI as part of the message (e.g., data URIs for user uploads)
+ * - `sourceUrl`: Original external URL for locally-cached files (for lookup only, never sent to AI)
+ */
 interface FileMetadata {
+    /** Unique identifier for the file (used as OPFS key for cached files) */
     id: string;
+    /** Display name of the file */
     name: string;
+    /** MIME type (e.g., "image/png") */
     type: string;
+    /** File size in bytes */
     size: number;
+    /**
+     * Content URL to include when sending this message to the AI.
+     * When present, this URL is added as an `image_url` content part.
+     * Typically used for user-uploaded files (data URIs) that should be sent with the message.
+     *
+     * NOT used for MCP-cached files - those use `sourceUrl` for lookup and render from OPFS.
+     */
     url?: string;
+    /**
+     * Original external URL for files downloaded and cached locally (e.g., from MCP R2).
+     * Used purely for URL→OPFS mapping to enable fallback when the source returns 404.
+     *
+     * This is metadata for local lookup only - it is NOT sent to the AI or rendered directly.
+     * The file content is served from OPFS using the `id` field.
+     */
+    sourceUrl?: string;
 }
 interface ChatCompletionUsage {
     promptTokens?: number;

package/dist/expo/index.d.ts

@@ -777,12 +777,38 @@ declare function generateCompositeKey(namespace: string, key: string): string;
 declare function generateUniqueKey(namespace: string, key: string, value: string): string;
 
 type ChatRole = "user" | "assistant" | "system";
+/**
+ * Metadata for files attached to messages.
+ *
+ * Note the distinction between `url` and `sourceUrl`:
+ * - `url`: Content URL that gets sent to the AI as part of the message (e.g., data URIs for user uploads)
+ * - `sourceUrl`: Original external URL for locally-cached files (for lookup only, never sent to AI)
+ */
 interface FileMetadata {
+    /** Unique identifier for the file (used as OPFS key for cached files) */
     id: string;
+    /** Display name of the file */
     name: string;
+    /** MIME type (e.g., "image/png") */
     type: string;
+    /** File size in bytes */
     size: number;
+    /**
+     * Content URL to include when sending this message to the AI.
+     * When present, this URL is added as an `image_url` content part.
+     * Typically used for user-uploaded files (data URIs) that should be sent with the message.
+     *
+     * NOT used for MCP-cached files - those use `sourceUrl` for lookup and render from OPFS.
+     */
     url?: string;
+    /**
+     * Original external URL for files downloaded and cached locally (e.g., from MCP R2).
+     * Used purely for URL→OPFS mapping to enable fallback when the source returns 404.
+     *
+     * This is metadata for local lookup only - it is NOT sent to the AI or rendered directly.
+     * The file content is served from OPFS using the `id` field.
+     */
+    sourceUrl?: string;
 }
 interface ChatCompletionUsage {
     promptTokens?: number;

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,12 @@ __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,
   generateConversationId: () => generateConversationId,
@@ -84,6 +88,7 @@ __export(index_exports, {
   getAndClearDriveReturnUrl: () => getAndClearDriveReturnUrl,
   getCalendarAccessToken: () => getCalendarAccessToken,
   getDriveAccessToken: () => getDriveAccessToken,
+  getEncryptionKey: () => getEncryptionKey,
   getGoogleDriveStoredToken: () => getGoogleDriveStoredToken,
   getValidCalendarToken: () => getValidCalendarToken,
   getValidDriveToken: () => getValidDriveToken,
@@ -98,9 +103,12 @@ __export(index_exports, {
   hasKeyPair: () => hasKeyPair,
   isCalendarCallback: () => isCalendarCallback,
   isDriveCallback: () => isDriveCallback,
+  isOPFSSupported: () => isOPFSSupported,
   memoryStorageSchema: () => memoryStorageSchema,
+  readEncryptedFile: () => readEncryptedFile,
   refreshCalendarToken: () => refreshCalendarToken,
   refreshDriveToken: () => refreshDriveToken,
+  replaceUrlWithMCPPlaceholder: () => replaceUrlWithMCPPlaceholder,
   requestEncryptionKey: () => requestEncryptionKey,
   requestKeyPair: () => requestKeyPair,
   revokeCalendarToken: () => revokeCalendarToken,
@@ -135,7 +143,8 @@ __export(index_exports, {
   usePdf: () => usePdf,
   useSearch: () => useSearch,
   useSettings: () => useSettings,
-  userPreferencesStorageSchema: () => userPreferencesStorageSchema
+  userPreferencesStorageSchema: () => userPreferencesStorageSchema,
+  writeEncryptedFile: () => writeEncryptedFile
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -2827,21 +2836,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
@@ -2858,9 +3108,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]
@@ -2928,9 +3186,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) => {
@@ -3054,7 +3352,8 @@ function useChatStorage(options) {
     []
   );
   const extractAndStoreMCPImages = (0, import_react2.useCallback)(
-    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)]*`,
@@ -3128,9 +3427,10 @@ function useChatStorage(options) {
               id: fileId,
               name: fileName,
               type: mimeType,
-              size
+              size,
+              sourceUrl: imageUrl
             });
-            if (imageUrl) {
+            if (replaceUrls && imageUrl) {
               replaceUrlWithPlaceholder(imageUrl, fileId);
             }
           } else {
@@ -3152,6 +3452,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 {
@@ -3203,10 +3586,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];
       }
@@ -3344,7 +3727,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
@@ -3380,7 +3770,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) => {
@@ -9155,6 +9545,7 @@ function hasDriveCredentials() {
   BACKUP_DRIVE_ROOT_FOLDER,
   BACKUP_ICLOUD_FOLDER,
   BackupAuthProvider,
+  BlobUrlManager,
   ChatConversation,
   ChatMessage,
   DEFAULT_BACKUP_FOLDER,
@@ -9184,9 +9575,12 @@ function hasDriveCredentials() {
   createMemoryContextSystemMessage,
   decryptData,
   decryptDataBytes,
+  deleteEncryptedFile,
   encryptData,
   exportPublicKey,
   extractConversationContext,
+  fileExists,
+  findFileIdBySourceUrl,
   formatMemoriesForChat,
   generateCompositeKey,
   generateConversationId,
@@ -9197,6 +9591,7 @@ function hasDriveCredentials() {
   getAndClearDriveReturnUrl,
   getCalendarAccessToken,
   getDriveAccessToken,
+  getEncryptionKey,
   getGoogleDriveStoredToken,
   getValidCalendarToken,
   getValidDriveToken,
@@ -9211,9 +9606,12 @@ function hasDriveCredentials() {
   hasKeyPair,
   isCalendarCallback,
   isDriveCallback,
+  isOPFSSupported,
   memoryStorageSchema,
+  readEncryptedFile,
   refreshCalendarToken,
   refreshDriveToken,
+  replaceUrlWithMCPPlaceholder,
   requestEncryptionKey,
   requestKeyPair,
   revokeCalendarToken,
@@ -9248,5 +9646,6 @@ function hasDriveCredentials() {
   usePdf,
   useSearch,
   useSettings,
-  userPreferencesStorageSchema
+  userPreferencesStorageSchema,
+  writeEncryptedFile
 });