integrate-sdk 0.8.27 → 0.8.28-dev.1

package/dist/oauth.js

@@ -627,6 +627,277 @@ class OAuthWindowManager {
   }
 }
 
+// src/oauth/indexeddb-storage.ts
+class IndexedDBStorage {
+  db = null;
+  initPromise = null;
+  async init() {
+    if (this.db) {
+      return this.db;
+    }
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = new Promise((resolve, reject) => {
+      if (typeof window === "undefined" || !window.indexedDB) {
+        reject(new Error("IndexedDB is not available in this environment"));
+        return;
+      }
+      const request = window.indexedDB.open(DB_NAME, DB_VERSION);
+      request.onerror = () => {
+        this.initPromise = null;
+        reject(new Error(`Failed to open IndexedDB: ${request.error?.message}`));
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        this.initPromise = null;
+        resolve(this.db);
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          const store = db.createObjectStore(STORE_NAME, { keyPath: "accountId" });
+          store.createIndex("provider", "provider", { unique: false });
+          store.createIndex("email", "email", { unique: false });
+          store.createIndex("provider_email", ["provider", "email"], { unique: true });
+        }
+      };
+    });
+    return this.initPromise;
+  }
+  generateAccountId(provider, email) {
+    const str = `${provider}:${email}`;
+    let hash = 0;
+    for (let i = 0;i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return `${provider}_${Math.abs(hash).toString(36)}`;
+  }
+  async saveToken(provider, email, tokenData) {
+    const db = await this.init();
+    const accountId = this.generateAccountId(provider, email);
+    const now = Date.now();
+    const entry = {
+      provider,
+      email,
+      accountId,
+      tokenData,
+      createdAt: now,
+      updatedAt: now
+    };
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      const getRequest = store.get(accountId);
+      getRequest.onsuccess = () => {
+        const existing = getRequest.result;
+        if (existing) {
+          entry.createdAt = existing.createdAt;
+        }
+        const putRequest = store.put(entry);
+        putRequest.onsuccess = () => resolve();
+        putRequest.onerror = () => reject(new Error(`Failed to save token: ${putRequest.error?.message}`));
+      };
+      getRequest.onerror = () => reject(new Error(`Failed to check existing token: ${getRequest.error?.message}`));
+    });
+  }
+  async getToken(provider, email) {
+    const db = await this.init();
+    const accountId = this.generateAccountId(provider, email);
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], "readonly");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.get(accountId);
+      request.onsuccess = () => {
+        const entry = request.result;
+        resolve(entry?.tokenData);
+      };
+      request.onerror = () => reject(new Error(`Failed to get token: ${request.error?.message}`));
+    });
+  }
+  async getTokensByProvider(provider) {
+    const db = await this.init();
+    const tokens = new Map;
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], "readonly");
+      const store = transaction.objectStore(STORE_NAME);
+      const index = store.index("provider");
+      const request = index.getAll(provider);
+      request.onsuccess = () => {
+        const entries = request.result;
+        for (const entry of entries) {
+          tokens.set(entry.email, entry.tokenData);
+        }
+        resolve(tokens);
+      };
+      request.onerror = () => reject(new Error(`Failed to get tokens: ${request.error?.message}`));
+    });
+  }
+  async listAccounts(provider) {
+    const db = await this.init();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], "readonly");
+      const store = transaction.objectStore(STORE_NAME);
+      const index = store.index("provider");
+      const request = index.getAll(provider);
+      request.onsuccess = () => {
+        const entries = request.result;
+        const accounts = entries.map((entry) => ({
+          email: entry.email,
+          accountId: entry.accountId,
+          expiresAt: entry.tokenData.expiresAt,
+          scopes: entry.tokenData.scopes,
+          createdAt: entry.createdAt
+        }));
+        resolve(accounts);
+      };
+      request.onerror = () => reject(new Error(`Failed to list accounts: ${request.error?.message}`));
+    });
+  }
+  async deleteToken(provider, email) {
+    const db = await this.init();
+    const accountId = this.generateAccountId(provider, email);
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.delete(accountId);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(new Error(`Failed to delete token: ${request.error?.message}`));
+    });
+  }
+  async deleteTokensByProvider(provider) {
+    const db = await this.init();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      const index = store.index("provider");
+      const request = index.getAll(provider);
+      request.onsuccess = () => {
+        const entries = request.result;
+        const deletePromises = entries.map((entry) => {
+          return new Promise((resolveDelete, rejectDelete) => {
+            const deleteRequest = store.delete(entry.accountId);
+            deleteRequest.onsuccess = () => resolveDelete();
+            deleteRequest.onerror = () => rejectDelete(deleteRequest.error);
+          });
+        });
+        Promise.all(deletePromises).then(() => resolve()).catch((error) => reject(error));
+      };
+      request.onerror = () => reject(new Error(`Failed to delete tokens: ${request.error?.message}`));
+    });
+  }
+  async clearAll() {
+    const db = await this.init();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.clear();
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(new Error(`Failed to clear tokens: ${request.error?.message}`));
+    });
+  }
+}
+var DB_NAME = "integrate_oauth_tokens", DB_VERSION = 1, STORE_NAME = "tokens";
+
+// src/oauth/email-fetcher.ts
+async function fetchUserEmail(provider, tokenData) {
+  try {
+    switch (provider.toLowerCase()) {
+      case "github":
+        return await fetchGitHubEmail(tokenData.accessToken);
+      case "gmail":
+      case "google":
+        return await fetchGoogleEmail(tokenData.accessToken);
+      case "notion":
+        return await fetchNotionEmail(tokenData.accessToken);
+      default:
+        return tokenData.email;
+    }
+  } catch (error) {
+    console.error(`Failed to fetch email for ${provider}:`, error);
+    return;
+  }
+}
+async function fetchGitHubEmail(accessToken) {
+  try {
+    const userResponse = await fetch("https://api.github.com/user", {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/vnd.github.v3+json"
+      }
+    });
+    if (!userResponse.ok) {
+      return;
+    }
+    const user = await userResponse.json();
+    if (user.email) {
+      return user.email;
+    }
+    const emailsResponse = await fetch("https://api.github.com/user/emails", {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/vnd.github.v3+json"
+      }
+    });
+    if (!emailsResponse.ok) {
+      return;
+    }
+    const emails = await emailsResponse.json();
+    const primaryEmail = emails.find((e) => e.primary && e.verified);
+    if (primaryEmail) {
+      return primaryEmail.email;
+    }
+    const verifiedEmail = emails.find((e) => e.verified);
+    if (verifiedEmail) {
+      return verifiedEmail.email;
+    }
+    if (emails.length > 0 && emails[0]?.email) {
+      return emails[0].email;
+    }
+    return;
+  } catch (error) {
+    console.error("Failed to fetch GitHub email:", error);
+    return;
+  }
+}
+async function fetchGoogleEmail(accessToken) {
+  try {
+    const response = await fetch("https://www.googleapis.com/oauth2/v2/userinfo", {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+    if (!response.ok) {
+      return;
+    }
+    const user = await response.json();
+    return user.email;
+  } catch (error) {
+    console.error("Failed to fetch Google email:", error);
+    return;
+  }
+}
+async function fetchNotionEmail(accessToken) {
+  try {
+    const response = await fetch("https://api.notion.com/v1/users/me", {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Notion-Version": "2022-06-28"
+      }
+    });
+    if (!response.ok) {
+      return;
+    }
+    const user = await response.json();
+    return user.person?.email;
+  } catch (error) {
+    console.error("Failed to fetch Notion email:", error);
+    return;
+  }
+}
+
 // src/oauth/manager.ts
 class OAuthManager {
   pendingAuths = new Map;
@@ -638,7 +909,8 @@ class OAuthManager {
   getTokenCallback;
   setTokenCallback;
   removeTokenCallback;
-  skipLocalStorage;
+  indexedDBStorage;
+  skipLocalStorage = false;
   constructor(oauthApiBase, flowConfig, apiBaseUrl, tokenCallbacks) {
     this.oauthApiBase = oauthApiBase;
     this.apiBaseUrl = apiBaseUrl;
@@ -651,7 +923,7 @@ class OAuthManager {
     this.getTokenCallback = tokenCallbacks?.getProviderToken;
     this.setTokenCallback = tokenCallbacks?.setProviderToken;
     this.removeTokenCallback = tokenCallbacks?.removeProviderToken;
-    this.skipLocalStorage = !!(tokenCallbacks?.getProviderToken || tokenCallbacks?.setProviderToken);
+    this.indexedDBStorage = new IndexedDBStorage;
     this.cleanupExpiredPendingAuths();
   }
   async initiateFlow(provider, config, returnUrl) {
@@ -709,8 +981,12 @@ class OAuthManager {
       expiresAt: tokenData.expiresAt,
       scopes: tokenData.scopes
     };
+    const email = await fetchUserEmail(provider, tokenDataToStore);
+    if (email) {
+      tokenDataToStore.email = email;
+    }
     this.providerTokens.set(provider, tokenDataToStore);
-    await this.saveProviderToken(provider, tokenDataToStore);
+    await this.saveProviderToken(provider, tokenDataToStore, email);
     this.pendingAuths.delete(state);
     this.removePendingAuthFromStorage(state);
     return { ...tokenDataToStore, provider };
@@ -746,8 +1022,12 @@ class OAuthManager {
         expiresAt: response.expiresAt,
         scopes: response.scopes
       };
+      const email = await fetchUserEmail(pendingAuth.provider, tokenData);
+      if (email) {
+        tokenData.email = email;
+      }
       this.providerTokens.set(pendingAuth.provider, tokenData);
-      await this.saveProviderToken(pendingAuth.provider, tokenData);
+      await this.saveProviderToken(pendingAuth.provider, tokenData, email);
       this.pendingAuths.delete(state);
       this.removePendingAuthFromStorage(state);
       return { ...tokenData, provider: pendingAuth.provider };
@@ -757,8 +1037,8 @@ class OAuthManager {
       throw error;
     }
   }
-  async checkAuthStatus(provider) {
-    const tokenData = await this.getProviderToken(provider);
+  async checkAuthStatus(provider, email) {
+    const tokenData = await this.getProviderToken(provider, email);
     if (!tokenData) {
       return {
         authorized: false,
@@ -772,30 +1052,83 @@ class OAuthManager {
       expiresAt: tokenData.expiresAt
     };
   }
+  async disconnectAccount(provider, email, context) {
+    if (this.removeTokenCallback) {
+      try {
+        await this.removeTokenCallback(provider, email, context);
+      } catch (error) {
+        console.error(`Failed to delete token for ${provider} (${email}) from database:`, error);
+      }
+    } else if (this.setTokenCallback) {
+      try {
+        await this.setTokenCallback(provider, null, email, context);
+      } catch (error) {
+        console.error(`Failed to delete token for ${provider} (${email}) from database:`, error);
+      }
+    }
+    if (!this.setTokenCallback && !this.removeTokenCallback) {
+      try {
+        await this.indexedDBStorage.deleteToken(provider, email);
+      } catch (error) {
+        console.error(`Failed to delete token from IndexedDB for ${provider} (${email}):`, error);
+      }
+    }
+    this.providerTokens.delete(provider);
+  }
   async disconnectProvider(provider, context) {
     if (this.removeTokenCallback) {
       try {
-        await this.removeTokenCallback(provider, context);
+        await this.removeTokenCallback(provider, undefined, context);
       } catch (error) {
-        console.error(`Failed to delete token for ${provider} from database via removeProviderToken:`, error);
+        console.error(`Failed to delete tokens for ${provider} from database:`, error);
       }
     } else if (this.setTokenCallback) {
       try {
-        const tokenData = await this.getProviderToken(provider, context);
-        if (tokenData) {
-          await this.setTokenCallback(provider, null, context);
-        }
+        await this.setTokenCallback(provider, null, undefined, context);
+      } catch (error) {
+        console.error(`Failed to delete tokens for ${provider} from database:`, error);
+      }
+    }
+    if (!this.setTokenCallback && !this.removeTokenCallback) {
+      try {
+        await this.indexedDBStorage.deleteTokensByProvider(provider);
       } catch (error) {
-        console.error(`Failed to delete token for ${provider} from database via setProviderToken:`, error);
+        if (typeof window !== "undefined" && window.localStorage) {
+          try {
+            const key = `integrate_token_${provider}`;
+            window.localStorage.removeItem(key);
+          } catch (localStorageError) {}
+        }
+      }
+    }
+    if (!this.setTokenCallback && !this.removeTokenCallback) {
+      if (typeof window !== "undefined" && window.localStorage) {
+        try {
+          const key = `integrate_token_${provider}`;
+          window.localStorage.removeItem(key);
+        } catch (localStorageError) {}
       }
     }
     this.providerTokens.delete(provider);
-    this.clearProviderToken(provider);
   }
-  async getProviderToken(provider, context) {
+  async listAccounts(provider) {
+    if (this.getTokenCallback) {
+      return [];
+    }
+    if (!this.getTokenCallback) {
+      try {
+        return await this.indexedDBStorage.listAccounts(provider);
+      } catch (error) {
+        console.error(`Failed to list accounts for ${provider}:`, error);
+        return [];
+      }
+    }
+    return [];
+  }
+  async getProviderToken(provider, email, context) {
     if (this.getTokenCallback) {
       try {
-        const tokenData = await this.getTokenCallback(provider, context);
+        const tokenData = await this.getTokenCallback(provider, email, context);
         if (tokenData) {
           this.providerTokens.set(provider, tokenData);
         }
@@ -805,6 +1138,17 @@ class OAuthManager {
         return;
       }
     }
+    if (email && !this.getTokenCallback) {
+      try {
+        const tokenData = await this.indexedDBStorage.getToken(provider, email);
+        if (tokenData) {
+          this.providerTokens.set(provider, tokenData);
+        }
+        return tokenData;
+      } catch (error) {
+        console.error(`Failed to get token from IndexedDB for ${provider}:`, error);
+      }
+    }
     return this.providerTokens.get(provider);
   }
   getAllProviderTokens() {
@@ -813,35 +1157,45 @@ class OAuthManager {
   getProviderTokenFromCache(provider) {
     return this.providerTokens.get(provider);
   }
-  async setProviderToken(provider, tokenData, context) {
+  async setProviderToken(provider, tokenData, email, context) {
+    const tokenEmail = email || tokenData?.email;
     if (tokenData === null) {
-      this.providerTokens.delete(provider);
+      if (tokenEmail) {
+        this.providerTokens.delete(provider);
+      } else {
+        this.providerTokens.delete(provider);
+      }
     } else {
       this.providerTokens.set(provider, tokenData);
     }
-    await this.saveProviderToken(provider, tokenData, context);
+    await this.saveProviderToken(provider, tokenData, tokenEmail, context);
   }
   clearProviderToken(provider) {
     this.providerTokens.delete(provider);
-    if (!this.skipLocalStorage && typeof window !== "undefined" && window.localStorage) {
-      try {
-        window.localStorage.removeItem(`integrate_token_${provider}`);
-      } catch (error) {
-        console.error(`Failed to clear token for ${provider} from localStorage:`, error);
-      }
+    if (!this.setTokenCallback && !this.removeTokenCallback && !this.skipLocalStorage) {
+      this.indexedDBStorage.deleteTokensByProvider(provider).catch((error) => {
+        console.error(`Failed to clear tokens for ${provider} from IndexedDB:`, error);
+      });
     }
   }
   clearAllProviderTokens() {
-    const providers = Array.from(this.providerTokens.keys());
     this.providerTokens.clear();
-    if (!this.skipLocalStorage && typeof window !== "undefined" && window.localStorage) {
-      for (const provider of providers) {
+    if (!this.setTokenCallback && !this.removeTokenCallback && !this.skipLocalStorage) {
+      if (typeof window !== "undefined" && window.localStorage) {
         try {
-          window.localStorage.removeItem(`integrate_token_${provider}`);
-        } catch (error) {
-          console.error(`Failed to clear token for ${provider} from localStorage:`, error);
-        }
+          const keysToRemove = [];
+          for (let i = 0;i < window.localStorage.length; i++) {
+            const key = window.localStorage.key(i);
+            if (key && key.startsWith("integrate_token_")) {
+              keysToRemove.push(key);
+            }
+          }
+          keysToRemove.forEach((key) => window.localStorage.removeItem(key));
+        } catch (localStorageError) {}
       }
+      this.indexedDBStorage.clearAll().catch((error) => {
+        console.error("Failed to clear all tokens from IndexedDB:", error);
+      });
     }
   }
   clearAllPendingAuths() {
@@ -862,66 +1216,125 @@ class OAuthManager {
       }
     }
   }
-  async saveProviderToken(provider, tokenData, context) {
+  async saveProviderToken(provider, tokenData, email, context) {
     if (this.setTokenCallback) {
       try {
-        await this.setTokenCallback(provider, tokenData, context);
+        await this.setTokenCallback(provider, tokenData, email, context);
       } catch (error) {
         console.error(`Failed to ${tokenData === null ? "delete" : "save"} token for ${provider} via callback:`, error);
         throw error;
       }
       return;
     }
-    if (tokenData === null) {
-      this.clearProviderToken(provider);
+    if (this.skipLocalStorage) {
       return;
     }
-    if (this.skipLocalStorage) {
+    if (tokenData === null) {
+      if (email) {
+        if (!this.setTokenCallback && !this.removeTokenCallback) {
+          await this.indexedDBStorage.deleteToken(provider, email).catch(() => {
+            if (typeof window !== "undefined" && window.localStorage) {
+              try {
+                const key = `integrate_token_${provider}`;
+                window.localStorage.removeItem(key);
+              } catch (localStorageError) {}
+            }
+          });
+        }
+      } else {
+        this.clearProviderToken(provider);
+        if (typeof window !== "undefined" && window.localStorage) {
+          try {
+            const key = `integrate_token_${provider}`;
+            window.localStorage.removeItem(key);
+          } catch (localStorageError) {}
+        }
+      }
       return;
     }
-    if (typeof window !== "undefined" && window.localStorage) {
+    const tokenEmail = email || tokenData.email;
+    if (tokenEmail) {
       try {
-        const key = `integrate_token_${provider}`;
-        window.localStorage.setItem(key, JSON.stringify(tokenData));
+        await this.indexedDBStorage.saveToken(provider, tokenEmail, tokenData);
       } catch (error) {
-        console.error(`Failed to save token for ${provider} to localStorage:`, error);
+        if (typeof window !== "undefined" && window.localStorage) {
+          try {
+            const key = `integrate_token_${provider}`;
+            window.localStorage.setItem(key, JSON.stringify(tokenData));
+          } catch (localStorageError) {
+            console.error(`Failed to save token for ${provider} to localStorage:`, localStorageError);
+          }
+        } else {
+          console.error(`Failed to save token for ${provider} to IndexedDB:`, error);
+        }
+      }
+    } else {
+      if (typeof window !== "undefined" && window.localStorage) {
+        try {
+          const key = `integrate_token_${provider}`;
+          window.localStorage.setItem(key, JSON.stringify(tokenData));
+        } catch (localStorageError) {
+          console.error(`Failed to save token for ${provider} to localStorage:`, localStorageError);
+        }
       }
     }
   }
-  async loadProviderToken(provider) {
+  async loadProviderToken(provider, email, context) {
     if (this.getTokenCallback) {
       try {
-        return await this.getTokenCallback(provider);
+        return await this.getTokenCallback(provider, email, context);
       } catch (error) {
         console.error(`Failed to load token for ${provider} via callback:`, error);
         return;
       }
     }
     if (this.skipLocalStorage) {
-      return;
+      return this.providerTokens.get(provider);
     }
-    if (typeof window !== "undefined" && window.localStorage) {
+    if (email) {
       try {
-        const key = `integrate_token_${provider}`;
-        const stored = window.localStorage.getItem(key);
-        if (stored) {
-          return JSON.parse(stored);
+        return await this.indexedDBStorage.getToken(provider, email);
+      } catch (error) {
+        if (typeof window !== "undefined" && window.localStorage) {
+          try {
+            const key = `integrate_token_${provider}`;
+            const stored = window.localStorage.getItem(key);
+            if (stored) {
+              return JSON.parse(stored);
+            }
+          } catch (localStorageError) {}
+        }
+        return;
+      }
+    } else {
+      try {
+        const tokens = await this.indexedDBStorage.getTokensByProvider(provider);
+        if (tokens.size > 0) {
+          return tokens.values().next().value;
         }
       } catch (error) {
-        console.error(`Failed to load token for ${provider} from localStorage:`, error);
+        if (typeof window !== "undefined" && window.localStorage) {
+          try {
+            const key = `integrate_token_${provider}`;
+            const stored = window.localStorage.getItem(key);
+            if (stored) {
+              return JSON.parse(stored);
+            }
+          } catch (localStorageError) {}
+        }
       }
     }
     return;
   }
   async loadAllProviderTokens(providers) {
     for (const provider of providers) {
-      const tokenData = await this.loadProviderToken(provider);
+      const tokenData = await this.loadProviderToken(provider, undefined, undefined);
       if (tokenData) {
         this.providerTokens.set(provider, tokenData);
       }
     }
   }
-  loadProviderTokenSync(provider) {
+  loadAllProviderTokensSync(providers) {
     if (this.getTokenCallback) {
       return;
     }
@@ -929,28 +1342,18 @@ class OAuthManager {
       return;
     }
     if (typeof window !== "undefined" && window.localStorage) {
-      try {
-        const key = `integrate_token_${provider}`;
-        const stored = window.localStorage.getItem(key);
-        if (stored) {
-          return JSON.parse(stored);
-        }
-      } catch (error) {
-        console.error(`Failed to load token for ${provider} from localStorage:`, error);
-      }
-    }
-    return;
-  }
-  loadAllProviderTokensSync(providers) {
-    if (this.getTokenCallback) {
-      return;
-    }
-    for (const provider of providers) {
-      const tokenData = this.loadProviderTokenSync(provider);
-      if (tokenData) {
-        this.providerTokens.set(provider, tokenData);
+      for (const provider of providers) {
+        try {
+          const key = `integrate_token_${provider}`;
+          const stored = window.localStorage.getItem(key);
+          if (stored) {
+            const tokenData = JSON.parse(stored);
+            this.providerTokens.set(provider, tokenData);
+          }
+        } catch {}
       }
     }
+    this.loadAllProviderTokens(providers).catch(() => {});
   }
   savePendingAuthToStorage(state, pendingAuth) {
     if (typeof window !== "undefined" && window.localStorage) {
@@ -1033,7 +1436,7 @@ class OAuthManager {
       })
     });
     if (response.headers.get("X-Integrate-Use-Database") === "true") {
-      this.skipLocalStorage = true;
+      this.setSkipLocalStorage(true);
     }
     if (!response.ok) {
       const error = await response.text();
@@ -1063,7 +1466,7 @@ class OAuthManager {
       })
     });
     if (response.headers.get("X-Integrate-Use-Database") === "true") {
-      this.skipLocalStorage = true;
+      this.setSkipLocalStorage(true);
     }
     if (!response.ok) {
       const error = await response.text();
@@ -1332,7 +1735,7 @@ class MCPClientBase {
     const hasApiKey = !!transportHeaders["X-API-KEY"];
     if (hasApiKey) {
       if (provider) {
-        const tokenData = await this.oauthManager.getProviderToken(provider, options?.context);
+        const tokenData = await this.oauthManager.getProviderToken(provider, undefined, options?.context);
         if (tokenData && this.transport.setHeader) {
           const previousAuthHeader = transportHeaders["Authorization"];
           try {
@@ -1362,7 +1765,7 @@ class MCPClientBase {
       "Content-Type": "application/json"
     };
     if (provider) {
-      const tokenData = await this.oauthManager.getProviderToken(provider, options?.context);
+      const tokenData = await this.oauthManager.getProviderToken(provider, undefined, options?.context);
       if (tokenData) {
         headers["Authorization"] = `Bearer ${tokenData.accessToken}`;
       }
@@ -1506,6 +1909,29 @@ class MCPClientBase {
       throw error;
     }
   }
+  async disconnectAccount(provider, email, context) {
+    const integration = this.integrations.find((p) => p.oauth?.provider === provider);
+    if (!integration?.oauth) {
+      throw new Error(`No OAuth configuration found for provider: ${provider}`);
+    }
+    try {
+      await this.oauthManager.disconnectAccount(provider, email, context);
+      const accounts = await this.oauthManager.listAccounts(provider);
+      if (accounts.length === 0) {
+        this.authState.set(provider, { authenticated: false });
+      }
+      this.eventEmitter.emit("auth:disconnect", { provider });
+    } catch (error) {
+      this.eventEmitter.emit("auth:error", {
+        provider,
+        error
+      });
+      throw error;
+    }
+  }
+  async listAccounts(provider) {
+    return await this.oauthManager.listAccounts(provider);
+  }
   async logout() {
     this.clearSessionToken();
     this.oauthManager.clearAllPendingAuths();
@@ -1538,13 +1964,13 @@ class MCPClientBase {
   isProviderAuthenticated(provider) {
     return this.authState.get(provider)?.authenticated ?? false;
   }
-  async isAuthorized(provider, context) {
+  async isAuthorized(provider, email, context) {
     if (this.oauthCallbackPromise) {
       await this.oauthCallbackPromise;
       this.oauthCallbackPromise = null;
     }
     try {
-      const tokenData = await this.oauthManager.getProviderToken(provider, context);
+      const tokenData = await this.oauthManager.getProviderToken(provider, email, context);
       const isAuthenticated = !!tokenData;
       const currentState = this.authState.get(provider);
       if (currentState) {
@@ -1582,8 +2008,8 @@ class MCPClientBase {
     }
     return authorized;
   }
-  async getAuthorizationStatus(provider) {
-    return await this.oauthManager.checkAuthStatus(provider);
+  async getAuthorizationStatus(provider, email) {
+    return await this.oauthManager.checkAuthStatus(provider, email);
   }
   async authorize(provider, options) {
     const integration = this.integrations.find((p) => p.oauth?.provider === provider);
@@ -1641,11 +2067,11 @@ class MCPClientBase {
       throw error;
     }
   }
-  async getProviderToken(provider, context) {
-    return await this.oauthManager.getProviderToken(provider, context);
+  async getProviderToken(provider, email, context) {
+    return await this.oauthManager.getProviderToken(provider, email, context);
   }
-  async setProviderToken(provider, tokenData, context) {
-    await this.oauthManager.setProviderToken(provider, tokenData, context);
+  async setProviderToken(provider, tokenData, email, context) {
+    await this.oauthManager.setProviderToken(provider, tokenData, email, context);
     if (tokenData === null) {
       this.authState.set(provider, { authenticated: false });
     } else {
@@ -7565,7 +7991,7 @@ class OAuthHandler {
           expiresAt: result.expiresAt,
           scopes: result.scopes
         };
-        await this.config.setProviderToken(callbackRequest.provider, tokenData, context);
+        await this.config.setProviderToken(callbackRequest.provider, tokenData, undefined, context);
       } catch (error) {}
     }
     if (webRequest) {
@@ -7611,7 +8037,7 @@ class OAuthHandler {
         }
         if (context) {
           try {
-            await this.config.removeProviderToken(request.provider, context);
+            await this.config.removeProviderToken(request.provider, undefined, context);
           } catch (error) {
             console.error(`Failed to delete token for ${request.provider} from database via removeProviderToken:`, error);
           }