integrate-sdk 0.8.4 → 0.8.7

package/dist/adapters/solid-start.js

@@ -1,4 +1,20 @@
+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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -9,6 +25,7 @@ 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 = {};
@@ -151,2358 +168,6 @@ 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;
-
-// 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;
-  }
-  getHeaders(additionalHeaders) {
-    const headers = {
-      ...additionalHeaders
-    };
-    if (this.apiKey) {
-      headers["X-API-KEY"] = this.apiKey;
-    }
-    return headers;
-  }
-  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(","));
-    }
-    url.searchParams.set("state", authorizeRequest.state);
-    url.searchParams.set("code_challenge", authorizeRequest.codeChallenge);
-    url.searchParams.set("code_challenge_method", authorizeRequest.codeChallengeMethod);
-    const redirectUri = authorizeRequest.redirectUri || providerConfig.redirectUri;
-    if (redirectUri) {
-      url.searchParams.set("redirect_uri", redirectUri);
-    }
-    if (providerConfig.config) {
-      for (const [key, value] of Object.entries(providerConfig.config)) {
-        if (value !== undefined && value !== null) {
-          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 (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) {
-        console.warn("[OAuth] Failed to capture user context:", 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) {
-        console.warn("[OAuth] Failed to restore user context:", 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
-        };
-        await this.config.setProviderToken(callbackRequest.provider, tokenData, context);
-      } catch (error) {
-        console.error("[OAuth] Failed to save provider token:", 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, context);
-          } catch (error) {
-            console.error(`Failed to delete token for ${request.provider} from database via removeProviderToken:`, error);
-          }
-        }
-      } catch (error) {
-        console.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 handleToolCall(request, authHeader) {
-    const url = this.serverUrl;
-    const headers = this.getHeaders({
-      "Content-Type": "application/json"
-    });
-    if (authHeader && authHeader.startsWith("Bearer ")) {
-      headers["Authorization"] = authHeader;
-    }
-    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 MCP_SERVER_URL = "https://mcp.integrate.dev/api/v1/mcp";
-
-// ../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;
-    }
-  };
-});
-
-// nextjs.ts
-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);
-        }
-        return response;
-      } catch (error) {
-        console.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);
-        }
-        return response;
-      } catch (error) {
-        console.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);
-        return Response.json(result);
-      } catch (error) {
-        console.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);
-        return Response.json(result);
-      } catch (error) {
-        console.error("[OAuth Disconnect] Error:", error);
-        return Response.json({ error: error.message || "Failed to disconnect provider" }, { 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 === "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 result = await handler.handleToolCall(body, authHeader);
-        return Response.json(result);
-      } catch (error) {
-        console.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);
-            }
-            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;
-                console.error("[OAuth Redirect] Error:", errorMsg);
-                return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent(errorMsg)}`, req.url));
-              }
-              if (!code || !state) {
-                console.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 });
-          }
-          return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
-        }
-      };
-    }
-  };
-  return handlers;
-}
-
-// ../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
-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;
-          console.log("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;
-      }
-      console.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;
-      }
-      console.error("SSE stream error:", error);
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  handleNotification(data) {
-    try {
-      const message = parseMessage(data);
-      this.messageHandlers.forEach((handler) => {
-        try {
-          handler(message);
-        } catch (error) {
-          console.error("Error in message handler:", error);
-        }
-      });
-    } catch (error) {
-      console.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();
-
-// ../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}`;
-}
-// ../oauth/window-manager.ts
-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) {
-      console.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");
-    }
-    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) {
-          console.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) {
-          console.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/manager.ts
-class OAuthManager {
-  pendingAuths = new Map;
-  providerTokens = new Map;
-  windowManager;
-  flowConfig;
-  oauthApiBase;
-  apiBaseUrl;
-  getTokenCallback;
-  setTokenCallback;
-  removeTokenCallback;
-  skipLocalStorage;
-  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.skipLocalStorage = tokenCallbacks?.skipLocalStorage ?? !!tokenCallbacks?.getProviderToken;
-    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);
-    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 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) {
-        console.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
-      };
-      this.providerTokens.set(pendingAuth.provider, tokenData);
-      await this.saveProviderToken(pendingAuth.provider, tokenData);
-      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) {
-    const tokenData = await this.getProviderToken(provider);
-    if (!tokenData) {
-      return {
-        authorized: false,
-        provider
-      };
-    }
-    return {
-      authorized: true,
-      provider,
-      scopes: tokenData.scopes,
-      expiresAt: tokenData.expiresAt
-    };
-  }
-  async disconnectProvider(provider, context) {
-    if (this.removeTokenCallback) {
-      try {
-        await this.removeTokenCallback(provider, context);
-      } catch (error) {
-        console.error(`Failed to delete token for ${provider} from database via removeProviderToken:`, error);
-      }
-    } else if (this.setTokenCallback) {
-      try {
-        const tokenData = await this.getProviderToken(provider, context);
-        if (tokenData) {
-          await this.setTokenCallback(provider, null, context);
-        }
-      } catch (error) {
-        console.error(`Failed to delete token for ${provider} from database via setProviderToken:`, error);
-      }
-    } else {
-      try {
-        const tokenData = await this.getProviderToken(provider);
-        if (tokenData?.accessToken) {
-          const url = this.apiBaseUrl ? `${this.apiBaseUrl}${this.oauthApiBase}/disconnect` : `${this.oauthApiBase}/disconnect`;
-          const response = await fetch(url, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: `Bearer ${tokenData.accessToken}`
-            },
-            body: JSON.stringify({
-              provider
-            })
-          });
-          if (!response.ok) {
-            if (response.status === 404) {
-              console.warn(`[Integrate SDK] OAuth disconnect route not found at ${url}. ` + `The route may not be set up on your server. ` + `Local token will still be cleared. ` + `To enable server-side disconnect, set up the route handler at ${this.oauthApiBase}/disconnect`);
-            } else {
-              const errorText = await response.text();
-              console.warn(`[Integrate SDK] Failed to disconnect ${provider} via API: ${response.status} ${errorText}. ` + `Local token will still be cleared.`);
-            }
-          }
-        }
-      } catch (error) {
-        const url = this.apiBaseUrl ? `${this.apiBaseUrl}${this.oauthApiBase}/disconnect` : `${this.oauthApiBase}/disconnect`;
-        if (error instanceof TypeError && error.message.includes("fetch")) {
-          console.warn(`[Integrate SDK] Could not reach disconnect route at ${url}. ` + `The route may not be set up on your server. ` + `Local token will still be cleared. ` + `To enable server-side disconnect, set up the route handler at ${this.oauthApiBase}/disconnect`);
-        } else {
-          console.warn(`[Integrate SDK] Failed to disconnect ${provider} via API: ${error}. ` + `Local token will still be cleared.`);
-        }
-      }
-    }
-    this.providerTokens.delete(provider);
-    this.clearProviderToken(provider);
-  }
-  async getProviderToken(provider, context) {
-    if (this.getTokenCallback) {
-      try {
-        const tokenData = await this.getTokenCallback(provider, context);
-        if (tokenData) {
-          this.providerTokens.set(provider, tokenData);
-        }
-        return tokenData;
-      } catch (error) {
-        console.error(`Failed to get token for ${provider} via callback:`, error);
-        return;
-      }
-    }
-    return this.providerTokens.get(provider);
-  }
-  getAllProviderTokens() {
-    return new Map(this.providerTokens);
-  }
-  getProviderTokenFromCache(provider) {
-    return this.providerTokens.get(provider);
-  }
-  async setProviderToken(provider, tokenData, context) {
-    if (tokenData === null) {
-      this.providerTokens.delete(provider);
-    } else {
-      this.providerTokens.set(provider, tokenData);
-    }
-    await this.saveProviderToken(provider, tokenData, context);
-  }
-  clearProviderToken(provider) {
-    this.providerTokens.delete(provider);
-    if (!this.skipLocalStorage && typeof window !== "undefined" && window.localStorage) {
-      try {
-        window.localStorage.removeItem(`integrate_token_${provider}`);
-      } catch (error) {
-        console.error(`Failed to clear token for ${provider} from localStorage:`, error);
-      }
-    }
-  }
-  clearAllProviderTokens() {
-    const providers = Array.from(this.providerTokens.keys());
-    this.providerTokens.clear();
-    if (!this.skipLocalStorage && typeof window !== "undefined" && window.localStorage) {
-      for (const provider of providers) {
-        try {
-          window.localStorage.removeItem(`integrate_token_${provider}`);
-        } catch (error) {
-          console.error(`Failed to clear token for ${provider} from localStorage:`, 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) {
-        console.error("Failed to clear pending auths from localStorage:", error);
-      }
-    }
-  }
-  async saveProviderToken(provider, tokenData, context) {
-    if (this.setTokenCallback) {
-      try {
-        await this.setTokenCallback(provider, tokenData, context);
-      } catch (error) {
-        console.error(`Failed to ${tokenData === null ? "delete" : "save"} token for ${provider} via callback:`, error);
-        throw error;
-      }
-      return;
-    }
-    if (tokenData === null) {
-      this.clearProviderToken(provider);
-      return;
-    }
-    if (this.skipLocalStorage) {
-      return;
-    }
-    if (typeof window !== "undefined" && window.localStorage) {
-      try {
-        const key = `integrate_token_${provider}`;
-        window.localStorage.setItem(key, JSON.stringify(tokenData));
-      } catch (error) {
-        console.error(`Failed to save token for ${provider} to localStorage:`, error);
-      }
-    }
-  }
-  async loadProviderToken(provider) {
-    if (this.getTokenCallback) {
-      try {
-        return await this.getTokenCallback(provider);
-      } catch (error) {
-        console.error(`Failed to load token for ${provider} via callback:`, error);
-        return;
-      }
-    }
-    if (typeof window !== "undefined" && window.localStorage) {
-      try {
-        const key = `integrate_token_${provider}`;
-        const stored = window.localStorage.getItem(key);
-        if (stored) {
-          return JSON.parse(stored);
-        }
-      } catch (error) {
-        console.error(`Failed to load token for ${provider} from localStorage:`, error);
-      }
-    }
-    return;
-  }
-  async loadAllProviderTokens(providers) {
-    for (const provider of providers) {
-      const tokenData = await this.loadProviderToken(provider);
-      if (tokenData) {
-        this.providerTokens.set(provider, tokenData);
-      }
-    }
-  }
-  loadProviderTokenSync(provider) {
-    if (this.getTokenCallback) {
-      return;
-    }
-    if (typeof window !== "undefined" && window.localStorage) {
-      try {
-        const key = `integrate_token_${provider}`;
-        const stored = window.localStorage.getItem(key);
-        if (stored) {
-          return JSON.parse(stored);
-        }
-      } catch (error) {
-        console.error(`Failed to load token for ${provider} from localStorage:`, error);
-      }
-    }
-    return;
-  }
-  loadAllProviderTokensSync(providers) {
-    if (this.getTokenCallback) {
-      return;
-    }
-    for (const provider of providers) {
-      const tokenData = this.loadProviderTokenSync(provider);
-      if (tokenData) {
-        this.providerTokens.set(provider, tokenData);
-      }
-    }
-  }
-  savePendingAuthToStorage(state, pendingAuth) {
-    if (this.skipLocalStorage) {
-      return;
-    }
-    if (typeof window !== "undefined" && window.localStorage) {
-      try {
-        const key = `integrate_oauth_pending_${state}`;
-        window.localStorage.setItem(key, JSON.stringify(pendingAuth));
-      } catch (error) {
-        console.error("Failed to save pending auth to localStorage:", error);
-      }
-    }
-  }
-  loadPendingAuthFromStorage(state) {
-    if (this.skipLocalStorage) {
-      return;
-    }
-    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) {
-        console.error("Failed to load pending auth from localStorage:", error);
-      }
-    }
-    return;
-  }
-  removePendingAuthFromStorage(state) {
-    if (this.skipLocalStorage) {
-      return;
-    }
-    if (typeof window !== "undefined" && window.localStorage) {
-      try {
-        const key = `integrate_oauth_pending_${state}`;
-        window.localStorage.removeItem(key);
-      } catch (error) {
-        console.error("Failed to remove pending auth from localStorage:", error);
-      }
-    }
-  }
-  cleanupExpiredPendingAuths() {
-    if (this.skipLocalStorage) {
-      return;
-    }
-    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) {
-        console.error("Failed to cleanup expired pending auths:", error);
-      }
-    }
-  }
-  async getAuthorizationUrl(provider, state, codeChallenge, redirectUri) {
-    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
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to get authorization URL: ${error}`);
-    }
-    const data = await response.json();
-    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.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to exchange code for token: ${error}`);
-    }
-    const data = await response.json();
-    return data;
-  }
-  close() {
-    this.windowManager.close();
-  }
-}
-
-// ../client.ts
-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) {
-          console.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 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;
-  oauthCallbackPromise;
-  server;
-  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";
-    const defaultRedirectUri = this.getDefaultRedirectUri(oauthApiBase);
-    this.apiRouteBase = config.apiRouteBase || "/api/integrate";
-    this.apiBaseUrl = config.apiBaseUrl;
-    this.integrations = config.integrations.map((integration) => {
-      if (integration.oauth && !integration.oauth.redirectUri) {
-        return {
-          ...integration,
-          oauth: {
-            ...integration.oauth,
-            redirectUri: defaultRedirectUri
-          }
-        };
-      }
-      return integration;
-    });
-    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,
-      skipLocalStorage: config.skipLocalStorage
-    });
-    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 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) {
-              console.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) => {
-        console.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");
-    }
-    this.server = this.createServerProxy();
-    this.initializeIntegrations();
-  }
-  getDefaultRedirectUri(oauthApiBase) {
-    if (typeof window === "undefined" || !window.location) {
-      return "http://localhost:3000/api/integrate/oauth/callback";
-    }
-    const origin = window.location.origin;
-    const normalizedPath = oauthApiBase.replace(/\/$/, "");
-    return `${origin}${normalizedPath}/callback`;
-  }
-  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);
-        };
-      }
-    });
-  }
-  createServerProxy() {
-    return new Proxy({}, {
-      get: (_target, methodName) => {
-        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 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() {
-    const response = await this.transport.sendRequest("tools/list" /* TOOLS_LIST */);
-    for (const tool of response.tools) {
-      this.availableTools.set(tool.name, tool);
-    }
-    const enabledTools = response.tools.filter((tool) => this.enabledToolNames.has(tool.name));
-    console.log(`Discovered ${response.tools.length} tools, ${enabledTools.length} 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) {
-      if (provider) {
-        const tokenData = await this.oauthManager.getProviderToken(provider, 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"
-    };
-    if (provider) {
-      const tokenData = await this.oauthManager.getProviderToken(provider, options?.context);
-      if (tokenData) {
-        headers["Authorization"] = `Bearer ${tokenData.accessToken}`;
-      }
-    }
-    const response = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        name,
-        arguments: args
-      })
-    });
-    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));
-  }
-  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 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, context) {
-    if (this.oauthCallbackPromise) {
-      await this.oauthCallbackPromise;
-      this.oauthCallbackPromise = null;
-    }
-    try {
-      const tokenData = await this.oauthManager.getProviderToken(provider, 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) {
-    return await this.oauthManager.checkAuthStatus(provider);
-  }
-  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 = 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, context) {
-    return await this.oauthManager.getProviderToken(provider, context);
-  }
-  async setProviderToken(provider, tokenData, context) {
-    await this.oauthManager.setProviderToken(provider, tokenData, 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
-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
 };