@reverbia/sdk 1.0.0-next.20251218224340 → 1.0.0-next.20251219092050

package/dist/react/index.mjs

@@ -2299,7 +2299,7 @@ function useChatStorage(options) {
           conversationId: convId,
           role: "assistant",
           content: assistantContent,
-          model: responseData.model,
+          model: responseData.model || model,
           usage: convertUsageToStored(responseData.usage),
           responseDuration,
           sources
@@ -2995,6 +2995,36 @@ var postApiV1Search = (options) => {
     }
   });
 };
+var postAuthOauthByProviderExchange = (options) => {
+  return (options.client ?? client).post({
+    url: "/auth/oauth/{provider}/exchange",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
+var postAuthOauthByProviderRefresh = (options) => {
+  return (options.client ?? client).post({
+    url: "/auth/oauth/{provider}/refresh",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
+var postAuthOauthByProviderRevoke = (options) => {
+  return (options.client ?? client).post({
+    url: "/auth/oauth/{provider}/revoke",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 
 // src/lib/memory/constants.ts
 var DEFAULT_LOCAL_EMBEDDING_MODEL = "Snowflake/snowflake-arctic-embed-xs";
@@ -4545,116 +4575,196 @@ import {
   useState as useState10
 } from "react";
 
-// src/lib/backup/dropbox/auth.ts
-var DROPBOX_AUTH_URL = "https://www.dropbox.com/oauth2/authorize";
-var DROPBOX_TOKEN_URL = "https://api.dropboxapi.com/oauth2/token";
-var TOKEN_STORAGE_KEY = "dropbox_access_token";
-var VERIFIER_STORAGE_KEY = "dropbox_code_verifier";
-function generateCodeVerifier() {
-  const array = new Uint8Array(32);
-  crypto.getRandomValues(array);
-  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+// src/lib/backup/oauth/storage.ts
+var STORAGE_KEY_PREFIX = "oauth_token_";
+function getStorageKey2(provider) {
+  return `${STORAGE_KEY_PREFIX}${provider}`;
 }
-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() {
+function getStoredTokenData(provider) {
   if (typeof window === "undefined") return null;
-  return sessionStorage.getItem(TOKEN_STORAGE_KEY);
+  try {
+    const stored = localStorage.getItem(getStorageKey2(provider));
+    if (!stored) return null;
+    const data = JSON.parse(stored);
+    if (!data.accessToken) return null;
+    return data;
+  } catch {
+    return null;
+  }
 }
-function storeToken(token) {
+function storeTokenData(provider, data) {
   if (typeof window === "undefined") return;
-  sessionStorage.setItem(TOKEN_STORAGE_KEY, token);
+  localStorage.setItem(getStorageKey2(provider), JSON.stringify(data));
 }
-function clearToken() {
+function clearTokenData(provider) {
   if (typeof window === "undefined") return;
-  sessionStorage.removeItem(TOKEN_STORAGE_KEY);
+  localStorage.removeItem(getStorageKey2(provider));
 }
-function getStoredVerifier() {
-  if (typeof window === "undefined") return null;
-  return sessionStorage.getItem(VERIFIER_STORAGE_KEY);
+function isTokenExpired(data, bufferSeconds = 60) {
+  if (!data) return true;
+  if (!data.expiresAt) return false;
+  const now = Date.now();
+  const bufferMs = bufferSeconds * 1e3;
+  return data.expiresAt - bufferMs <= now;
 }
-function storeVerifier(verifier) {
-  if (typeof window === "undefined") return;
-  sessionStorage.setItem(VERIFIER_STORAGE_KEY, verifier);
+function getValidAccessToken(provider) {
+  const data = getStoredTokenData(provider);
+  if (!data) return null;
+  if (data.expiresAt && isTokenExpired(data)) {
+    return null;
+  }
+  return data.accessToken;
 }
-function clearVerifier() {
-  if (typeof window === "undefined") return;
-  sessionStorage.removeItem(VERIFIER_STORAGE_KEY);
+function getRefreshToken(provider) {
+  const data = getStoredTokenData(provider);
+  return data?.refreshToken ?? null;
+}
+function tokenResponseToStoredData(accessToken, expiresIn, refreshToken, scope) {
+  const data = {
+    accessToken,
+    refreshToken,
+    scope
+  };
+  if (expiresIn) {
+    data.expiresAt = Date.now() + expiresIn * 1e3;
+  }
+  return data;
 }
+
+// src/lib/backup/dropbox/auth.ts
+var PROVIDER = "dropbox";
+var STATE_STORAGE_KEY = "dropbox_oauth_state";
+var DROPBOX_AUTH_URL = "https://www.dropbox.com/oauth2/authorize";
 function getRedirectUri(callbackPath) {
   if (typeof window === "undefined") return "";
   return `${window.location.origin}${callbackPath}`;
 }
-async function handleDropboxCallback(appKey, callbackPath) {
+function generateState() {
+  const array = new Uint8Array(16);
+  crypto.getRandomValues(array);
+  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function storeOAuthState(state) {
+  if (typeof window === "undefined") return;
+  sessionStorage.setItem(STATE_STORAGE_KEY, state);
+}
+function getAndClearOAuthState() {
+  if (typeof window === "undefined") return null;
+  const state = sessionStorage.getItem(STATE_STORAGE_KEY);
+  sessionStorage.removeItem(STATE_STORAGE_KEY);
+  return state;
+}
+function isDropboxCallback() {
+  if (typeof window === "undefined") return false;
+  const url = new URL(window.location.href);
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const storedState = sessionStorage.getItem(STATE_STORAGE_KEY);
+  return !!code && !!state && state === storedState;
+}
+async function handleDropboxCallback(callbackPath, apiClient) {
   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;
+  const storedState = getAndClearOAuthState();
+  if (!code || !state || state !== storedState) {
+    return null;
+  }
   try {
-    const response = await fetch(DROPBOX_TOKEN_URL, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: new URLSearchParams({
+    const response = await postAuthOauthByProviderExchange({
+      client: apiClient,
+      path: { provider: PROVIDER },
+      body: {
         code,
-        grant_type: "authorization_code",
-        client_id: appKey,
-        redirect_uri: getRedirectUri(callbackPath),
-        code_verifier: verifier
-      })
+        redirect_uri: getRedirectUri(callbackPath)
+      }
     });
-    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");
+    if (!response.data?.access_token) {
+      throw new Error("No access token in response");
     }
-    storeToken(token);
-    clearVerifier();
+    const tokenData = tokenResponseToStoredData(
+      response.data.access_token,
+      response.data.expires_in,
+      response.data.refresh_token,
+      response.data.scope
+    );
+    storeTokenData(PROVIDER, tokenData);
     window.history.replaceState({}, "", window.location.pathname);
-    return token;
+    return response.data.access_token;
+  } catch {
+    return null;
+  }
+}
+async function refreshDropboxToken(apiClient) {
+  const refreshToken = getRefreshToken(PROVIDER);
+  if (!refreshToken) return null;
+  try {
+    const response = await postAuthOauthByProviderRefresh({
+      client: apiClient,
+      path: { provider: PROVIDER },
+      body: { refresh_token: refreshToken }
+    });
+    if (!response.data?.access_token) {
+      throw new Error("No access token in refresh response");
+    }
+    const currentData = getStoredTokenData(PROVIDER);
+    const tokenData = tokenResponseToStoredData(
+      response.data.access_token,
+      response.data.expires_in,
+      response.data.refresh_token ?? currentData?.refreshToken,
+      response.data.scope ?? currentData?.scope
+    );
+    storeTokenData(PROVIDER, tokenData);
+    return response.data.access_token;
   } catch {
-    clearVerifier();
+    clearTokenData(PROVIDER);
     return null;
   }
 }
+async function revokeDropboxToken(apiClient) {
+  const tokenData = getStoredTokenData(PROVIDER);
+  if (!tokenData) return;
+  try {
+    const tokenToRevoke = tokenData.refreshToken ?? tokenData.accessToken;
+    await postAuthOauthByProviderRevoke({
+      client: apiClient,
+      path: { provider: PROVIDER },
+      body: { token: tokenToRevoke }
+    });
+  } catch {
+  } finally {
+    clearTokenData(PROVIDER);
+  }
+}
+async function getDropboxAccessToken(apiClient) {
+  const validToken = getValidAccessToken(PROVIDER);
+  if (validToken) return validToken;
+  return refreshDropboxToken(apiClient);
+}
 async function startDropboxAuth(appKey, callbackPath) {
-  const verifier = generateCodeVerifier();
-  const challenge = await generateCodeChallenge(verifier);
-  storeVerifier(verifier);
+  const state = generateState();
+  storeOAuthState(state);
   const params = new URLSearchParams({
     client_id: appKey,
     redirect_uri: getRedirectUri(callbackPath),
     response_type: "code",
-    code_challenge: challenge,
-    code_challenge_method: "S256",
-    state: "dropbox_auth",
+    state,
     token_access_type: "offline"
+    // Request refresh token
   });
   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);
+function clearToken() {
+  clearTokenData(PROVIDER);
+}
+function hasDropboxCredentials() {
+  const data = getStoredTokenData(PROVIDER);
+  return !!(data?.accessToken || data?.refreshToken);
 }
 
 // src/react/useDropboxAuth.ts
@@ -4662,26 +4772,41 @@ var DropboxAuthContext = createContext(null);
 function DropboxAuthProvider({
   appKey,
   callbackPath = "/auth/dropbox/callback",
+  apiClient,
   children
 }) {
   const [accessToken, setAccessToken] = useState10(null);
   const isConfigured = !!appKey;
   useEffect6(() => {
-    const storedToken = getStoredToken();
-    if (storedToken) {
-      setAccessToken(storedToken);
-    }
-  }, []);
+    const checkStoredToken = async () => {
+      if (hasDropboxCredentials()) {
+        const token = await getDropboxAccessToken(apiClient);
+        if (token) {
+          setAccessToken(token);
+        }
+      }
+    };
+    checkStoredToken();
+  }, [apiClient]);
   useEffect6(() => {
-    if (!isConfigured || !appKey) return;
+    if (!isConfigured) return;
     const handleCallback = async () => {
-      const token = await handleDropboxCallback(appKey, callbackPath);
-      if (token) {
-        setAccessToken(token);
+      if (isDropboxCallback()) {
+        const token = await handleDropboxCallback(callbackPath, apiClient);
+        if (token) {
+          setAccessToken(token);
+        }
       }
     };
     handleCallback();
-  }, [appKey, callbackPath, isConfigured]);
+  }, [callbackPath, isConfigured, apiClient]);
+  const refreshTokenFn = useCallback10(async () => {
+    const token = await getDropboxAccessToken(apiClient);
+    if (token) {
+      setAccessToken(token);
+    }
+    return token;
+  }, [apiClient]);
   const requestAccess = useCallback10(async () => {
     if (!isConfigured || !appKey) {
       throw new Error("Dropbox is not configured");
@@ -4689,17 +4814,17 @@ function DropboxAuthProvider({
     if (accessToken) {
       return accessToken;
     }
-    const storedToken = getStoredToken();
+    const storedToken = await getDropboxAccessToken(apiClient);
     if (storedToken) {
       setAccessToken(storedToken);
       return storedToken;
     }
-    return requestDropboxAccess(appKey, callbackPath);
-  }, [accessToken, appKey, callbackPath, isConfigured]);
-  const logout = useCallback10(() => {
-    clearToken();
+    return startDropboxAuth(appKey, callbackPath);
+  }, [accessToken, appKey, callbackPath, isConfigured, apiClient]);
+  const logout = useCallback10(async () => {
+    await revokeDropboxToken(apiClient);
     setAccessToken(null);
-  }, []);
+  }, [apiClient]);
   return createElement(
     DropboxAuthContext.Provider,
     {
@@ -4708,7 +4833,8 @@ function DropboxAuthProvider({
         isAuthenticated: !!accessToken,
         isConfigured,
         requestAccess,
-        logout
+        logout,
+        refreshToken: refreshTokenFn
       }
     },
     children
@@ -4735,25 +4861,25 @@ function useDropboxBackup(options) {
   const {
     accessToken: dropboxToken,
     isConfigured: isDropboxConfigured,
-    requestAccess: requestDropboxAccess2
+    requestAccess: requestDropboxAccess
   } = useDropboxAuth();
   const deps = useMemo4(
     () => ({
-      requestDropboxAccess: requestDropboxAccess2,
+      requestDropboxAccess,
       requestEncryptionKey: requestEncryptionKey2,
       exportConversation,
       importConversation
     }),
-    [requestDropboxAccess2, requestEncryptionKey2, exportConversation, importConversation]
+    [requestDropboxAccess, requestEncryptionKey2, exportConversation, importConversation]
   );
   const ensureToken = useCallback11(async () => {
     if (dropboxToken) return dropboxToken;
     try {
-      return await requestDropboxAccess2();
+      return await requestDropboxAccess();
     } catch {
       return null;
     }
-  }, [dropboxToken, requestDropboxAccess2]);
+  }, [dropboxToken, requestDropboxAccess]);
   const backup = useCallback11(
     async (backupOptions) => {
       if (!userAddress) {
@@ -4813,8 +4939,247 @@ function useDropboxBackup(options) {
   };
 }
 
+// src/react/useGoogleDriveAuth.ts
+import {
+  createContext as createContext2,
+  createElement as createElement2,
+  useCallback as useCallback12,
+  useContext as useContext2,
+  useEffect as useEffect7,
+  useState as useState11
+} from "react";
+
+// src/lib/backup/google/auth.ts
+var PROVIDER2 = "google-drive";
+var CODE_STORAGE_KEY = "google_oauth_state";
+var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+var DRIVE_SCOPES = [
+  "https://www.googleapis.com/auth/drive.file"
+  // Access to files created by the app
+].join(" ");
+function getRedirectUri2(callbackPath) {
+  if (typeof window === "undefined") return "";
+  return `${window.location.origin}${callbackPath}`;
+}
+function generateState2() {
+  const array = new Uint8Array(16);
+  crypto.getRandomValues(array);
+  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function storeOAuthState2(state) {
+  if (typeof window === "undefined") return;
+  sessionStorage.setItem(CODE_STORAGE_KEY, state);
+}
+function getAndClearOAuthState2() {
+  if (typeof window === "undefined") return null;
+  const state = sessionStorage.getItem(CODE_STORAGE_KEY);
+  sessionStorage.removeItem(CODE_STORAGE_KEY);
+  return state;
+}
+function isGoogleDriveCallback() {
+  if (typeof window === "undefined") return false;
+  const url = new URL(window.location.href);
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const storedState = sessionStorage.getItem(CODE_STORAGE_KEY);
+  return !!code && !!state && state === storedState;
+}
+async function handleGoogleDriveCallback(callbackPath, apiClient) {
+  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");
+  const storedState = getAndClearOAuthState2();
+  if (!code || !state || state !== storedState) {
+    return null;
+  }
+  try {
+    const response = await postAuthOauthByProviderExchange({
+      client: apiClient,
+      path: { provider: PROVIDER2 },
+      body: {
+        code,
+        redirect_uri: getRedirectUri2(callbackPath)
+      }
+    });
+    if (!response.data?.access_token) {
+      throw new Error("No access token in response");
+    }
+    const tokenData = tokenResponseToStoredData(
+      response.data.access_token,
+      response.data.expires_in,
+      response.data.refresh_token,
+      response.data.scope
+    );
+    storeTokenData(PROVIDER2, tokenData);
+    window.history.replaceState({}, "", window.location.pathname);
+    return response.data.access_token;
+  } catch {
+    return null;
+  }
+}
+async function refreshGoogleDriveToken(apiClient) {
+  const refreshToken = getRefreshToken(PROVIDER2);
+  if (!refreshToken) return null;
+  try {
+    const response = await postAuthOauthByProviderRefresh({
+      client: apiClient,
+      path: { provider: PROVIDER2 },
+      body: { refresh_token: refreshToken }
+    });
+    if (!response.data?.access_token) {
+      throw new Error("No access token in refresh response");
+    }
+    const currentData = getStoredTokenData(PROVIDER2);
+    const tokenData = tokenResponseToStoredData(
+      response.data.access_token,
+      response.data.expires_in,
+      response.data.refresh_token ?? currentData?.refreshToken,
+      response.data.scope ?? currentData?.scope
+    );
+    storeTokenData(PROVIDER2, tokenData);
+    return response.data.access_token;
+  } catch {
+    clearTokenData(PROVIDER2);
+    return null;
+  }
+}
+async function revokeGoogleDriveToken(apiClient) {
+  const tokenData = getStoredTokenData(PROVIDER2);
+  if (!tokenData) return;
+  try {
+    const tokenToRevoke = tokenData.refreshToken ?? tokenData.accessToken;
+    await postAuthOauthByProviderRevoke({
+      client: apiClient,
+      path: { provider: PROVIDER2 },
+      body: { token: tokenToRevoke }
+    });
+  } catch {
+  } finally {
+    clearTokenData(PROVIDER2);
+  }
+}
+async function getGoogleDriveAccessToken(apiClient) {
+  const validToken = getValidAccessToken(PROVIDER2);
+  if (validToken) return validToken;
+  return refreshGoogleDriveToken(apiClient);
+}
+async function startGoogleDriveAuth(clientId, callbackPath) {
+  const state = generateState2();
+  storeOAuthState2(state);
+  const params = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: getRedirectUri2(callbackPath),
+    response_type: "code",
+    scope: DRIVE_SCOPES,
+    state,
+    access_type: "offline",
+    // Request refresh token
+    prompt: "consent"
+    // Force consent to always get refresh token
+  });
+  window.location.href = `${GOOGLE_AUTH_URL}?${params.toString()}`;
+  return new Promise(() => {
+  });
+}
+function getGoogleDriveStoredToken() {
+  return getValidAccessToken(PROVIDER2);
+}
+function clearGoogleDriveToken() {
+  clearTokenData(PROVIDER2);
+}
+function hasGoogleDriveCredentials() {
+  const data = getStoredTokenData(PROVIDER2);
+  return !!(data?.accessToken || data?.refreshToken);
+}
+
+// src/react/useGoogleDriveAuth.ts
+var GoogleDriveAuthContext = createContext2(null);
+function GoogleDriveAuthProvider({
+  clientId,
+  callbackPath = "/auth/google/callback",
+  apiClient,
+  children
+}) {
+  const [accessToken, setAccessToken] = useState11(null);
+  const isConfigured = !!clientId;
+  useEffect7(() => {
+    const checkStoredToken = async () => {
+      if (hasGoogleDriveCredentials()) {
+        const token = await getGoogleDriveAccessToken(apiClient);
+        if (token) {
+          setAccessToken(token);
+        }
+      }
+    };
+    checkStoredToken();
+  }, [apiClient]);
+  useEffect7(() => {
+    if (!isConfigured) return;
+    const handleCallback = async () => {
+      if (isGoogleDriveCallback()) {
+        const token = await handleGoogleDriveCallback(callbackPath, apiClient);
+        if (token) {
+          setAccessToken(token);
+        }
+      }
+    };
+    handleCallback();
+  }, [callbackPath, isConfigured, apiClient]);
+  const refreshTokenFn = useCallback12(async () => {
+    const token = await getGoogleDriveAccessToken(apiClient);
+    if (token) {
+      setAccessToken(token);
+    }
+    return token;
+  }, [apiClient]);
+  const requestAccess = useCallback12(async () => {
+    if (!isConfigured || !clientId) {
+      throw new Error("Google Drive is not configured");
+    }
+    if (accessToken) {
+      return accessToken;
+    }
+    const storedToken = await getGoogleDriveAccessToken(apiClient);
+    if (storedToken) {
+      setAccessToken(storedToken);
+      return storedToken;
+    }
+    return startGoogleDriveAuth(clientId, callbackPath);
+  }, [accessToken, clientId, callbackPath, isConfigured, apiClient]);
+  const logout = useCallback12(async () => {
+    await revokeGoogleDriveToken(apiClient);
+    setAccessToken(null);
+  }, [apiClient]);
+  return createElement2(
+    GoogleDriveAuthContext.Provider,
+    {
+      value: {
+        accessToken,
+        isAuthenticated: !!accessToken,
+        isConfigured,
+        requestAccess,
+        logout,
+        refreshToken: refreshTokenFn
+      }
+    },
+    children
+  );
+}
+function useGoogleDriveAuth() {
+  const context = useContext2(GoogleDriveAuthContext);
+  if (!context) {
+    throw new Error(
+      "useGoogleDriveAuth must be used within GoogleDriveAuthProvider"
+    );
+  }
+  return context;
+}
+
 // src/react/useGoogleDriveBackup.ts
-import { useCallback as useCallback12, useMemo as useMemo5 } from "react";
+import { useCallback as useCallback13, useMemo as useMemo5 } from "react";
 
 // src/lib/backup/google/api.ts
 var DRIVE_API_URL = "https://www.googleapis.com/drive/v3";
@@ -5121,14 +5486,17 @@ function useGoogleDriveBackup(options) {
   const {
     database,
     userAddress,
-    accessToken,
-    requestDriveAccess,
     requestEncryptionKey: requestEncryptionKey2,
     exportConversation,
     importConversation,
     rootFolder = DEFAULT_ROOT_FOLDER,
     conversationsFolder = DEFAULT_CONVERSATIONS_FOLDER
   } = options;
+  const {
+    accessToken: driveToken,
+    isConfigured: isDriveConfigured,
+    requestAccess: requestDriveAccess
+  } = useGoogleDriveAuth();
   const deps = useMemo5(
     () => ({
       requestDriveAccess,
@@ -5136,22 +5504,17 @@ function useGoogleDriveBackup(options) {
       exportConversation,
       importConversation
     }),
-    [
-      requestDriveAccess,
-      requestEncryptionKey2,
-      exportConversation,
-      importConversation
-    ]
+    [requestDriveAccess, requestEncryptionKey2, exportConversation, importConversation]
   );
-  const ensureToken = useCallback12(async () => {
-    if (accessToken) return accessToken;
+  const ensureToken = useCallback13(async () => {
+    if (driveToken) return driveToken;
     try {
       return await requestDriveAccess();
     } catch {
       return null;
     }
-  }, [accessToken, requestDriveAccess]);
-  const backup = useCallback12(
+  }, [driveToken, requestDriveAccess]);
+  const backup = useCallback13(
     async (backupOptions) => {
       if (!userAddress) {
         return { error: "Please sign in to backup to Google Drive" };
@@ -5178,7 +5541,7 @@ function useGoogleDriveBackup(options) {
     },
     [database, userAddress, ensureToken, deps, rootFolder, conversationsFolder]
   );
-  const restore = useCallback12(
+  const restore = useCallback13(
     async (restoreOptions) => {
       if (!userAddress) {
         return { error: "Please sign in to restore from Google Drive" };
@@ -5207,22 +5570,400 @@ function useGoogleDriveBackup(options) {
   return {
     backup,
     restore,
-    isAuthenticated: !!accessToken
+    isConfigured: isDriveConfigured,
+    isAuthenticated: !!driveToken
+  };
+}
+
+// src/react/useBackupAuth.ts
+import {
+  createContext as createContext3,
+  createElement as createElement3,
+  useCallback as useCallback14,
+  useContext as useContext3,
+  useEffect as useEffect8,
+  useState as useState12
+} from "react";
+var BackupAuthContext = createContext3(null);
+function BackupAuthProvider({
+  dropboxAppKey,
+  dropboxCallbackPath = "/auth/dropbox/callback",
+  googleClientId,
+  googleCallbackPath = "/auth/google/callback",
+  apiClient,
+  children
+}) {
+  const [dropboxToken, setDropboxToken] = useState12(null);
+  const isDropboxConfigured = !!dropboxAppKey;
+  const [googleToken, setGoogleToken] = useState12(null);
+  const isGoogleConfigured = !!googleClientId;
+  useEffect8(() => {
+    const checkStoredTokens = async () => {
+      if (hasDropboxCredentials()) {
+        const token = await getDropboxAccessToken(apiClient);
+        if (token) {
+          setDropboxToken(token);
+        }
+      }
+      if (hasGoogleDriveCredentials()) {
+        const token = await getGoogleDriveAccessToken(apiClient);
+        if (token) {
+          setGoogleToken(token);
+        }
+      }
+    };
+    checkStoredTokens();
+  }, [apiClient]);
+  useEffect8(() => {
+    if (!isDropboxConfigured) return;
+    const handleCallback = async () => {
+      if (isDropboxCallback()) {
+        const token = await handleDropboxCallback(
+          dropboxCallbackPath,
+          apiClient
+        );
+        if (token) {
+          setDropboxToken(token);
+        }
+      }
+    };
+    handleCallback();
+  }, [dropboxCallbackPath, isDropboxConfigured, apiClient]);
+  useEffect8(() => {
+    if (!isGoogleConfigured) return;
+    const handleCallback = async () => {
+      if (isGoogleDriveCallback()) {
+        const token = await handleGoogleDriveCallback(
+          googleCallbackPath,
+          apiClient
+        );
+        if (token) {
+          setGoogleToken(token);
+        }
+      }
+    };
+    handleCallback();
+  }, [googleCallbackPath, isGoogleConfigured, apiClient]);
+  const refreshDropboxTokenFn = useCallback14(async () => {
+    const token = await getDropboxAccessToken(apiClient);
+    if (token) {
+      setDropboxToken(token);
+    }
+    return token;
+  }, [apiClient]);
+  const requestDropboxAccess = useCallback14(async () => {
+    if (!isDropboxConfigured || !dropboxAppKey) {
+      throw new Error("Dropbox is not configured");
+    }
+    if (dropboxToken) {
+      return dropboxToken;
+    }
+    const storedToken = await getDropboxAccessToken(apiClient);
+    if (storedToken) {
+      setDropboxToken(storedToken);
+      return storedToken;
+    }
+    return startDropboxAuth(dropboxAppKey, dropboxCallbackPath);
+  }, [
+    dropboxToken,
+    dropboxAppKey,
+    dropboxCallbackPath,
+    isDropboxConfigured,
+    apiClient
+  ]);
+  const logoutDropbox = useCallback14(async () => {
+    await revokeDropboxToken(apiClient);
+    setDropboxToken(null);
+  }, [apiClient]);
+  const refreshGoogleTokenFn = useCallback14(async () => {
+    const token = await getGoogleDriveAccessToken(apiClient);
+    if (token) {
+      setGoogleToken(token);
+    }
+    return token;
+  }, [apiClient]);
+  const requestGoogleAccess = useCallback14(async () => {
+    if (!isGoogleConfigured || !googleClientId) {
+      throw new Error("Google Drive is not configured");
+    }
+    if (googleToken) {
+      return googleToken;
+    }
+    const storedToken = await getGoogleDriveAccessToken(apiClient);
+    if (storedToken) {
+      setGoogleToken(storedToken);
+      return storedToken;
+    }
+    return startGoogleDriveAuth(googleClientId, googleCallbackPath);
+  }, [
+    googleToken,
+    googleClientId,
+    googleCallbackPath,
+    isGoogleConfigured,
+    apiClient
+  ]);
+  const logoutGoogle = useCallback14(async () => {
+    await revokeGoogleDriveToken(apiClient);
+    setGoogleToken(null);
+  }, [apiClient]);
+  const logoutAll = useCallback14(async () => {
+    await Promise.all([
+      isDropboxConfigured ? logoutDropbox() : Promise.resolve(),
+      isGoogleConfigured ? logoutGoogle() : Promise.resolve()
+    ]);
+  }, [isDropboxConfigured, isGoogleConfigured, logoutDropbox, logoutGoogle]);
+  const dropboxState = {
+    accessToken: dropboxToken,
+    isAuthenticated: !!dropboxToken,
+    isConfigured: isDropboxConfigured,
+    requestAccess: requestDropboxAccess,
+    logout: logoutDropbox,
+    refreshToken: refreshDropboxTokenFn
+  };
+  const googleDriveState = {
+    accessToken: googleToken,
+    isAuthenticated: !!googleToken,
+    isConfigured: isGoogleConfigured,
+    requestAccess: requestGoogleAccess,
+    logout: logoutGoogle,
+    refreshToken: refreshGoogleTokenFn
+  };
+  return createElement3(
+    BackupAuthContext.Provider,
+    {
+      value: {
+        dropbox: dropboxState,
+        googleDrive: googleDriveState,
+        hasAnyProvider: isDropboxConfigured || isGoogleConfigured,
+        hasAnyAuthentication: !!dropboxToken || !!googleToken,
+        logoutAll
+      }
+    },
+    children
+  );
+}
+function useBackupAuth() {
+  const context = useContext3(BackupAuthContext);
+  if (!context) {
+    throw new Error("useBackupAuth must be used within BackupAuthProvider");
+  }
+  return context;
+}
+
+// src/react/useBackup.ts
+import { useCallback as useCallback15, useMemo as useMemo6 } from "react";
+function useBackup(options) {
+  const {
+    database,
+    userAddress,
+    requestEncryptionKey: requestEncryptionKey2,
+    exportConversation,
+    importConversation,
+    dropboxFolder = DEFAULT_BACKUP_FOLDER,
+    googleRootFolder = DEFAULT_ROOT_FOLDER,
+    googleConversationsFolder = DEFAULT_CONVERSATIONS_FOLDER
+  } = options;
+  const {
+    dropbox: dropboxAuth,
+    googleDrive: googleDriveAuth,
+    hasAnyProvider,
+    hasAnyAuthentication,
+    logoutAll
+  } = useBackupAuth();
+  const dropboxDeps = useMemo6(
+    () => ({
+      requestDropboxAccess: dropboxAuth.requestAccess,
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [dropboxAuth.requestAccess, requestEncryptionKey2, exportConversation, importConversation]
+  );
+  const googleDriveDeps = useMemo6(
+    () => ({
+      requestDriveAccess: googleDriveAuth.requestAccess,
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [googleDriveAuth.requestAccess, requestEncryptionKey2, exportConversation, importConversation]
+  );
+  const dropboxBackup = useCallback15(
+    async (backupOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to backup to Dropbox" };
+      }
+      let token = dropboxAuth.accessToken;
+      if (!token) {
+        try {
+          token = await dropboxAuth.requestAccess();
+        } catch {
+          return { error: "Dropbox access denied" };
+        }
+      }
+      try {
+        return await performDropboxExport(
+          database,
+          userAddress,
+          token,
+          dropboxDeps,
+          backupOptions?.onProgress,
+          dropboxFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to backup to Dropbox"
+        };
+      }
+    },
+    [database, userAddress, dropboxAuth, dropboxDeps, dropboxFolder]
+  );
+  const dropboxRestore = useCallback15(
+    async (restoreOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to restore from Dropbox" };
+      }
+      let token = dropboxAuth.accessToken;
+      if (!token) {
+        try {
+          token = await dropboxAuth.requestAccess();
+        } catch {
+          return { error: "Dropbox access denied" };
+        }
+      }
+      try {
+        return await performDropboxImport(
+          userAddress,
+          token,
+          dropboxDeps,
+          restoreOptions?.onProgress,
+          dropboxFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to restore from Dropbox"
+        };
+      }
+    },
+    [userAddress, dropboxAuth, dropboxDeps, dropboxFolder]
+  );
+  const googleDriveBackup = useCallback15(
+    async (backupOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to backup to Google Drive" };
+      }
+      let token = googleDriveAuth.accessToken;
+      if (!token) {
+        try {
+          token = await googleDriveAuth.requestAccess();
+        } catch {
+          return { error: "Google Drive access denied" };
+        }
+      }
+      try {
+        return await performGoogleDriveExport(
+          database,
+          userAddress,
+          token,
+          googleDriveDeps,
+          backupOptions?.onProgress,
+          googleRootFolder,
+          googleConversationsFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to backup to Google Drive"
+        };
+      }
+    },
+    [
+      database,
+      userAddress,
+      googleDriveAuth,
+      googleDriveDeps,
+      googleRootFolder,
+      googleConversationsFolder
+    ]
+  );
+  const googleDriveRestore = useCallback15(
+    async (restoreOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to restore from Google Drive" };
+      }
+      let token = googleDriveAuth.accessToken;
+      if (!token) {
+        try {
+          token = await googleDriveAuth.requestAccess();
+        } catch {
+          return { error: "Google Drive access denied" };
+        }
+      }
+      try {
+        return await performGoogleDriveImport(
+          userAddress,
+          token,
+          googleDriveDeps,
+          restoreOptions?.onProgress,
+          googleRootFolder,
+          googleConversationsFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to restore from Google Drive"
+        };
+      }
+    },
+    [
+      userAddress,
+      googleDriveAuth,
+      googleDriveDeps,
+      googleRootFolder,
+      googleConversationsFolder
+    ]
+  );
+  const dropboxState = {
+    isConfigured: dropboxAuth.isConfigured,
+    isAuthenticated: dropboxAuth.isAuthenticated,
+    backup: dropboxBackup,
+    restore: dropboxRestore,
+    connect: dropboxAuth.requestAccess,
+    disconnect: dropboxAuth.logout
+  };
+  const googleDriveState = {
+    isConfigured: googleDriveAuth.isConfigured,
+    isAuthenticated: googleDriveAuth.isAuthenticated,
+    backup: googleDriveBackup,
+    restore: googleDriveRestore,
+    connect: googleDriveAuth.requestAccess,
+    disconnect: googleDriveAuth.logout
+  };
+  return {
+    dropbox: dropboxState,
+    googleDrive: googleDriveState,
+    hasAnyProvider,
+    hasAnyAuthentication,
+    disconnectAll: logoutAll
   };
 }
 export {
+  DEFAULT_CONVERSATIONS_FOLDER as BACKUP_DRIVE_CONVERSATIONS_FOLDER,
+  DEFAULT_ROOT_FOLDER as BACKUP_DRIVE_ROOT_FOLDER,
+  BackupAuthProvider,
   Conversation as ChatConversation,
   Message as ChatMessage,
   DEFAULT_BACKUP_FOLDER,
   DEFAULT_CONVERSATIONS_FOLDER as DEFAULT_DRIVE_CONVERSATIONS_FOLDER,
   DEFAULT_ROOT_FOLDER as DEFAULT_DRIVE_ROOT_FOLDER,
+  DEFAULT_BACKUP_FOLDER as DEFAULT_DROPBOX_FOLDER,
   DEFAULT_TOOL_SELECTOR_MODEL,
   DropboxAuthProvider,
+  GoogleDriveAuthProvider,
   Memory as StoredMemoryModel,
   ModelPreference as StoredModelPreferenceModel,
   chatStorageMigrations,
   chatStorageSchema,
   clearToken as clearDropboxToken,
+  clearGoogleDriveToken,
   createMemoryContextSystemMessage,
   decryptData,
   decryptDataBytes,
@@ -5233,8 +5974,10 @@ export {
   generateCompositeKey,
   generateConversationId,
   generateUniqueKey,
-  getStoredToken as getDropboxToken,
+  getGoogleDriveStoredToken,
+  hasDropboxCredentials,
   hasEncryptionKey,
+  hasGoogleDriveCredentials,
   memoryStorageSchema,
   requestEncryptionKey,
   sdkMigrations,
@@ -5242,12 +5985,14 @@ export {
   sdkSchema,
   selectTool,
   settingsStorageSchema,
-  storeToken as storeDropboxToken,
+  useBackup,
+  useBackupAuth,
   useChat,
   useChatStorage,
   useDropboxAuth,
   useDropboxBackup,
   useEncryption,
+  useGoogleDriveAuth,
   useGoogleDriveBackup,
   useImageGeneration,
   useMemoryStorage,