integrate-sdk 0.9.13-dev.0 → 0.9.14-dev.0

package/dist/adapters/solid-start.js

@@ -1,21 +1,4 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -26,7 +9,6 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // session-detector.ts
 var exports_session_detector = {};
@@ -169,6 +151,3639 @@ async function detectSessionContext(request) {
   }
   return;
 }
+
+// context-cookie.ts
+var exports_context_cookie = {};
+__export(exports_context_cookie, {
+  readContextCookie: () => readContextCookie,
+  getSetCookieHeader: () => getSetCookieHeader,
+  getContextCookieFromRequest: () => getContextCookieFromRequest,
+  getClearCookieHeader: () => getClearCookieHeader,
+  createContextCookie: () => createContextCookie,
+  CONTEXT_COOKIE_NAME: () => CONTEXT_COOKIE_NAME,
+  CONTEXT_COOKIE_MAX_AGE: () => CONTEXT_COOKIE_MAX_AGE
+});
+async function deriveKey(secret) {
+  const encoder = new TextEncoder;
+  const secretData = encoder.encode(secret);
+  const keyMaterial = await crypto.subtle.importKey("raw", secretData, { name: "PBKDF2" }, false, ["deriveBits", "deriveKey"]);
+  const salt = encoder.encode("integrate-oauth-context-v1");
+  return await crypto.subtle.deriveKey({
+    name: "PBKDF2",
+    salt,
+    iterations: 1e5,
+    hash: "SHA-256"
+  }, keyMaterial, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+}
+async function encryptPayload(payload, secret) {
+  const key = await deriveKey(secret);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const encoder = new TextEncoder;
+  const data = encoder.encode(JSON.stringify(payload));
+  const encrypted = await crypto.subtle.encrypt({
+    name: "AES-GCM",
+    iv
+  }, key, data);
+  const combined = new Uint8Array(iv.length + encrypted.byteLength);
+  combined.set(iv, 0);
+  combined.set(new Uint8Array(encrypted), iv.length);
+  return base64UrlEncode(combined);
+}
+async function decryptPayload(cookieValue, secret) {
+  try {
+    const combined = base64UrlDecode(cookieValue);
+    const iv = combined.slice(0, 12);
+    const encrypted = combined.slice(12);
+    const key = await deriveKey(secret);
+    const decrypted = await crypto.subtle.decrypt({
+      name: "AES-GCM",
+      iv
+    }, key, encrypted);
+    const decoder = new TextDecoder;
+    const json = decoder.decode(decrypted);
+    const payload = JSON.parse(json);
+    const age = Date.now() - payload.timestamp;
+    if (age > CONTEXT_COOKIE_MAX_AGE * 1000) {
+      return;
+    }
+    return payload;
+  } catch (error) {
+    return;
+  }
+}
+function base64UrlEncode(data) {
+  const base64 = btoa(String.fromCharCode(...data));
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64UrlDecode(str) {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = base64.length % 4;
+  if (padding) {
+    base64 += "=".repeat(4 - padding);
+  }
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function createContextCookie(context, provider, secret) {
+  const payload = {
+    context,
+    provider,
+    timestamp: Date.now()
+  };
+  return await encryptPayload(payload, secret);
+}
+async function readContextCookie(cookieValue, secret) {
+  const payload = await decryptPayload(cookieValue, secret);
+  if (!payload) {
+    return;
+  }
+  return {
+    context: payload.context,
+    provider: payload.provider
+  };
+}
+function getSetCookieHeader(cookieValue, maxAge = CONTEXT_COOKIE_MAX_AGE) {
+  const attributes = [
+    `${CONTEXT_COOKIE_NAME}=${cookieValue}`,
+    `Max-Age=${maxAge}`,
+    "HttpOnly",
+    "Secure",
+    "SameSite=Lax",
+    "Path=/"
+  ];
+  return attributes.join("; ");
+}
+function getClearCookieHeader() {
+  const attributes = [
+    `${CONTEXT_COOKIE_NAME}=`,
+    "Max-Age=0",
+    "HttpOnly",
+    "Secure",
+    "SameSite=Lax",
+    "Path=/"
+  ];
+  return attributes.join("; ");
+}
+function getContextCookieFromRequest(request) {
+  const cookieHeader = request.headers.get("cookie");
+  if (!cookieHeader) {
+    return;
+  }
+  const cookies = cookieHeader.split(";");
+  for (const cookie of cookies) {
+    const [name, ...valueParts] = cookie.split("=");
+    if (name && name.trim() === CONTEXT_COOKIE_NAME) {
+      return valueParts.join("=").trim();
+    }
+  }
+  return;
+}
+var CONTEXT_COOKIE_NAME = "__integrate_oauth_ctx", CONTEXT_COOKIE_MAX_AGE = 300;
+
+// ../utils/logger.ts
+function shouldLog(level, context) {
+  return logLevelHierarchy[level] <= logLevelHierarchy[contextLogLevels[context]];
+}
+function createLogger(namespace, context = "client") {
+  const prefix = `[${namespace}]`;
+  return {
+    debug: (...args) => {
+      if (shouldLog("debug", context)) {
+        console.log(prefix, ...args);
+      }
+    },
+    info: (...args) => {
+      if (shouldLog("info", context)) {
+        console.log(prefix, ...args);
+      }
+    },
+    warn: (...args) => {
+      if (shouldLog("warn", context)) {
+        console.warn(prefix, ...args);
+      }
+    },
+    error: (...args) => {
+      if (shouldLog("error", context)) {
+        console.error(prefix, ...args);
+      }
+    }
+  };
+}
+var contextLogLevels, logLevelHierarchy;
+var init_logger = __esm(() => {
+  contextLogLevels = {
+    client: "error",
+    server: "error"
+  };
+  logLevelHierarchy = {
+    none: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4
+  };
+});
+
+// ../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) {
+    logger.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) {
+    logger.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) {
+    logger.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) {
+    logger.error("Failed to fetch Notion email:", error);
+    return;
+  }
+}
+var logger;
+var init_email_fetcher = __esm(() => {
+  init_logger();
+  logger = createLogger("EmailFetcher");
+});
+
+// base-handler.ts
+class OAuthHandler {
+  config;
+  serverUrl;
+  apiKey;
+  constructor(config) {
+    this.config = config;
+    if (!config || !config.providers) {
+      throw new Error("OAuthHandler requires a valid config with providers");
+    }
+    this.serverUrl = config.serverUrl || MCP_SERVER_URL;
+    this.apiKey = config.apiKey;
+  }
+  handleIntegrations() {
+    const integrations = this.config.integrations || [];
+    return {
+      integrations: integrations.map((integration) => ({
+        id: integration.id,
+        name: integration.name || integration.id,
+        logoUrl: integration.logoUrl,
+        tools: integration.tools,
+        hasOAuth: !!integration.oauth,
+        scopes: integration.oauth?.scopes,
+        optionalScopes: integration.oauth?.optionalScopes,
+        provider: integration.oauth?.provider
+      }))
+    };
+  }
+  getHeaders(additionalHeaders) {
+    const headers = {
+      ...additionalHeaders
+    };
+    if (this.apiKey) {
+      headers["X-API-KEY"] = this.apiKey;
+    }
+    return headers;
+  }
+  hasDatabaseCallbacks() {
+    return !!this.config.setProviderToken;
+  }
+  async handleAuthorize(request) {
+    let webRequest;
+    let authorizeRequest;
+    if (request instanceof Request) {
+      webRequest = request;
+      authorizeRequest = await request.json();
+    } else if (typeof request === "object" && "json" in request && typeof request.json === "function") {
+      authorizeRequest = await request.json();
+    } else {
+      authorizeRequest = request;
+    }
+    const providerConfig = this.config.providers[authorizeRequest.provider];
+    if (!providerConfig) {
+      throw new Error(`Provider ${authorizeRequest.provider} not configured. Add OAuth credentials to your API route configuration.`);
+    }
+    if (!providerConfig.clientId || !providerConfig.clientSecret) {
+      throw new Error(`Missing OAuth credentials for ${authorizeRequest.provider}. Check your environment variables.`);
+    }
+    const url = new URL("/oauth/authorize", this.serverUrl);
+    url.searchParams.set("provider", authorizeRequest.provider);
+    url.searchParams.set("client_id", providerConfig.clientId);
+    url.searchParams.set("client_secret", providerConfig.clientSecret);
+    const scopes = authorizeRequest.scopes || providerConfig.scopes || [];
+    if (scopes.length > 0) {
+      url.searchParams.set("scope", scopes.join(","));
+    }
+    const optionalScopes = authorizeRequest.optionalScopes || providerConfig.optionalScopes || [];
+    if (optionalScopes.length > 0) {
+      url.searchParams.set("optional_scope", optionalScopes.join(","));
+    }
+    url.searchParams.set("state", authorizeRequest.state);
+    url.searchParams.set("code_challenge", authorizeRequest.codeChallenge);
+    url.searchParams.set("code_challenge_method", authorizeRequest.codeChallengeMethod);
+    const redirectUri = providerConfig.redirectUri;
+    if (redirectUri) {
+      url.searchParams.set("redirect_uri", redirectUri);
+    }
+    const OAUTH_FIELDS = new Set([
+      "clientId",
+      "clientSecret",
+      "scopes",
+      "optionalScopes",
+      "redirectUri",
+      "client_id",
+      "client_secret",
+      "scope",
+      "optional_scope",
+      "redirect_uri",
+      "provider"
+    ]);
+    if (providerConfig.config) {
+      for (const [key, value] of Object.entries(providerConfig.config)) {
+        if (value !== undefined && value !== null && !OAUTH_FIELDS.has(key)) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to generate authorization URL: ${error}`);
+    }
+    const data = await response.json();
+    const result = data;
+    if (!result.authorizationUrl) {
+      throw new Error("MCP server failed to return authorization URL");
+    }
+    if (authorizeRequest.codeVerifier) {
+      try {
+        const serverImport = new Function("s", "return import(s)");
+        const { storeCodeVerifier } = await serverImport("../server.js");
+        storeCodeVerifier(authorizeRequest.state, authorizeRequest.codeVerifier, authorizeRequest.provider, authorizeRequest.frontendOrigin);
+      } catch (error) {}
+    } else {}
+    if (webRequest) {
+      try {
+        const { detectSessionContext: detectSessionContext2 } = await Promise.resolve().then(() => exports_session_detector);
+        const { createContextCookie: createContextCookie2, getSetCookieHeader: getSetCookieHeader2 } = await Promise.resolve().then(() => exports_context_cookie);
+        let context;
+        if (this.config.getSessionContext) {
+          context = await this.config.getSessionContext(webRequest);
+        }
+        if (!context || !context.userId) {
+          context = await detectSessionContext2(webRequest);
+        }
+        if (context && context.userId) {
+          const secret = this.apiKey || providerConfig.clientSecret;
+          const cookieValue = await createContextCookie2(context, authorizeRequest.provider, secret);
+          result.setCookie = getSetCookieHeader2(cookieValue);
+        }
+      } catch (error) {}
+    }
+    return result;
+  }
+  async handleCallback(request) {
+    let webRequest;
+    let callbackRequest;
+    if (request instanceof Request) {
+      webRequest = request;
+      callbackRequest = await request.json();
+    } else if (typeof request === "object" && "json" in request && typeof request.json === "function") {
+      callbackRequest = await request.json();
+    } else {
+      callbackRequest = request;
+    }
+    const providerConfig = this.config.providers[callbackRequest.provider];
+    if (!providerConfig) {
+      throw new Error(`Provider ${callbackRequest.provider} not configured. Add OAuth credentials to your API route configuration.`);
+    }
+    if (!providerConfig.clientId || !providerConfig.clientSecret) {
+      throw new Error(`Missing OAuth credentials for ${callbackRequest.provider}. Check your environment variables.`);
+    }
+    let context;
+    if (webRequest) {
+      try {
+        const { getContextCookieFromRequest: getContextCookieFromRequest2, readContextCookie: readContextCookie2 } = await Promise.resolve().then(() => exports_context_cookie);
+        const cookieValue = getContextCookieFromRequest2(webRequest);
+        if (cookieValue) {
+          const secret = this.apiKey || providerConfig.clientSecret;
+          const contextData = await readContextCookie2(cookieValue, secret);
+          if (contextData && contextData.provider === callbackRequest.provider) {
+            context = contextData.context;
+          }
+        }
+      } catch (error) {}
+    }
+    const url = new URL("/oauth/callback", this.serverUrl);
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: this.getHeaders({
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify({
+        provider: callbackRequest.provider,
+        code: callbackRequest.code,
+        code_verifier: callbackRequest.codeVerifier,
+        state: callbackRequest.state,
+        client_id: providerConfig.clientId,
+        client_secret: providerConfig.clientSecret,
+        redirect_uri: providerConfig.redirectUri
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to exchange authorization code: ${error}`);
+    }
+    const data = await response.json();
+    const result = data;
+    if (this.config.setProviderToken) {
+      try {
+        const tokenData = {
+          accessToken: result.accessToken,
+          refreshToken: result.refreshToken,
+          tokenType: result.tokenType,
+          expiresIn: result.expiresIn,
+          expiresAt: result.expiresAt,
+          scopes: result.scopes ? result.scopes.flatMap((s) => s.split(" ").filter(Boolean)) : result.scopes
+        };
+        const email = result.email || await fetchUserEmail(callbackRequest.provider, tokenData);
+        if (email) {
+          tokenData.email = email;
+        }
+        await this.config.setProviderToken(callbackRequest.provider, tokenData, email, context);
+      } catch (error) {}
+    }
+    if (webRequest) {
+      const { getClearCookieHeader: getClearCookieHeader2 } = await Promise.resolve().then(() => exports_context_cookie);
+      result.clearCookie = getClearCookieHeader2();
+    }
+    return result;
+  }
+  async handleStatus(provider, accessToken) {
+    const url = new URL("/oauth/status", this.serverUrl);
+    url.searchParams.set("provider", provider);
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: this.getHeaders({
+        Authorization: `Bearer ${accessToken}`
+      })
+    });
+    if (!response.ok) {
+      if (response.status === 401) {
+        return {
+          authorized: false
+        };
+      }
+      const error = await response.text();
+      throw new Error(`MCP server failed to check authorization status: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async handleDisconnect(request, accessToken, webRequest) {
+    if (!accessToken) {
+      throw new Error("No access token provided. Cannot disconnect provider.");
+    }
+    if (webRequest && this.config.removeProviderToken) {
+      try {
+        let context;
+        if (this.config.getSessionContext) {
+          context = await this.config.getSessionContext(webRequest);
+        }
+        if (!context || !context.userId) {
+          const { detectSessionContext: detectSessionContext2 } = await Promise.resolve().then(() => exports_session_detector);
+          context = await detectSessionContext2(webRequest);
+        }
+        if (context) {
+          try {
+            await this.config.removeProviderToken(request.provider, undefined, context);
+          } catch (error) {
+            logger2.error(`Failed to delete token for ${request.provider} from database via removeProviderToken:`, error);
+          }
+        }
+      } catch (error) {
+        logger2.error(`Failed to extract context for disconnect:`, error);
+      }
+    }
+    const url = new URL("/oauth/disconnect", this.serverUrl);
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: this.getHeaders({
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`
+      }),
+      body: JSON.stringify({
+        provider: request.provider
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to disconnect provider: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async handleRefresh(request) {
+    let webRequest;
+    let refreshRequest;
+    if (request instanceof Request) {
+      webRequest = request;
+      refreshRequest = await request.json();
+    } else if (typeof request === "object" && "json" in request && typeof request.json === "function") {
+      refreshRequest = await request.json();
+    } else {
+      refreshRequest = request;
+    }
+    const providerConfig = this.config.providers[refreshRequest.provider];
+    if (!providerConfig) {
+      throw new Error(`Provider ${refreshRequest.provider} not configured. Add OAuth credentials to your API route configuration.`);
+    }
+    let context;
+    if (webRequest) {
+      try {
+        if (this.config.getSessionContext) {
+          context = await this.config.getSessionContext(webRequest);
+        }
+        if (!context || !context.userId) {
+          const { detectSessionContext: detectSessionContext2 } = await Promise.resolve().then(() => exports_session_detector);
+          context = await detectSessionContext2(webRequest);
+        }
+      } catch (error) {}
+    }
+    const body = {
+      provider: refreshRequest.provider,
+      refresh_token: refreshRequest.refreshToken,
+      client_id: providerConfig.clientId
+    };
+    if (providerConfig.clientSecret) {
+      body.client_secret = providerConfig.clientSecret;
+    }
+    if (providerConfig.config?.subdomain) {
+      body.subdomain = providerConfig.config.subdomain;
+    }
+    const url = new URL("/oauth/refresh", this.serverUrl);
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: this.getHeaders({
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      const lowerError = error.toLowerCase();
+      if (lowerError.includes("not supported") || lowerError.includes("unsupported")) {
+        throw new Error(`Token refresh not supported: ${error}`);
+      }
+      throw new Error(`Token refresh failed: ${error}`);
+    }
+    const data = await response.json();
+    const result = data;
+    if (this.config.setProviderToken) {
+      try {
+        const tokenData = {
+          accessToken: result.accessToken,
+          refreshToken: result.refreshToken,
+          tokenType: result.tokenType,
+          expiresIn: result.expiresIn,
+          expiresAt: result.expiresAt,
+          scopes: result.scopes ? result.scopes.flatMap((s) => s.split(" ").filter(Boolean)) : result.scopes
+        };
+        const email = result.email || await fetchUserEmail(refreshRequest.provider, tokenData);
+        if (email) {
+          tokenData.email = email;
+        }
+        await this.config.setProviderToken(refreshRequest.provider, tokenData, email, context);
+      } catch (error) {}
+    }
+    return result;
+  }
+  async handleToolCall(request, authHeader, integrationsHeader) {
+    const url = this.serverUrl;
+    const headers = this.getHeaders({
+      "Content-Type": "application/json"
+    });
+    if (authHeader) {
+      const normalized = authHeader.replace(/^bearer\s+/i, "Bearer ");
+      if (normalized.startsWith("Bearer ")) {
+        headers["Authorization"] = normalized;
+      }
+    }
+    if (integrationsHeader) {
+      headers["X-Integrations"] = integrationsHeader;
+    }
+    const jsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: Date.now() + Math.random(),
+      method: "tools/call",
+      params: {
+        name: request.name,
+        arguments: request.arguments || {}
+      }
+    };
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(jsonRpcRequest)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to execute tool call: ${error}`);
+    }
+    const jsonRpcResponse = await response.json();
+    if (jsonRpcResponse.error) {
+      const error = new Error(jsonRpcResponse.error.message || "Tool call failed");
+      error.code = jsonRpcResponse.error.code;
+      error.data = jsonRpcResponse.error.data;
+      throw error;
+    }
+    return jsonRpcResponse.result;
+  }
+}
+var SERVER_LOG_CONTEXT = "server", logger2, MCP_SERVER_URL = "https://mcp.integrate.dev/api/v1/mcp";
+var init_base_handler = __esm(() => {
+  init_email_fetcher();
+  init_logger();
+  logger2 = createLogger("OAuthHandler", SERVER_LOG_CONTEXT);
+});
+
+// ../oauth/pkce.ts
+var exports_pkce = {};
+__export(exports_pkce, {
+  parseState: () => parseState,
+  generateStateWithReturnUrl: () => generateStateWithReturnUrl,
+  generateState: () => generateState,
+  generateCodeVerifier: () => generateCodeVerifier,
+  generateCodeChallenge: () => generateCodeChallenge
+});
+function generateCodeVerifier() {
+  const array = new Uint8Array(32);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(array);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    globalThis.crypto.getRandomValues(array);
+  } else {
+    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode2(array);
+}
+async function generateCodeChallenge(verifier) {
+  const encoder = new TextEncoder;
+  const data = encoder.encode(verifier);
+  let hashBuffer;
+  if (typeof crypto !== "undefined" && crypto.subtle) {
+    hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto?.subtle) {
+    hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", data);
+  } else {
+    throw new Error("crypto.subtle.digest is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode2(new Uint8Array(hashBuffer));
+}
+function generateState() {
+  const array = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(array);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    globalThis.crypto.getRandomValues(array);
+  } else {
+    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode2(array);
+}
+function generateStateWithReturnUrl(returnUrl) {
+  const csrf = generateState();
+  const stateData = returnUrl ? { csrf, returnUrl } : { csrf };
+  const encoder = new TextEncoder;
+  const jsonBytes = encoder.encode(JSON.stringify(stateData));
+  return base64UrlEncode2(jsonBytes);
+}
+function parseState(state) {
+  try {
+    const decoded = base64UrlDecode2(state);
+    const parsed = JSON.parse(decoded);
+    if (typeof parsed === "string") {
+      return { csrf: parsed };
+    } else if (parsed && typeof parsed === "object") {
+      return {
+        csrf: parsed.csrf || state,
+        returnUrl: parsed.returnUrl
+      };
+    }
+    return { csrf: state };
+  } catch {
+    return { csrf: state };
+  }
+}
+function base64UrlEncode2(array) {
+  let base64 = "";
+  if (typeof Buffer !== "undefined") {
+    base64 = Buffer.from(array).toString("base64");
+  } else {
+    const binary = String.fromCharCode(...array);
+    base64 = btoa(binary);
+  }
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64UrlDecode2(str) {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  while (base64.length % 4 !== 0) {
+    base64 += "=";
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(base64, "base64").toString("utf-8");
+  } else {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0;i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    const decoder = new TextDecoder;
+    return decoder.decode(bytes);
+  }
+}
+
+// ../errors.ts
+var exports_errors = {};
+__export(exports_errors, {
+  parseServerError: () => parseServerError,
+  isTokenExpiredError: () => isTokenExpiredError,
+  isAuthorizationError: () => isAuthorizationError,
+  isAuthError: () => isAuthError,
+  ToolCallError: () => ToolCallError,
+  TokenExpiredError: () => TokenExpiredError,
+  IntegrateSDKError: () => IntegrateSDKError,
+  ConnectionError: () => ConnectionError,
+  AuthorizationError: () => AuthorizationError,
+  AuthenticationError: () => AuthenticationError
+});
+function isAuthError(error) {
+  return error instanceof AuthenticationError;
+}
+function isTokenExpiredError(error) {
+  return error instanceof TokenExpiredError;
+}
+function isAuthorizationError(error) {
+  return error instanceof AuthorizationError;
+}
+function parseServerError(error, context) {
+  if (error && typeof error === "object" && "jsonrpcError" in error) {
+    const jsonrpcError = error.jsonrpcError;
+    if (jsonrpcError && typeof jsonrpcError === "object") {
+      return parseServerError(jsonrpcError, context);
+    }
+  }
+  if (error && typeof error === "object" && "code" in error && "message" in error) {
+    const code = error.code;
+    const message = error.message || "Unknown error";
+    if (code === -32600) {
+      return new IntegrateSDKError(`Invalid request: ${message}`);
+    }
+    if (code === -32601) {
+      return new IntegrateSDKError(`Method not found: ${message}`);
+    }
+    if (code === -32602) {
+      return new IntegrateSDKError(`Invalid params: ${message}`);
+    }
+    if (code === 401 || code === -32001) {
+      if (message.toLowerCase().includes("expired") || message.toLowerCase().includes("token")) {
+        return new TokenExpiredError(message, context?.provider);
+      }
+      return new AuthenticationError(message, 401, context?.provider);
+    }
+    if (code === 403 || code === -32002) {
+      return new AuthorizationError(message, 403);
+    }
+    if (context?.toolName) {
+      return new ToolCallError(message, context.toolName, error);
+    }
+    return new IntegrateSDKError(message);
+  }
+  if (error instanceof Error) {
+    const message = error.message;
+    const statusCode = error.statusCode;
+    if (statusCode === 401) {
+      if (message.toLowerCase().includes("expired") || message.toLowerCase().includes("token")) {
+        return new TokenExpiredError(message, context?.provider);
+      }
+      return new AuthenticationError(message, 401, context?.provider);
+    }
+    if (statusCode === 403) {
+      return new AuthorizationError(message, 403);
+    }
+    if (message.includes("401") || message.includes("Unauthorized") || message.includes("unauthenticated")) {
+      if (message.toLowerCase().includes("expired") || message.toLowerCase().includes("token")) {
+        return new TokenExpiredError(message, context?.provider);
+      }
+      return new AuthenticationError(message, 401, context?.provider);
+    }
+    if (message.includes("403") || message.includes("Forbidden") || message.includes("unauthorized")) {
+      return new AuthorizationError(message, 403);
+    }
+    if (context?.toolName) {
+      return new ToolCallError(message, context.toolName, error);
+    }
+    return new IntegrateSDKError(message);
+  }
+  return new IntegrateSDKError(String(error));
+}
+var IntegrateSDKError, AuthenticationError, AuthorizationError, TokenExpiredError, ConnectionError, ToolCallError;
+var init_errors = __esm(() => {
+  IntegrateSDKError = class IntegrateSDKError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "IntegrateSDKError";
+    }
+  };
+  AuthenticationError = class AuthenticationError extends IntegrateSDKError {
+    statusCode;
+    provider;
+    constructor(message, statusCode, provider) {
+      super(message);
+      this.name = "AuthenticationError";
+      this.statusCode = statusCode;
+      this.provider = provider;
+    }
+  };
+  AuthorizationError = class AuthorizationError extends IntegrateSDKError {
+    statusCode;
+    requiredScopes;
+    constructor(message, statusCode, requiredScopes) {
+      super(message);
+      this.name = "AuthorizationError";
+      this.statusCode = statusCode;
+      this.requiredScopes = requiredScopes;
+    }
+  };
+  TokenExpiredError = class TokenExpiredError extends AuthenticationError {
+    constructor(message, provider) {
+      super(message, 401, provider);
+      this.name = "TokenExpiredError";
+    }
+  };
+  ConnectionError = class ConnectionError extends IntegrateSDKError {
+    statusCode;
+    constructor(message, statusCode) {
+      super(message);
+      this.name = "ConnectionError";
+      this.statusCode = statusCode;
+    }
+  };
+  ToolCallError = class ToolCallError extends IntegrateSDKError {
+    toolName;
+    originalError;
+    constructor(message, toolName, originalError) {
+      super(message);
+      this.name = "ToolCallError";
+      this.toolName = toolName;
+      this.originalError = originalError;
+    }
+  };
+});
+
+// ../utils/naming.ts
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function methodToToolName(methodName, integrationId) {
+  const snakeCaseMethod = camelToSnake(methodName);
+  return `${integrationId}_${snakeCaseMethod}`;
+}
+
+// ../utils/concurrency.ts
+var exports_concurrency = {};
+__export(exports_concurrency, {
+  parallelWithLimit: () => parallelWithLimit
+});
+async function parallelWithLimit(items, fn, limit = 3) {
+  const results = [];
+  const executing = [];
+  for (let i = 0;i < items.length; i++) {
+    const item = items[i];
+    const index = i;
+    const promise = fn(item).then((result) => {
+      results[index] = result;
+    }).catch(() => {
+      results[index] = undefined;
+    });
+    executing.push(promise);
+    if (executing.length >= limit) {
+      const completedIndex = await Promise.race(executing.map((p, idx) => p.then(() => idx).catch(() => idx)));
+      executing.splice(completedIndex, 1);
+    }
+  }
+  await Promise.all(executing);
+  return results;
+}
+// ../triggers/utils.ts
+var init_utils = () => {};
+
+// ../code-mode/type-generator.ts
+var RESERVED_TS;
+var init_type_generator = __esm(() => {
+  RESERVED_TS = new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "as",
+    "implements",
+    "interface",
+    "let",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "static",
+    "yield"
+  ]);
+});
+// ../code-mode/executor.ts
+var init_executor = () => {};
+
+// ../code-mode/tool-builder.ts
+var DEFAULT_INSTRUCTIONS, warnedCodeModeReasons;
+var init_tool_builder = __esm(() => {
+  init_type_generator();
+  init_executor();
+  DEFAULT_INSTRUCTIONS = [
+    "You are given a single tool: `execute_code`. Instead of calling individual MCP tools,",
+    "you write a short async TypeScript/JavaScript snippet that uses the typed `client`",
+    "object below, and the snippet runs in an isolated sandbox which dispatches the actual",
+    "tool calls. Chain multiple operations together in one snippet whenever possible —",
+    "that is the whole point of this tool.",
+    "",
+    "Rules:",
+    "- The snippet is the body of an `async` function. Use `await` freely.",
+    "- Use `return <value>` at the end to hand a structured result back to the caller;",
+    "  the caller receives it as JSON.",
+    "- Use `console.log(...)` for intermediate observations you want to read later.",
+    "- Throw / let errors propagate; the runtime will surface them with a non-zero exit.",
+    "- Each method call returns an object of shape `ToolResult` (see types below).",
+    "  The payload usually lives in `result.content[0].text` as JSON — parse it if needed.",
+    "- You cannot import npm packages. Only the pre-imported `client` and standard",
+    "  globals (`fetch`, `console`, `JSON`, ...) are available.",
+    "",
+    "API surface:"
+  ].join(`
+`);
+  warnedCodeModeReasons = new Set;
+});
+
+// nextjs.ts
+init_base_handler();
+init_logger();
+var SERVER_LOG_CONTEXT2 = "server";
+var logger3 = createLogger("NextJSOAuth", SERVER_LOG_CONTEXT2);
+function createNextOAuthHandler(config) {
+  const handler = new OAuthHandler(config);
+  const handlers = {
+    async authorize(req) {
+      try {
+        const result = await handler.handleAuthorize(req);
+        const response = Response.json(result);
+        if (result.setCookie) {
+          response.headers.set("Set-Cookie", result.setCookie);
+        }
+        if (handler.hasDatabaseCallbacks()) {
+          response.headers.set("X-Integrate-Use-Database", "true");
+        }
+        return response;
+      } catch (error) {
+        logger3.error("[OAuth Authorize] Error:", error);
+        return Response.json({ error: error.message || "Failed to get authorization URL" }, { status: 500 });
+      }
+    },
+    async callback(req) {
+      try {
+        const result = await handler.handleCallback(req);
+        const response = Response.json(result);
+        if (result.clearCookie) {
+          response.headers.set("Set-Cookie", result.clearCookie);
+        }
+        if (handler.hasDatabaseCallbacks()) {
+          response.headers.set("X-Integrate-Use-Database", "true");
+        }
+        return response;
+      } catch (error) {
+        logger3.error("[OAuth Callback] Error:", error);
+        return Response.json({ error: error.message || "Failed to exchange authorization code" }, { status: 500 });
+      }
+    },
+    async status(req) {
+      try {
+        const provider = req.nextUrl.searchParams.get("provider");
+        const authHeader = req.headers.get("authorization");
+        if (!provider) {
+          return Response.json({ error: "Missing provider query parameter" }, { status: 400 });
+        }
+        if (!authHeader || !authHeader.startsWith("Bearer ")) {
+          return Response.json({ error: "Missing or invalid Authorization header" }, { status: 400 });
+        }
+        const accessToken = authHeader.substring(7);
+        const result = await handler.handleStatus(provider, accessToken);
+        const response = Response.json(result);
+        if (handler.hasDatabaseCallbacks()) {
+          response.headers.set("X-Integrate-Use-Database", "true");
+        }
+        return response;
+      } catch (error) {
+        logger3.error("[OAuth Status] Error:", error);
+        return Response.json({ error: error.message || "Failed to check authorization status" }, { status: 500 });
+      }
+    },
+    async disconnect(req) {
+      try {
+        const authHeader = req.headers.get("authorization");
+        if (!authHeader || !authHeader.startsWith("Bearer ")) {
+          return Response.json({ error: "Missing or invalid Authorization header" }, { status: 400 });
+        }
+        const accessToken = authHeader.substring(7);
+        const body = await req.json();
+        const { provider } = body;
+        if (!provider) {
+          return Response.json({ error: "Missing provider in request body" }, { status: 400 });
+        }
+        const result = await handler.handleDisconnect({ provider }, accessToken, req);
+        const response = Response.json(result);
+        if (handler.hasDatabaseCallbacks()) {
+          response.headers.set("X-Integrate-Use-Database", "true");
+        }
+        return response;
+      } catch (error) {
+        logger3.error("[OAuth Disconnect] Error:", error);
+        return Response.json({ error: error.message || "Failed to disconnect provider" }, { status: 500 });
+      }
+    },
+    async refresh(req) {
+      try {
+        const result = await handler.handleRefresh(req);
+        const response = Response.json(result);
+        if (handler.hasDatabaseCallbacks()) {
+          response.headers.set("X-Integrate-Use-Database", "true");
+        }
+        return response;
+      } catch (error) {
+        if (error.message?.toLowerCase().includes("not supported")) {
+          logger3.info("[OAuth Refresh] Not supported for this provider:", error.message);
+        } else {
+          logger3.error("[OAuth Refresh] Error:", error);
+        }
+        return Response.json({ error: error.message || "Failed to refresh token" }, { status: 500 });
+      }
+    },
+    createRoutes() {
+      return {
+        async POST(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const action = params.action;
+          if (action === "authorize") {
+            return handlers.authorize(req);
+          }
+          if (action === "callback") {
+            return handlers.callback(req);
+          }
+          if (action === "disconnect") {
+            return handlers.disconnect(req);
+          }
+          if (action === "refresh") {
+            return handlers.refresh(req);
+          }
+          if (action === "mcp") {
+            return handlers.mcp(req);
+          }
+          return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+        },
+        async GET(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const action = params.action;
+          if (action === "status") {
+            return handlers.status(req);
+          }
+          return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+        }
+      };
+    },
+    async mcp(req) {
+      try {
+        const body = await req.json();
+        const authHeader = req.headers.get("authorization");
+        const integrationsHeader = req.headers.get("x-integrations");
+        const result = await handler.handleToolCall(body, authHeader, integrationsHeader);
+        return Response.json(result);
+      } catch (error) {
+        logger3.error("[MCP Tool Call] Error:", error);
+        return Response.json({ error: error.message || "Failed to execute tool call" }, { status: error.statusCode || 500 });
+      }
+    },
+    toNextJsHandler(redirectConfig) {
+      const defaultRedirectUrl = redirectConfig?.redirectUrl || "/";
+      const errorRedirectUrl = redirectConfig?.errorRedirectUrl || "/auth-error";
+      return {
+        async POST(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const segments = params.all || [];
+          if (segments.length === 2 && segments[0] === "oauth") {
+            const action = segments[1];
+            if (action === "authorize") {
+              return handlers.authorize(req);
+            }
+            if (action === "callback") {
+              return handlers.callback(req);
+            }
+            if (action === "disconnect") {
+              return handlers.disconnect(req);
+            }
+            if (action === "refresh") {
+              return handlers.refresh(req);
+            }
+            return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+          }
+          if (segments.length === 1 && segments[0] === "mcp") {
+            return handlers.mcp(req);
+          }
+          return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
+        },
+        async GET(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const segments = params.all || [];
+          if (segments.length === 2 && segments[0] === "oauth") {
+            const action = segments[1];
+            if (action === "status") {
+              return handlers.status(req);
+            }
+            if (action === "callback") {
+              const { searchParams } = new URL(req.url);
+              const code = searchParams.get("code");
+              const state = searchParams.get("state");
+              const error = searchParams.get("error");
+              const errorDescription = searchParams.get("error_description");
+              if (error) {
+                const errorMsg = errorDescription || error;
+                logger3.error("[OAuth Redirect] Error:", errorMsg);
+                return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent(errorMsg)}`, req.url));
+              }
+              if (!code || !state) {
+                logger3.error("[OAuth Redirect] Missing code or state parameter");
+                return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, req.url));
+              }
+              let returnUrl = defaultRedirectUrl;
+              try {
+                const { parseState: parseState2 } = await Promise.resolve().then(() => exports_pkce);
+                const stateData = parseState2(state);
+                if (stateData.returnUrl) {
+                  returnUrl = stateData.returnUrl;
+                }
+              } catch (e) {
+                try {
+                  const referrer = req.headers?.get?.("referer") || req.headers?.get?.("referrer");
+                  if (referrer) {
+                    const referrerUrl = new URL(referrer);
+                    const currentUrl = new URL(req.url);
+                    if (referrerUrl.origin === currentUrl.origin) {
+                      returnUrl = referrerUrl.pathname + referrerUrl.search;
+                    }
+                  }
+                } catch {}
+              }
+              const targetUrl = new URL(returnUrl, req.url);
+              targetUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state }))}`;
+              return Response.redirect(targetUrl);
+            }
+            return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+          }
+          if (segments.length === 1 && segments[0] === "integrations") {
+            const result = handler.handleIntegrations();
+            return Response.json(result);
+          }
+          return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
+        }
+      };
+    }
+  };
+  return handlers;
+}
+
+// node.ts
+function fromNodeHeaders(nodeHeaders) {
+  const webHeaders = new Headers;
+  for (const [key, value] of Object.entries(nodeHeaders)) {
+    if (value !== undefined) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => webHeaders.append(key, v));
+      } else {
+        webHeaders.set(key, value);
+      }
+    }
+  }
+  return webHeaders;
+}
+async function toWebRequest(req) {
+  const protocol = req.socket?.encrypted ? "https" : "http";
+  const host = req.headers.host || "localhost";
+  const url = `${protocol}://${host}${req.url || ""}`;
+  const headers = fromNodeHeaders(req.headers);
+  let body;
+  if (req.method && ["POST", "PUT", "PATCH"].includes(req.method)) {
+    body = await new Promise((resolve, reject) => {
+      let data = "";
+      req.on("data", (chunk) => data += chunk);
+      req.on("end", () => resolve(data));
+      req.on("error", reject);
+    });
+  }
+  return new Request(url, {
+    method: req.method,
+    headers,
+    body: body || undefined
+  });
+}
+async function sendWebResponse(webRes, nodeRes) {
+  nodeRes.statusCode = webRes.status;
+  webRes.headers.forEach((value, key) => {
+    nodeRes.setHeader(key, value);
+  });
+  const body = await webRes.text();
+  nodeRes.end(body);
+}
+
+// ../protocol/jsonrpc.ts
+function parseMessage(message) {
+  try {
+    return JSON.parse(message);
+  } catch (error) {
+    throw new Error(`Failed to parse JSON-RPC message: ${error}`);
+  }
+}
+
+// ../transport/http-session.ts
+init_logger();
+var logger4 = createLogger("HTTPSession");
+
+class HttpSessionTransport {
+  url;
+  headers;
+  timeout;
+  messageHandlers = new Set;
+  sessionId;
+  sseController;
+  connected = false;
+  constructor(options) {
+    this.url = options.url;
+    this.headers = options.headers || {};
+    this.timeout = options.timeout || 30000;
+  }
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    this.connected = true;
+  }
+  async sendRequest(method, params) {
+    if (!this.connected) {
+      throw new Error("Not connected to server");
+    }
+    const request = {
+      jsonrpc: "2.0",
+      id: Date.now() + Math.random(),
+      method,
+      params
+    };
+    const headers = {
+      ...this.headers,
+      "Content-Type": "application/json"
+    };
+    if (this.sessionId) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+    try {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch(this.url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(request),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = new Error(`Request failed: ${response.statusText}`);
+        error.statusCode = response.status;
+        throw error;
+      }
+      if (!this.sessionId) {
+        const sid = response.headers.get("mcp-session-id");
+        if (sid) {
+          this.sessionId = sid;
+          logger4.debug("Session established:", sid);
+          this.startSSEListener();
+        }
+      }
+      const jsonResponse = await response.json();
+      if ("error" in jsonResponse) {
+        const error = new Error(`JSON-RPC Error ${jsonResponse.error.code}: ${jsonResponse.error.message}`);
+        error.code = jsonResponse.error.code;
+        if (jsonResponse.error.data) {
+          error.data = jsonResponse.error.data;
+        }
+        error.jsonrpcError = jsonResponse.error;
+        throw error;
+      }
+      return jsonResponse.result;
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          const timeoutError = new Error("Request timeout");
+          timeoutError.code = -32000;
+          throw timeoutError;
+        }
+        throw error;
+      }
+      throw new Error(String(error));
+    }
+  }
+  async startSSEListener() {
+    if (!this.sessionId || this.sseController) {
+      return;
+    }
+    this.sseController = new AbortController;
+    try {
+      const response = await fetch(this.url, {
+        method: "GET",
+        headers: {
+          ...this.headers,
+          Accept: "text/event-stream",
+          "mcp-session-id": this.sessionId
+        },
+        signal: this.sseController.signal
+      });
+      if (!response.ok || !response.body) {
+        return;
+      }
+      this.processSSEStream(response.body);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      logger4.error("SSE connection error:", error);
+    }
+  }
+  async processSSEStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder;
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(`
+`);
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6).trim();
+            if (data) {
+              this.handleNotification(data);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      logger4.error("SSE stream error:", error);
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  handleNotification(data) {
+    try {
+      const message = parseMessage(data);
+      this.messageHandlers.forEach((handler) => {
+        try {
+          handler(message);
+        } catch (error) {
+          logger4.error("Error in message handler:", error);
+        }
+      });
+    } catch (error) {
+      logger4.error("Failed to parse notification:", error);
+    }
+  }
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => {
+      this.messageHandlers.delete(handler);
+    };
+  }
+  async disconnect() {
+    if (!this.connected) {
+      return;
+    }
+    if (this.sseController) {
+      this.sseController.abort();
+      this.sseController = undefined;
+    }
+    this.messageHandlers.clear();
+    this.sessionId = undefined;
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  setHeader(key, value) {
+    this.headers[key] = value;
+  }
+  removeHeader(key) {
+    delete this.headers[key];
+  }
+  getHeaders() {
+    return { ...this.headers };
+  }
+}
+
+// ../client.ts
+init_errors();
+init_logger();
+
+// ../triggers/client.ts
+class TriggerClient {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async create(params) {
+    return this.request("POST", "/triggers", params);
+  }
+  async list(params) {
+    let path = "/triggers";
+    if (params) {
+      const searchParams = new URLSearchParams;
+      if (params.status)
+        searchParams.set("status", params.status);
+      if (params.toolName)
+        searchParams.set("toolName", params.toolName);
+      if (params.limit !== undefined)
+        searchParams.set("limit", params.limit.toString());
+      if (params.offset !== undefined)
+        searchParams.set("offset", params.offset.toString());
+      const query = searchParams.toString();
+      if (query)
+        path += `?${query}`;
+    }
+    return this.request("GET", path);
+  }
+  async get(triggerId) {
+    return this.request("GET", `/triggers/${triggerId}`);
+  }
+  async update(triggerId, params) {
+    return this.request("PATCH", `/triggers/${triggerId}`, params);
+  }
+  async delete(triggerId) {
+    await this.request("DELETE", `/triggers/${triggerId}`);
+  }
+  async pause(triggerId) {
+    return this.request("POST", `/triggers/${triggerId}/pause`);
+  }
+  async resume(triggerId) {
+    return this.request("POST", `/triggers/${triggerId}/resume`);
+  }
+  async run(triggerId) {
+    return this.request("POST", `/triggers/${triggerId}/run`);
+  }
+  async request(method, path, body) {
+    const url = this.config.apiBaseUrl ? `${this.config.apiBaseUrl}${this.config.apiRouteBase}${path}` : `${this.config.apiRouteBase}${path}`;
+    const options = {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...this.config.getHeaders()
+      }
+    };
+    if (body !== undefined) {
+      options.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      let errorMessage = `Request failed: ${response.statusText}`;
+      try {
+        const errorData = await response.json();
+        if (errorData.error) {
+          errorMessage = typeof errorData.error === "string" ? errorData.error : errorData.error.message || errorMessage;
+        }
+      } catch {}
+      throw new Error(errorMessage);
+    }
+    if (method === "DELETE" && response.status === 204) {
+      return;
+    }
+    return response.json();
+  }
+}
+// ../oauth/window-manager.ts
+init_logger();
+var logger5 = createLogger("OAuthWindowManager");
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+
+class OAuthWindowManager {
+  popupWindow = null;
+  popupCheckInterval = null;
+  popupCheckTimeout = null;
+  openPopup(url, options) {
+    if (!isBrowser()) {
+      throw new Error("OAuthWindowManager.openPopup() can only be used in browser environments");
+    }
+    const width = options?.width || 600;
+    const height = options?.height || 700;
+    const left = window.screenX + (window.outerWidth - width) / 2;
+    const top = window.screenY + (window.outerHeight - height) / 2;
+    const features = [
+      `popup=yes`,
+      `width=${width}`,
+      `height=${height}`,
+      `left=${left}`,
+      `top=${top}`,
+      "toolbar=no",
+      "location=no",
+      "directories=no",
+      "status=no",
+      "menubar=no",
+      "scrollbars=yes",
+      "resizable=yes",
+      "copyhistory=no",
+      "noopener=no"
+    ].join(",");
+    const windowName = `oauth_popup_${Date.now()}`;
+    this.popupWindow = window.open(url, windowName, features);
+    if (!this.popupWindow) {
+      logger5.warn("Popup was blocked by the browser. Please allow popups for this site.");
+      return null;
+    }
+    this.popupWindow.focus();
+    return this.popupWindow;
+  }
+  openRedirect(url) {
+    if (!isBrowser()) {
+      throw new Error("OAuthWindowManager.openRedirect() can only be used in browser environments");
+    }
+    logger5.debug("[OAuthWindowManager] Redirecting to:", url.substring(0, 100) + (url.length > 100 ? "..." : ""));
+    window.location.href = url;
+  }
+  listenForCallback(mode, timeoutMs = 5 * 60 * 1000) {
+    if (mode === "popup") {
+      return this.listenForPopupCallback(timeoutMs);
+    } else {
+      return this.listenForRedirectCallback();
+    }
+  }
+  listenForPopupCallback(timeoutMs) {
+    if (!isBrowser()) {
+      return Promise.reject(new Error("OAuth popup callback can only be used in browser environments"));
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.cleanup();
+        reject(new Error("OAuth authorization timed out"));
+      }, timeoutMs);
+      const messageHandler = (event) => {
+        if (event.data && event.data.type === "oauth_callback") {
+          clearTimeout(timeout);
+          if (this.popupCheckTimeout) {
+            clearTimeout(this.popupCheckTimeout);
+            this.popupCheckTimeout = null;
+          }
+          window.removeEventListener("message", messageHandler);
+          const { code, state, error } = event.data;
+          if (error) {
+            this.cleanup();
+            reject(new Error(`OAuth error: ${error}`));
+            return;
+          }
+          if (!code || !state) {
+            this.cleanup();
+            reject(new Error("Invalid OAuth callback: missing code or state"));
+            return;
+          }
+          this.cleanup();
+          resolve({ code, state });
+        }
+      };
+      window.addEventListener("message", messageHandler);
+      this.popupCheckTimeout = setTimeout(() => {
+        this.popupCheckTimeout = null;
+        this.popupCheckInterval = setInterval(() => {
+          if (this.popupWindow?.closed) {
+            clearTimeout(timeout);
+            clearInterval(this.popupCheckInterval);
+            window.removeEventListener("message", messageHandler);
+            this.cleanup();
+            reject(new Error("OAuth popup was closed by user"));
+          }
+        }, 500);
+      }, 2000);
+    });
+  }
+  listenForRedirectCallback() {
+    if (!isBrowser()) {
+      return Promise.reject(new Error("OAuth redirect callback can only be used in browser environments"));
+    }
+    return new Promise((resolve, reject) => {
+      const params = new URLSearchParams(window.location.search);
+      let code = params.get("code");
+      let state = params.get("state");
+      let error = params.get("error");
+      let errorDescription = params.get("error_description");
+      if (!code && !error && window.location.hash) {
+        try {
+          const hash = window.location.hash.substring(1);
+          const hashParams = new URLSearchParams(hash);
+          const oauthCallback = hashParams.get("oauth_callback");
+          if (oauthCallback) {
+            const parsed = JSON.parse(decodeURIComponent(oauthCallback));
+            code = parsed.code;
+            state = parsed.state;
+            window.history.replaceState(null, "", window.location.pathname + window.location.search);
+          }
+        } catch (e) {
+          logger5.error("Failed to parse OAuth callback params from hash:", e);
+        }
+      }
+      if (!code && !error) {
+        try {
+          const stored = sessionStorage.getItem("oauth_callback_params");
+          if (stored) {
+            const parsed = JSON.parse(stored);
+            code = parsed.code;
+            state = parsed.state;
+            sessionStorage.removeItem("oauth_callback_params");
+          }
+        } catch (e) {
+          logger5.error("Failed to parse OAuth callback params from sessionStorage:", e);
+        }
+      }
+      if (error) {
+        const errorMsg = errorDescription || error;
+        reject(new Error(`OAuth error: ${errorMsg}`));
+        return;
+      }
+      if (!code || !state) {
+        reject(new Error("Invalid OAuth callback: missing code or state in URL"));
+        return;
+      }
+      resolve({ code, state });
+    });
+  }
+  cleanup() {
+    if (this.popupWindow && !this.popupWindow.closed) {
+      this.popupWindow.close();
+    }
+    this.popupWindow = null;
+    if (this.popupCheckInterval) {
+      clearInterval(this.popupCheckInterval);
+      this.popupCheckInterval = null;
+    }
+    if (this.popupCheckTimeout) {
+      clearTimeout(this.popupCheckTimeout);
+      this.popupCheckTimeout = null;
+    }
+  }
+  close() {
+    this.cleanup();
+  }
+}
+
+// ../oauth/indexeddb-storage.ts
+var DB_NAME = "integrate_oauth_tokens";
+var DB_VERSION = 1;
+var STORE_NAME = "tokens";
+
+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}`));
+    });
+  }
+}
+
+// ../oauth/manager.ts
+init_email_fetcher();
+init_logger();
+var logger6 = createLogger("OAuth");
+
+class OAuthManager {
+  pendingAuths = new Map;
+  providerTokens = new Map;
+  windowManager;
+  flowConfig;
+  oauthApiBase;
+  apiBaseUrl;
+  getTokenCallback;
+  setTokenCallback;
+  removeTokenCallback;
+  indexedDBStorage;
+  skipLocalStorage = false;
+  constructor(oauthApiBase, flowConfig, apiBaseUrl, tokenCallbacks) {
+    this.oauthApiBase = oauthApiBase;
+    this.apiBaseUrl = apiBaseUrl;
+    this.windowManager = new OAuthWindowManager;
+    this.flowConfig = {
+      mode: flowConfig?.mode || "redirect",
+      popupOptions: flowConfig?.popupOptions,
+      onAuthCallback: flowConfig?.onAuthCallback
+    };
+    this.getTokenCallback = tokenCallbacks?.getProviderToken;
+    this.setTokenCallback = tokenCallbacks?.setProviderToken;
+    this.removeTokenCallback = tokenCallbacks?.removeProviderToken;
+    this.indexedDBStorage = new IndexedDBStorage;
+    this.cleanupExpiredPendingAuths();
+  }
+  async initiateFlow(provider, config, returnUrl) {
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = await generateCodeChallenge(codeVerifier);
+    const state = generateStateWithReturnUrl(returnUrl);
+    const pendingAuth = {
+      provider,
+      state,
+      codeVerifier,
+      codeChallenge,
+      redirectUri: config.redirectUri,
+      returnUrl,
+      initiatedAt: Date.now()
+    };
+    this.pendingAuths.set(state, pendingAuth);
+    this.savePendingAuthToStorage(state, pendingAuth);
+    const authUrl = await this.getAuthorizationUrl(provider, state, codeChallenge, config.redirectUri, codeVerifier);
+    if (!authUrl || authUrl.trim() === "") {
+      throw new Error("Received empty authorization URL from server");
+    }
+    if (this.flowConfig.mode === "popup") {
+      this.windowManager.openPopup(authUrl, this.flowConfig.popupOptions);
+      try {
+        const callbackParams = await this.windowManager.listenForCallback("popup");
+        await this.handleCallback(callbackParams.code, callbackParams.state);
+      } catch (error) {
+        this.pendingAuths.delete(state);
+        throw error;
+      }
+    } else {
+      this.windowManager.openRedirect(authUrl);
+    }
+  }
+  async handleCallbackWithToken(_code, state, tokenData) {
+    let pendingAuth = this.pendingAuths.get(state);
+    if (!pendingAuth) {
+      pendingAuth = this.loadPendingAuthFromStorage(state);
+    }
+    if (!pendingAuth) {
+      throw new Error("Invalid state parameter: no matching OAuth flow found");
+    }
+    const fiveMinutes = 5 * 60 * 1000;
+    if (Date.now() - pendingAuth.initiatedAt > fiveMinutes) {
+      this.pendingAuths.delete(state);
+      this.removePendingAuthFromStorage(state);
+      throw new Error("OAuth flow expired: please try again");
+    }
+    const provider = tokenData.provider || pendingAuth.provider;
+    const tokenDataToStore = {
+      accessToken: tokenData.accessToken,
+      refreshToken: tokenData.refreshToken,
+      tokenType: tokenData.tokenType,
+      expiresIn: tokenData.expiresIn,
+      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, email);
+    this.pendingAuths.delete(state);
+    this.removePendingAuthFromStorage(state);
+    return { ...tokenDataToStore, provider };
+  }
+  async handleCallback(code, state) {
+    let pendingAuth = this.pendingAuths.get(state);
+    if (!pendingAuth) {
+      pendingAuth = this.loadPendingAuthFromStorage(state);
+    }
+    if (!pendingAuth) {
+      throw new Error("Invalid state parameter: no matching OAuth flow found");
+    }
+    const fiveMinutes = 5 * 60 * 1000;
+    if (Date.now() - pendingAuth.initiatedAt > fiveMinutes) {
+      this.pendingAuths.delete(state);
+      this.removePendingAuthFromStorage(state);
+      throw new Error("OAuth flow expired: please try again");
+    }
+    if (this.flowConfig.onAuthCallback) {
+      try {
+        await this.flowConfig.onAuthCallback(pendingAuth.provider, code, state);
+      } catch (error) {
+        logger6.error("Custom OAuth callback handler failed:", error);
+      }
+    }
+    try {
+      const response = await this.exchangeCodeForToken(pendingAuth.provider, code, pendingAuth.codeVerifier, state);
+      const tokenData = {
+        accessToken: response.accessToken,
+        refreshToken: response.refreshToken,
+        tokenType: response.tokenType,
+        expiresIn: response.expiresIn,
+        expiresAt: response.expiresAt,
+        scopes: response.scopes
+      };
+      const email = response.email || await fetchUserEmail(pendingAuth.provider, tokenData);
+      if (email) {
+        tokenData.email = email;
+      }
+      this.providerTokens.set(pendingAuth.provider, tokenData);
+      await this.saveProviderToken(pendingAuth.provider, tokenData, email);
+      this.pendingAuths.delete(state);
+      this.removePendingAuthFromStorage(state);
+      return { ...tokenData, provider: pendingAuth.provider };
+    } catch (error) {
+      this.pendingAuths.delete(state);
+      this.removePendingAuthFromStorage(state);
+      throw error;
+    }
+  }
+  async checkAuthStatus(provider, email) {
+    const tokenData = await this.getProviderToken(provider, email);
+    if (!tokenData) {
+      return {
+        authorized: false,
+        provider
+      };
+    }
+    return {
+      authorized: true,
+      provider,
+      scopes: tokenData.scopes,
+      expiresAt: tokenData.expiresAt
+    };
+  }
+  async disconnectAccount(provider, email, context) {
+    if (this.removeTokenCallback) {
+      try {
+        await this.removeTokenCallback(provider, email, context);
+      } catch (error) {
+        logger6.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) {
+        logger6.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) {
+        logger6.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, undefined, context);
+      } catch (error) {
+        logger6.error(`Failed to delete tokens for ${provider} from database:`, error);
+      }
+    } else if (this.setTokenCallback) {
+      try {
+        await this.setTokenCallback(provider, null, undefined, context);
+      } catch (error) {
+        logger6.error(`Failed to delete tokens for ${provider} from database:`, error);
+      }
+    }
+    if (!this.setTokenCallback && !this.removeTokenCallback) {
+      try {
+        await this.indexedDBStorage.deleteTokensByProvider(provider);
+      } catch (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);
+  }
+  async listAccounts(provider) {
+    if (this.getTokenCallback) {
+      return [];
+    }
+    if (!this.getTokenCallback) {
+      try {
+        return await this.indexedDBStorage.listAccounts(provider);
+      } catch (error) {
+        logger6.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, email, context);
+        if (tokenData) {
+          this.providerTokens.set(provider, tokenData);
+        }
+        return tokenData;
+      } catch (error) {
+        logger6.error(`Failed to get token for ${provider} via callback:`, error);
+        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) {
+        logger6.error(`Failed to get token from IndexedDB for ${provider}:`, error);
+      }
+    }
+    return this.providerTokens.get(provider);
+  }
+  getAllProviderTokens() {
+    return new Map(this.providerTokens);
+  }
+  getProviderTokenFromCache(provider) {
+    return this.providerTokens.get(provider);
+  }
+  async setProviderToken(provider, tokenData, email, context) {
+    const tokenEmail = email || tokenData?.email;
+    if (tokenData === null) {
+      if (tokenEmail) {
+        this.providerTokens.delete(provider);
+      } else {
+        this.providerTokens.delete(provider);
+      }
+    } else {
+      this.providerTokens.set(provider, tokenData);
+    }
+    await this.saveProviderToken(provider, tokenData, tokenEmail, context);
+  }
+  clearProviderToken(provider) {
+    this.providerTokens.delete(provider);
+    if (!this.setTokenCallback && !this.removeTokenCallback && !this.skipLocalStorage) {
+      this.indexedDBStorage.deleteTokensByProvider(provider).catch((error) => {
+        logger6.error(`Failed to clear tokens for ${provider} from IndexedDB:`, error);
+      });
+    }
+  }
+  clearAllProviderTokens() {
+    this.providerTokens.clear();
+    if (!this.setTokenCallback && !this.removeTokenCallback && !this.skipLocalStorage) {
+      if (typeof window !== "undefined" && window.localStorage) {
+        try {
+          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) => {
+        logger6.error("Failed to clear all tokens from IndexedDB:", error);
+      });
+    }
+  }
+  clearAllPendingAuths() {
+    this.pendingAuths.clear();
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const prefix = "integrate_oauth_pending_";
+        const keysToRemove = [];
+        for (let i = 0;i < window.localStorage.length; i++) {
+          const key = window.localStorage.key(i);
+          if (key && key.startsWith(prefix)) {
+            keysToRemove.push(key);
+          }
+        }
+        keysToRemove.forEach((key) => window.localStorage.removeItem(key));
+      } catch (error) {
+        logger6.error("Failed to clear pending auths from localStorage:", error);
+      }
+    }
+  }
+  async saveProviderToken(provider, tokenData, email, context) {
+    if (this.setTokenCallback) {
+      try {
+        await this.setTokenCallback(provider, tokenData, email, context);
+      } catch (error) {
+        logger6.error(`Failed to ${tokenData === null ? "delete" : "save"} token for ${provider} via callback:`, error);
+        throw error;
+      }
+      return;
+    }
+    if (this.skipLocalStorage) {
+      return;
+    }
+    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;
+    }
+    const tokenEmail = email || tokenData.email;
+    if (tokenEmail) {
+      try {
+        await this.indexedDBStorage.saveToken(provider, tokenEmail, tokenData);
+      } catch (error) {
+        if (typeof window !== "undefined" && window.localStorage) {
+          try {
+            const key = `integrate_token_${provider}`;
+            window.localStorage.setItem(key, JSON.stringify(tokenData));
+          } catch (localStorageError) {
+            logger6.error(`Failed to save token for ${provider} to localStorage:`, localStorageError);
+          }
+        } else {
+          logger6.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) {
+          logger6.error(`Failed to save token for ${provider} to localStorage:`, localStorageError);
+        }
+      }
+    }
+  }
+  async loadProviderToken(provider, email, context) {
+    if (this.getTokenCallback) {
+      try {
+        return await this.getTokenCallback(provider, email, context);
+      } catch (error) {
+        logger6.error(`Failed to load token for ${provider} via callback:`, error);
+        return;
+      }
+    }
+    if (this.skipLocalStorage) {
+      return this.providerTokens.get(provider);
+    }
+    if (email) {
+      try {
+        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) {
+        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, undefined, undefined);
+      if (tokenData) {
+        this.providerTokens.set(provider, tokenData);
+      }
+    }
+  }
+  loadAllProviderTokensSync(providers) {
+    if (this.getTokenCallback) {
+      return;
+    }
+    if (this.skipLocalStorage) {
+      return;
+    }
+    if (typeof window !== "undefined" && window.localStorage) {
+      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) {
+      try {
+        const key = `integrate_oauth_pending_${state}`;
+        window.localStorage.setItem(key, JSON.stringify(pendingAuth));
+      } catch (error) {
+        logger6.error("Failed to save pending auth to localStorage:", error);
+      }
+    }
+  }
+  loadPendingAuthFromStorage(state) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const key = `integrate_oauth_pending_${state}`;
+        const stored = window.localStorage.getItem(key);
+        if (stored) {
+          return JSON.parse(stored);
+        }
+      } catch (error) {
+        logger6.error("Failed to load pending auth from localStorage:", error);
+      }
+    }
+    return;
+  }
+  removePendingAuthFromStorage(state) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const key = `integrate_oauth_pending_${state}`;
+        window.localStorage.removeItem(key);
+      } catch (error) {
+        logger6.error("Failed to remove pending auth from localStorage:", error);
+      }
+    }
+  }
+  cleanupExpiredPendingAuths() {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const prefix = "integrate_oauth_pending_";
+        const fiveMinutes = 5 * 60 * 1000;
+        const now = Date.now();
+        const keysToRemove = [];
+        for (let i = 0;i < window.localStorage.length; i++) {
+          const key = window.localStorage.key(i);
+          if (key && key.startsWith(prefix)) {
+            try {
+              const stored = window.localStorage.getItem(key);
+              if (stored) {
+                const pendingAuth = JSON.parse(stored);
+                if (now - pendingAuth.initiatedAt > fiveMinutes) {
+                  keysToRemove.push(key);
+                }
+              }
+            } catch (error) {
+              keysToRemove.push(key);
+            }
+          }
+        }
+        keysToRemove.forEach((key) => window.localStorage.removeItem(key));
+      } catch (error) {
+        logger6.error("Failed to cleanup expired pending auths:", error);
+      }
+    }
+  }
+  async getAuthorizationUrl(provider, state, codeChallenge, redirectUri, codeVerifier) {
+    const url = this.apiBaseUrl ? `${this.apiBaseUrl}${this.oauthApiBase}/authorize` : `${this.oauthApiBase}/authorize`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        provider,
+        state,
+        codeChallenge,
+        codeChallengeMethod: "S256",
+        redirectUri,
+        codeVerifier: this.flowConfig.mode === "redirect" ? codeVerifier : undefined,
+        frontendOrigin: this.apiBaseUrl && this.flowConfig.mode === "redirect" && typeof window !== "undefined" ? window.location.origin : undefined
+      })
+    });
+    if (response.headers.get("X-Integrate-Use-Database") === "true") {
+      this.setSkipLocalStorage(true);
+    }
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to get authorization URL: ${error}`);
+    }
+    const data = await response.json();
+    if (!data.authorizationUrl) {
+      throw new Error("Authorization URL is missing from server response");
+    }
+    if (typeof data.authorizationUrl !== "string" || data.authorizationUrl.trim() === "") {
+      throw new Error("Invalid authorization URL received from server");
+    }
+    return data.authorizationUrl;
+  }
+  async exchangeCodeForToken(provider, code, codeVerifier, state) {
+    const url = this.apiBaseUrl ? `${this.apiBaseUrl}${this.oauthApiBase}/callback` : `${this.oauthApiBase}/callback`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        provider,
+        code,
+        codeVerifier,
+        state
+      })
+    });
+    if (response.headers.get("X-Integrate-Use-Database") === "true") {
+      this.setSkipLocalStorage(true);
+    }
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to exchange code for token: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  setSkipLocalStorage(value) {
+    this.skipLocalStorage = value;
+  }
+  close() {
+    this.windowManager.close();
+  }
+}
+
+// ../client.ts
+var CLIENT_LOG_CONTEXT = "client";
+
+class SimpleEventEmitter {
+  handlers = new Map;
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, new Set);
+    }
+    this.handlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+  emit(event, payload) {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(payload);
+        } catch (error) {
+          logger7.error(`Error in event handler for ${event}:`, error);
+        }
+      });
+    }
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+  }
+}
+var MCP_SERVER_URL2 = "https://mcp.integrate.dev/api/v1/mcp";
+var logger7 = createLogger("MCPClient", CLIENT_LOG_CONTEXT);
+var clientCache = new Map;
+var cleanupClients = new Set;
+class MCPClientBase {
+  transport;
+  integrations;
+  availableTools = new Map;
+  enabledToolNames = new Set;
+  initialized = false;
+  clientInfo;
+  onReauthRequired;
+  maxReauthRetries;
+  authState = new Map;
+  oauthManager;
+  eventEmitter = new SimpleEventEmitter;
+  apiRouteBase;
+  apiBaseUrl;
+  databaseDetected = false;
+  _connectingPromise = null;
+  __configuredIntegrations;
+  __useServerConfig;
+  oauthCallbackPromise;
+  server;
+  trigger;
+  constructor(config) {
+    this.transport = new HttpSessionTransport({
+      url: config.serverUrl || MCP_SERVER_URL2,
+      headers: config.headers,
+      timeout: config.timeout
+    });
+    const oauthApiBase = config.oauthApiBase || "/api/integrate/oauth";
+    this.apiRouteBase = config.apiRouteBase || "/api/integrate";
+    this.apiBaseUrl = config.apiBaseUrl;
+    const defaultRedirectUri = this.getDefaultRedirectUri(oauthApiBase, this.apiBaseUrl);
+    this.integrations = config.integrations.map((integration) => {
+      if (integration.oauth && !integration.oauth.redirectUri) {
+        return {
+          ...integration,
+          oauth: {
+            ...integration.oauth,
+            redirectUri: defaultRedirectUri
+          }
+        };
+      }
+      return integration;
+    });
+    this.__configuredIntegrations = this.integrations;
+    this.__useServerConfig = config.useServerConfig ?? false;
+    this.clientInfo = config.clientInfo || {
+      name: "integrate-sdk",
+      version: "0.1.0"
+    };
+    this.onReauthRequired = config.onReauthRequired;
+    this.maxReauthRetries = config.maxReauthRetries ?? 1;
+    this.oauthManager = new OAuthManager(oauthApiBase, config.oauthFlow, this.apiBaseUrl, {
+      getProviderToken: config.getProviderToken,
+      setProviderToken: config.setProviderToken,
+      removeProviderToken: config.removeProviderToken
+    });
+    for (const integration of this.integrations) {
+      for (const toolName of integration.tools) {
+        this.enabledToolNames.add(toolName);
+      }
+      if (integration.oauth) {
+        const provider = integration.oauth.provider;
+        this.authState.set(provider, { authenticated: false });
+      }
+    }
+    const integrationHeaderValue = this.getIntegrationHeaderValue();
+    if (integrationHeaderValue && this.transport.setHeader) {
+      this.transport.setHeader("X-Integrations", integrationHeaderValue);
+    }
+    const providers = this.integrations.filter((p) => p.oauth).map((p) => p.oauth.provider);
+    const usingDatabaseCallbacks = !!config.getProviderToken;
+    if (usingDatabaseCallbacks) {
+      this.oauthManager.loadAllProviderTokens(providers).then(async () => {
+        for (const integration of this.integrations) {
+          if (integration.oauth) {
+            const provider = integration.oauth.provider;
+            try {
+              const tokenData = await this.oauthManager.getProviderToken(provider);
+              const currentState = this.authState.get(provider);
+              if (currentState && !currentState.authenticated && !currentState.lastError) {
+                this.authState.set(provider, { authenticated: !!tokenData });
+              }
+            } catch (error) {
+              logger7.error(`Failed to check token for ${provider}:`, error);
+              const currentState = this.authState.get(provider);
+              if (currentState && !currentState.authenticated && !currentState.lastError) {
+                this.authState.set(provider, { authenticated: false });
+              }
+            }
+          }
+        }
+      }).catch((error) => {
+        logger7.error("Failed to load provider tokens:", error);
+      });
+    } else {
+      this.oauthManager.loadAllProviderTokensSync(providers);
+      for (const integration of this.integrations) {
+        if (integration.oauth) {
+          const provider = integration.oauth.provider;
+          const tokenData = this.oauthManager.getProviderTokenFromCache(provider);
+          if (tokenData) {
+            this.authState.set(provider, { authenticated: true });
+          }
+        }
+      }
+    }
+    const integrationIds = this.integrations.map((i) => i.id);
+    if (integrationIds.includes("github")) {
+      this.github = this.createIntegrationProxy("github");
+    }
+    if (integrationIds.includes("gmail")) {
+      this.gmail = this.createIntegrationProxy("gmail");
+    }
+    if (integrationIds.includes("notion")) {
+      this.notion = this.createIntegrationProxy("notion");
+    }
+    if (integrationIds.includes("slack")) {
+      this.slack = this.createIntegrationProxy("slack");
+    }
+    if (integrationIds.includes("linear")) {
+      this.linear = this.createIntegrationProxy("linear");
+    }
+    if (integrationIds.includes("vercel")) {
+      this.vercel = this.createIntegrationProxy("vercel");
+    }
+    if (integrationIds.includes("zendesk")) {
+      this.zendesk = this.createIntegrationProxy("zendesk");
+    }
+    if (integrationIds.includes("stripe")) {
+      this.stripe = this.createIntegrationProxy("stripe");
+    }
+    if (integrationIds.includes("gcal")) {
+      this.gcal = this.createIntegrationProxy("gcal");
+    }
+    if (integrationIds.includes("outlook")) {
+      this.outlook = this.createIntegrationProxy("outlook");
+    }
+    if (integrationIds.includes("airtable")) {
+      this.airtable = this.createIntegrationProxy("airtable");
+    }
+    if (integrationIds.includes("todoist")) {
+      this.todoist = this.createIntegrationProxy("todoist");
+    }
+    this.server = this.createServerProxy();
+    this.trigger = new TriggerClient({
+      apiRouteBase: this.apiRouteBase,
+      apiBaseUrl: this.apiBaseUrl,
+      getHeaders: () => ({
+        "X-Integrations": this.getIntegrationHeaderValue()
+      })
+    });
+    this.initializeIntegrations();
+  }
+  getDefaultRedirectUri(oauthApiBase, apiBaseUrl) {
+    const normalizedPath = oauthApiBase.replace(/\/$/, "");
+    const callbackPath = `${normalizedPath}/callback`;
+    if (apiBaseUrl) {
+      const normalizedApiBaseUrl = apiBaseUrl.replace(/\/$/, "");
+      return `${normalizedApiBaseUrl}${callbackPath}`;
+    }
+    if (typeof window === "undefined" || !window.location) {
+      return "http://localhost:3000/api/integrate/oauth/callback";
+    }
+    const origin = window.location.origin;
+    return `${origin}${callbackPath}`;
+  }
+  createIntegrationProxy(integrationId) {
+    const hasIntegration = this.integrations.some((integration) => integration.id === integrationId);
+    if (!hasIntegration) {
+      return;
+    }
+    return new Proxy({}, {
+      get: (_target, methodName) => {
+        return async (args, options) => {
+          const toolName = methodToToolName(methodName, integrationId);
+          return await this.callToolWithRetry(toolName, args, 0, options);
+        };
+      }
+    });
+  }
+  getIntegrationHeaderValue() {
+    return this.integrations.map((integration) => integration.id).join(",");
+  }
+  createServerProxy() {
+    return new Proxy({}, {
+      get: (_target, methodName) => {
+        if (methodName === "listConfiguredIntegrations") {
+          return async (options) => {
+            const transportHeaders = this.transport.headers || {};
+            const hasApiKey = !!transportHeaders["X-API-KEY"];
+            const serverConfig = this.__oauthConfig;
+            const localIntegrations = serverConfig?.integrations || this.__configuredIntegrations;
+            const formatLocalIntegrations = (integrations) => ({
+              integrations: integrations.map((integration) => ({
+                id: integration.id,
+                name: integration.name || integration.id,
+                logoUrl: integration.logoUrl,
+                tools: integration.tools,
+                hasOAuth: !!integration.oauth,
+                scopes: integration.oauth?.scopes,
+                provider: integration.oauth?.provider
+              }))
+            });
+            if (hasApiKey || !this.__useServerConfig) {
+              if (options?.includeToolMetadata && hasApiKey) {
+                await this.ensureConnected();
+                const integrationsWithMetadata = localIntegrations.map((integration) => {
+                  const toolMetadata = integration.tools.map((toolName) => this.availableTools.get(toolName)).filter((tool) => !!tool);
+                  return {
+                    id: integration.id,
+                    name: integration.name || integration.id,
+                    logoUrl: integration.logoUrl,
+                    tools: integration.tools,
+                    hasOAuth: !!integration.oauth,
+                    scopes: integration.oauth?.scopes,
+                    provider: integration.oauth?.provider,
+                    toolMetadata
+                  };
+                });
+                return { integrations: integrationsWithMetadata };
+              }
+              if (options?.includeToolMetadata && !hasApiKey) {
+                const { parallelWithLimit: parallelWithLimit2 } = await Promise.resolve().then(() => exports_concurrency);
+                const integrationsWithMetadata = await parallelWithLimit2(localIntegrations, async (integration) => {
+                  try {
+                    const response = await this.callServerToolInternal("list_tools_by_integration", {
+                      integration: integration.id
+                    });
+                    let toolMetadata = [];
+                    if (response.content && Array.isArray(response.content)) {
+                      for (const item of response.content) {
+                        if (item.type === "text" && item.text) {
+                          try {
+                            const parsed = JSON.parse(item.text);
+                            if (Array.isArray(parsed)) {
+                              toolMetadata = parsed;
+                            } else if (parsed.tools && Array.isArray(parsed.tools)) {
+                              toolMetadata = parsed.tools;
+                            }
+                          } catch {}
+                        }
+                      }
+                    }
+                    return {
+                      id: integration.id,
+                      name: integration.name || integration.id,
+                      logoUrl: integration.logoUrl,
+                      tools: integration.tools,
+                      hasOAuth: !!integration.oauth,
+                      scopes: integration.oauth?.scopes,
+                      provider: integration.oauth?.provider,
+                      toolMetadata
+                    };
+                  } catch (error) {
+                    logger7.error(`Failed to fetch tool metadata for ${integration.id}:`, error);
+                    return {
+                      id: integration.id,
+                      name: integration.name || integration.id,
+                      logoUrl: integration.logoUrl,
+                      tools: integration.tools,
+                      hasOAuth: !!integration.oauth,
+                      scopes: integration.oauth?.scopes,
+                      provider: integration.oauth?.provider,
+                      toolMetadata: []
+                    };
+                  }
+                }, 3);
+                return { integrations: integrationsWithMetadata };
+              }
+              return formatLocalIntegrations(localIntegrations);
+            }
+            const url = this.apiBaseUrl ? `${this.apiBaseUrl}${this.apiRouteBase}/integrations` : `${this.apiRouteBase}/integrations`;
+            try {
+              const response = await fetch(url, {
+                method: "GET",
+                headers: {
+                  "Content-Type": "application/json"
+                }
+              });
+              if (!response.ok) {
+                logger7.error("Failed to fetch integrations from server, falling back to local config");
+                return formatLocalIntegrations(localIntegrations);
+              }
+              const result = await response.json();
+              if (options?.includeToolMetadata && result.integrations) {
+                const { parallelWithLimit: parallelWithLimit2 } = await Promise.resolve().then(() => exports_concurrency);
+                const integrationsWithMetadata = await parallelWithLimit2(result.integrations, async (integration) => {
+                  try {
+                    const metadataResponse = await this.callServerToolInternal("list_tools_by_integration", {
+                      integration: integration.id
+                    });
+                    let toolMetadata = [];
+                    if (metadataResponse.content && Array.isArray(metadataResponse.content)) {
+                      for (const item of metadataResponse.content) {
+                        if (item.type === "text" && item.text) {
+                          try {
+                            const parsed = JSON.parse(item.text);
+                            if (Array.isArray(parsed)) {
+                              toolMetadata = parsed;
+                            } else if (parsed.tools && Array.isArray(parsed.tools)) {
+                              toolMetadata = parsed.tools;
+                            }
+                          } catch {}
+                        }
+                      }
+                    }
+                    return {
+                      ...integration,
+                      toolMetadata
+                    };
+                  } catch (error) {
+                    logger7.error(`Failed to fetch tool metadata for ${integration.id}:`, error);
+                    return {
+                      ...integration,
+                      toolMetadata: []
+                    };
+                  }
+                }, 3);
+                return { integrations: integrationsWithMetadata };
+              }
+              return result;
+            } catch (error) {
+              logger7.error("Failed to fetch integrations from server, falling back to local config:", error);
+              return formatLocalIntegrations(localIntegrations);
+            }
+          };
+        }
+        return async (args, options) => {
+          const toolName = methodToToolName(methodName, "");
+          const finalToolName = toolName.startsWith("_") ? toolName.substring(1) : toolName;
+          return await this.callServerToolInternal(finalToolName, args, options);
+        };
+      }
+    });
+  }
+  async callServerToolInternal(name, args, options) {
+    try {
+      const response = await this.callToolThroughHandler(name, args, undefined, options);
+      return response;
+    } catch (error) {
+      const parsedError = parseServerError(error, { toolName: name });
+      throw parsedError;
+    }
+  }
+  async ensureConnected() {
+    if (this.isConnected()) {
+      return;
+    }
+    if (!this._connectingPromise) {
+      this._connectingPromise = this.connect().finally(() => {
+        this._connectingPromise = null;
+      });
+    }
+    return this._connectingPromise;
+  }
+  async initializeIntegrations() {
+    for (const integration of this.integrations) {
+      if (integration.onInit) {
+        await integration.onInit(this);
+      }
+    }
+  }
+  async connect() {
+    for (const integration of this.integrations) {
+      if (integration.onBeforeConnect) {
+        await integration.onBeforeConnect(this);
+      }
+    }
+    await this.transport.connect();
+    await this.initialize();
+    await this.discoverTools();
+    for (const integration of this.integrations) {
+      if (integration.onAfterConnect) {
+        await integration.onAfterConnect(this);
+      }
+    }
+  }
+  async initialize() {
+    const params = {
+      protocolVersion: "2024-11-05",
+      capabilities: {
+        tools: {}
+      },
+      clientInfo: this.clientInfo
+    };
+    const response = await this.transport.sendRequest("initialize" /* INITIALIZE */, params);
+    this.initialized = true;
+    return response;
+  }
+  async discoverTools() {
+    let cursor;
+    let totalDiscovered = 0;
+    do {
+      const response = await this.transport.sendRequest("tools/list" /* TOOLS_LIST */, cursor ? { cursor } : undefined);
+      for (const tool of response.tools) {
+        this.availableTools.set(tool.name, tool);
+      }
+      totalDiscovered += response.tools.length;
+      cursor = response.nextCursor;
+    } while (cursor);
+    const enabledCount = Array.from(this.availableTools.keys()).filter((name) => this.enabledToolNames.has(name)).length;
+    logger7.debug(`Discovered ${totalDiscovered} tools, ${enabledCount} enabled by integrations`);
+  }
+  async _callToolByName(name, args, options) {
+    return await this.callToolWithRetry(name, args, 0, options);
+  }
+  async callServerTool(name, args) {
+    try {
+      const response = await this.callToolThroughHandler(name, args);
+      return response;
+    } catch (error) {
+      const parsedError = parseServerError(error, { toolName: name });
+      throw parsedError;
+    }
+  }
+  async callToolThroughHandler(name, args, provider, options) {
+    const transportHeaders = this.transport.headers || {};
+    const hasApiKey = !!transportHeaders["X-API-KEY"];
+    if (hasApiKey) {
+      await this.ensureConnected();
+      if (provider) {
+        const tokenData = await this.oauthManager.getProviderToken(provider, undefined, options?.context);
+        if (tokenData && this.transport.setHeader) {
+          const previousAuthHeader = transportHeaders["Authorization"];
+          try {
+            this.transport.setHeader("Authorization", `Bearer ${tokenData.accessToken}`);
+            const result3 = await this.transport.sendRequest("tools/call", {
+              name,
+              arguments: args || {}
+            });
+            return result3;
+          } finally {
+            if (previousAuthHeader && this.transport.setHeader) {
+              this.transport.setHeader("Authorization", previousAuthHeader);
+            } else if (this.transport.removeHeader) {
+              this.transport.removeHeader("Authorization");
+            }
+          }
+        }
+      }
+      const result2 = await this.transport.sendRequest("tools/call", {
+        name,
+        arguments: args || {}
+      });
+      return result2;
+    }
+    const url = this.apiBaseUrl ? `${this.apiBaseUrl}${this.apiRouteBase}/mcp` : `${this.apiRouteBase}/mcp`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const integrationsHeader = this.getIntegrationHeaderValue();
+    if (integrationsHeader) {
+      headers["X-Integrations"] = integrationsHeader;
+    }
+    if (provider) {
+      const tokenData = await this.oauthManager.getProviderToken(provider, undefined, options?.context);
+      if (tokenData) {
+        headers["Authorization"] = `Bearer ${tokenData.accessToken}`;
+      }
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        name,
+        arguments: args
+      })
+    });
+    if (!this.databaseDetected && response.headers.get("X-Integrate-Use-Database") === "true") {
+      this.oauthManager.setSkipLocalStorage(true);
+      this.databaseDetected = true;
+    }
+    if (!response.ok) {
+      let errorMessage = `Request failed: ${response.statusText}`;
+      const error = new Error(errorMessage);
+      error.statusCode = response.status;
+      try {
+        const errorData = await response.json();
+        if (errorData.error) {
+          errorMessage = typeof errorData.error === "string" ? errorData.error : errorData.error.message || errorMessage;
+          error.message = errorMessage;
+        }
+        if (errorData.code) {
+          error.code = errorData.code;
+        }
+        if (errorData.data) {
+          error.data = errorData.data;
+        }
+        if (errorData.error && typeof errorData.error === "object") {
+          error.jsonrpcError = errorData.error;
+        }
+      } catch {}
+      throw error;
+    }
+    const result = await response.json();
+    return result;
+  }
+  async callToolWithRetry(name, args, retryCount = 0, options) {
+    if (!this.enabledToolNames.has(name)) {
+      throw new Error(`Tool "${name}" is not enabled. Enable it by adding the appropriate integration.`);
+    }
+    const provider = this.getProviderForTool(name);
+    try {
+      const response = await this.callToolThroughHandler(name, args, provider, options);
+      if (provider) {
+        this.authState.set(provider, { authenticated: true });
+      }
+      return response;
+    } catch (error) {
+      const parsedError = parseServerError(error, { toolName: name, provider });
+      if (isAuthError(parsedError) && retryCount < this.maxReauthRetries) {
+        if (provider) {
+          this.authState.set(provider, {
+            authenticated: false,
+            lastError: parsedError
+          });
+        }
+        if (this.onReauthRequired && provider) {
+          const reauthSuccess = await this.onReauthRequired({
+            provider,
+            error: parsedError,
+            toolName: name
+          });
+          if (reauthSuccess) {
+            return await this.callToolWithRetry(name, args, retryCount + 1);
+          }
+        }
+      }
+      throw parsedError;
+    }
+  }
+  getProviderForTool(toolName) {
+    for (const integration of this.integrations) {
+      if (integration.tools.includes(toolName) && integration.oauth) {
+        return integration.oauth.provider;
+      }
+    }
+    return;
+  }
+  getTool(name) {
+    return this.availableTools.get(name);
+  }
+  getAvailableTools() {
+    return Array.from(this.availableTools.values());
+  }
+  setRequestHeader(key, value) {
+    this.transport.setHeader(key, value);
+  }
+  getEnabledTools() {
+    return Array.from(this.availableTools.values()).filter((tool) => this.enabledToolNames.has(tool.name));
+  }
+  async getEnabledToolsAsync() {
+    if (this.isConnected() && this.availableTools.size > 0) {
+      return this.getEnabledTools();
+    }
+    if (this.availableTools.size > 0) {
+      return this.getEnabledTools();
+    }
+    const tools = [];
+    const integrationIds = new Set;
+    for (const integration of this.integrations) {
+      integrationIds.add(integration.id);
+    }
+    const { parallelWithLimit: parallelWithLimit2 } = await Promise.resolve().then(() => exports_concurrency);
+    const integrationToolsResults = await parallelWithLimit2(Array.from(integrationIds), async (integrationId) => {
+      try {
+        const response = await this.callServerToolInternal("list_tools_by_integration", {
+          integration: integrationId
+        });
+        const integrationTools = [];
+        if (response.content && Array.isArray(response.content)) {
+          for (const item of response.content) {
+            if (item.type === "text" && item.text) {
+              try {
+                const parsed = JSON.parse(item.text);
+                if (Array.isArray(parsed)) {
+                  for (const tool of parsed) {
+                    if (tool.name && tool.inputSchema) {
+                      integrationTools.push({
+                        name: tool.name,
+                        description: tool.description,
+                        inputSchema: tool.inputSchema
+                      });
+                    }
+                  }
+                } else if (parsed.tools && Array.isArray(parsed.tools)) {
+                  for (const tool of parsed.tools) {
+                    if (tool.name && tool.inputSchema) {
+                      integrationTools.push({
+                        name: tool.name,
+                        description: tool.description,
+                        inputSchema: tool.inputSchema
+                      });
+                    }
+                  }
+                }
+              } catch {}
+            }
+          }
+        }
+        return integrationTools;
+      } catch (error) {
+        logger7.error(`Failed to fetch tools for integration ${integrationId}:`, error);
+        return [];
+      }
+    }, 3);
+    for (const integrationTools of integrationToolsResults) {
+      tools.push(...integrationTools);
+    }
+    for (const tool of tools) {
+      this.availableTools.set(tool.name, tool);
+    }
+    return tools.filter((tool) => this.enabledToolNames.has(tool.name));
+  }
+  getOAuthConfig(integrationId) {
+    const integration = this.integrations.find((p) => p.id === integrationId);
+    return integration?.oauth;
+  }
+  getAllOAuthConfigs() {
+    const configs = new Map;
+    for (const integration of this.integrations) {
+      if (integration.oauth) {
+        configs.set(integration.id, integration.oauth);
+      }
+    }
+    return configs;
+  }
+  onMessage(handler) {
+    return this.transport.onMessage(handler);
+  }
+  on(event, handler) {
+    this.eventEmitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.eventEmitter.off(event, handler);
+  }
+  clearSessionToken() {
+    this.oauthManager.clearAllProviderTokens();
+    for (const integration of this.integrations) {
+      if (integration.oauth) {
+        const provider = integration.oauth.provider;
+        this.authState.set(provider, { authenticated: false });
+      }
+    }
+  }
+  async disconnectProvider(provider, 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.disconnectProvider(provider, context);
+      this.authState.set(provider, { authenticated: false });
+      this.eventEmitter.emit("auth:disconnect", { provider });
+    } catch (error) {
+      this.eventEmitter.emit("auth:error", {
+        provider,
+        error
+      });
+      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();
+    this.authState.clear();
+    for (const integration of this.integrations) {
+      if (integration.oauth) {
+        this.authState.set(integration.oauth.provider, { authenticated: false });
+      }
+    }
+    this.eventEmitter.emit("auth:logout", {});
+  }
+  async disconnect() {
+    for (const integration of this.integrations) {
+      if (integration.onDisconnect) {
+        await integration.onDisconnect(this);
+      }
+    }
+    await this.transport.disconnect();
+    this.initialized = false;
+  }
+  isConnected() {
+    return this.transport.isConnected();
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  getAuthState(provider) {
+    return this.authState.get(provider);
+  }
+  isProviderAuthenticated(provider) {
+    return this.authState.get(provider)?.authenticated ?? false;
+  }
+  async isAuthorized(provider, email, context) {
+    if (this.oauthCallbackPromise) {
+      await this.oauthCallbackPromise;
+      this.oauthCallbackPromise = null;
+    }
+    try {
+      const tokenData = await this.oauthManager.getProviderToken(provider, email, context);
+      const isAuthenticated = !!tokenData;
+      const currentState = this.authState.get(provider);
+      if (currentState) {
+        currentState.authenticated = isAuthenticated;
+        if (isAuthenticated) {
+          currentState.lastError = undefined;
+        }
+      } else {
+        this.authState.set(provider, { authenticated: isAuthenticated });
+      }
+      return isAuthenticated;
+    } catch (error) {
+      const currentState = this.authState.get(provider);
+      if (currentState) {
+        currentState.authenticated = false;
+      } else {
+        this.authState.set(provider, { authenticated: false });
+      }
+      return false;
+    }
+  }
+  async authorizedProviders() {
+    if (this.oauthCallbackPromise) {
+      await this.oauthCallbackPromise;
+      this.oauthCallbackPromise = null;
+    }
+    const authorized = [];
+    for (const integration of this.integrations) {
+      if (integration.oauth) {
+        const provider = integration.oauth.provider;
+        if (this.authState.get(provider)?.authenticated) {
+          authorized.push(provider);
+        }
+      }
+    }
+    return authorized;
+  }
+  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);
+    if (!integration?.oauth) {
+      const error = new Error(`No OAuth configuration found for provider: ${provider}`);
+      this.eventEmitter.emit("auth:error", { provider, error });
+      throw error;
+    }
+    if (options?.useExistingConnection) {
+      const authStatus = await this.oauthManager.checkAuthStatus(provider);
+      if (authStatus.authorized) {
+        const tokenData = await this.oauthManager.getProviderToken(provider);
+        if (tokenData) {
+          this.eventEmitter.emit("auth:complete", {
+            provider,
+            accessToken: tokenData.accessToken,
+            expiresAt: tokenData.expiresAt
+          });
+          this.authState.set(provider, { authenticated: true });
+        }
+        return;
+      }
+    }
+    this.eventEmitter.emit("auth:started", { provider });
+    try {
+      await this.oauthManager.initiateFlow(provider, integration.oauth, options?.returnUrl);
+      const tokenData = await this.oauthManager.getProviderToken(provider);
+      if (tokenData) {
+        this.eventEmitter.emit("auth:complete", {
+          provider,
+          accessToken: tokenData.accessToken,
+          expiresAt: tokenData.expiresAt
+        });
+      }
+      this.authState.set(provider, { authenticated: true });
+    } catch (error) {
+      this.eventEmitter.emit("auth:error", { provider, error });
+      throw error;
+    }
+  }
+  async handleOAuthCallback(params) {
+    try {
+      const result = params.tokenData ? await this.oauthManager.handleCallbackWithToken(params.code, params.state, params.tokenData) : await this.oauthManager.handleCallback(params.code, params.state);
+      this.authState.set(result.provider, { authenticated: true });
+      this.eventEmitter.emit("auth:complete", {
+        provider: result.provider,
+        accessToken: result.accessToken,
+        expiresAt: result.expiresAt
+      });
+    } catch (error) {
+      this.eventEmitter.emit("auth:error", {
+        provider: "unknown",
+        error
+      });
+      throw error;
+    }
+  }
+  async getProviderToken(provider, email, context) {
+    return await this.oauthManager.getProviderToken(provider, email, 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 {
+      this.authState.set(provider, { authenticated: true });
+    }
+  }
+  getAllProviderTokens() {
+    const tokens = {};
+    const allTokens = this.oauthManager.getAllProviderTokens();
+    for (const [provider, tokenData] of allTokens.entries()) {
+      tokens[provider] = tokenData.accessToken;
+    }
+    return tokens;
+  }
+  async reauthenticate(provider) {
+    const state = this.authState.get(provider);
+    if (!state) {
+      throw new Error(`Provider "${provider}" not found in configured integrations`);
+    }
+    if (!this.onReauthRequired) {
+      throw new Error("No re-authentication handler configured. Set onReauthRequired in client config.");
+    }
+    const lastError = state.lastError || new (await Promise.resolve().then(() => (init_errors(), exports_errors))).AuthenticationError("Manual re-authentication requested", undefined, provider);
+    const success = await this.onReauthRequired({
+      provider,
+      error: lastError
+    });
+    if (success) {
+      this.authState.set(provider, { authenticated: true });
+    }
+    return success;
+  }
+}
+// ../server.ts
+init_logger();
+
+// ../integrations/github.ts
+init_logger();
+var logger8 = createLogger("GitHub");
+// ../integrations/gmail.ts
+init_logger();
+var logger9 = createLogger("Gmail");
+// ../integrations/notion.ts
+init_logger();
+var logger10 = createLogger("Notion");
+// ../integrations/slack.ts
+init_logger();
+var logger11 = createLogger("Slack");
+// ../integrations/linear.ts
+init_logger();
+var logger12 = createLogger("Linear");
+// ../integrations/vercel.ts
+init_logger();
+var logger13 = createLogger("Vercel");
+// ../integrations/zendesk.ts
+init_logger();
+var logger14 = createLogger("Zendesk");
+// ../integrations/stripe.ts
+init_logger();
+var logger15 = createLogger("Stripe");
+// ../integrations/gcal.ts
+init_logger();
+var logger16 = createLogger("Google Calendar");
+// ../integrations/outlook.ts
+init_logger();
+var logger17 = createLogger("Outlook");
+// ../integrations/airtable.ts
+init_logger();
+var logger18 = createLogger("Airtable");
+// ../integrations/todoist.ts
+init_logger();
+var logger19 = createLogger("Todoist");
+// ../integrations/whatsapp.ts
+init_logger();
+var logger20 = createLogger("WhatsApp");
+// ../integrations/calcom.ts
+init_logger();
+var logger21 = createLogger("Cal.com");
+// ../integrations/ramp.ts
+init_logger();
+var logger22 = createLogger("Ramp");
+// ../integrations/onedrive.ts
+init_logger();
+var logger23 = createLogger("OneDrive");
+// ../integrations/gworkspace.ts
+init_logger();
+var logger24 = createLogger("Google Workspace");
+// ../integrations/polar.ts
+init_logger();
+var logger25 = createLogger("Polar");
+// ../integrations/figma.ts
+init_logger();
+var logger26 = createLogger("Figma");
+// ../integrations/intercom.ts
+init_logger();
+var logger27 = createLogger("Intercom");
+// ../integrations/hubspot.ts
+init_logger();
+var logger28 = createLogger("HubSpot");
+// ../integrations/youtube.ts
+init_logger();
+var logger29 = createLogger("YouTube");
+// ../integrations/cursor.ts
+init_logger();
+var logger30 = createLogger("Cursor");
+// ../ai/trigger-tools.ts
+init_utils();
+
+// ../ai/vercel-ai.ts
+init_tool_builder();
+// ../ai/openai.ts
+init_tool_builder();
+
+// ../../node_modules/zod-to-json-schema/dist/esm/Options.js
+var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
+// ../../node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+// ../ai/anthropic.ts
+init_tool_builder();
+// ../ai/google.ts
+init_tool_builder();
+// ../server.ts
+var SERVER_LOG_CONTEXT3 = "server";
+var logger31 = createLogger("MCPServer", SERVER_LOG_CONTEXT3);
+var codeVerifierStorage = new Map;
+function toSolidStartHandler(clientOrHandlerOrOptions, _redirectOptions) {
+  if (clientOrHandlerOrOptions && clientOrHandlerOrOptions.handler && typeof clientOrHandlerOrOptions.handler === "function") {
+    const baseHandler = clientOrHandlerOrOptions.handler;
+    const handler2 = async (event) => {
+      return baseHandler(event.request);
+    };
+    return {
+      GET: handler2,
+      POST: handler2,
+      PATCH: handler2,
+      PUT: handler2,
+      DELETE: handler2
+    };
+  }
+  if (typeof clientOrHandlerOrOptions === "function") {
+    const baseHandler = clientOrHandlerOrOptions;
+    const handler2 = async (event) => {
+      return baseHandler(event.request);
+    };
+    return {
+      GET: handler2,
+      POST: handler2,
+      PATCH: handler2,
+      PUT: handler2,
+      DELETE: handler2
+    };
+  }
+  const options = clientOrHandlerOrOptions;
+  if (!options.providers || Object.keys(options.providers).length === 0) {
+    throw new Error("toSolidStartHandler requires either a handler function or a providers config object");
+  }
+  const { providers, serverUrl, apiKey, redirectUrl, errorRedirectUrl } = options;
+  const nextHandler = createNextOAuthHandler({
+    providers,
+    serverUrl,
+    apiKey
+  });
+  const routes = nextHandler.toNextJsHandler({
+    redirectUrl: redirectUrl || "/",
+    errorRedirectUrl: errorRedirectUrl || "/auth-error"
+  });
+  const handler = async (event) => {
+    const method = event.request.method.toUpperCase();
+    const url = new URL(event.request.url);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    const integrateIndex = pathParts.indexOf("integrate");
+    const segments = integrateIndex >= 0 ? pathParts.slice(integrateIndex + 1) : [];
+    const context = {
+      params: segments
+    };
+    if (method === "POST") {
+      return routes.POST(event.request, { params: { all: context.params } });
+    } else if (method === "GET") {
+      return routes.GET(event.request, { params: { all: context.params } });
+    } else {
+      return Response.json({ error: `Method ${method} not allowed` }, { status: 405 });
+    }
+  };
+  return {
+    GET: handler,
+    POST: handler,
+    PATCH: handler,
+    PUT: handler,
+    DELETE: handler
+  };
+}
+function toSvelteKitHandler(clientOrHandlerOrOptions, _redirectOptions) {
+  if (clientOrHandlerOrOptions && clientOrHandlerOrOptions.handler && typeof clientOrHandlerOrOptions.handler === "function") {
+    const baseHandler = clientOrHandlerOrOptions.handler;
+    return async (event) => {
+      const all = event.params?.all;
+      return baseHandler(event.request, { params: { all } });
+    };
+  }
+  if (typeof clientOrHandlerOrOptions === "function") {
+    const baseHandler = clientOrHandlerOrOptions;
+    return async (event) => {
+      const all = event.params?.all;
+      return baseHandler(event.request, { params: { all } });
+    };
+  }
+  const options = clientOrHandlerOrOptions;
+  if (!options.providers || Object.keys(options.providers).length === 0) {
+    throw new Error("toSvelteKitHandler requires either a handler function or a providers config object");
+  }
+  const { providers, serverUrl, apiKey, redirectUrl, errorRedirectUrl } = options;
+  const nextHandler = createNextOAuthHandler({
+    providers,
+    serverUrl,
+    apiKey
+  });
+  const routes = nextHandler.toNextJsHandler({
+    redirectUrl: redirectUrl || "/",
+    errorRedirectUrl: errorRedirectUrl || "/auth-error"
+  });
+  return async (event) => {
+    const method = event.request.method.toUpperCase();
+    const all = event.params?.all;
+    const context = {
+      params: Array.isArray(all) ? all : all ? all.split("/").filter(Boolean) : []
+    };
+    if (method === "POST") {
+      return routes.POST(event.request, { params: { all: context.params } });
+    } else if (method === "GET") {
+      return routes.GET(event.request, { params: { all: context.params } });
+    } else {
+      return Response.json({ error: `Method ${method} not allowed` }, { status: 405 });
+    }
+  };
+}
 export {
   toSolidStartHandler
 };