integrate-sdk 0.2.4 → 0.3.2

package/dist/server.js

@@ -0,0 +1,1481 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/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;
+    }
+  };
+});
+
+// src/protocol/jsonrpc.ts
+function parseMessage(message) {
+  try {
+    return JSON.parse(message);
+  } catch (error) {
+    throw new Error(`Failed to parse JSON-RPC message: ${error}`);
+  }
+}
+
+// src/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 };
+  }
+}
+
+// src/protocol/messages.ts
+var MCPMethod;
+((MCPMethod2) => {
+  MCPMethod2["INITIALIZE"] = "initialize";
+  MCPMethod2["TOOLS_LIST"] = "tools/list";
+  MCPMethod2["TOOLS_CALL"] = "tools/call";
+  MCPMethod2["RESOURCES_LIST"] = "resources/list";
+  MCPMethod2["RESOURCES_READ"] = "resources/read";
+  MCPMethod2["PROMPTS_LIST"] = "prompts/list";
+  MCPMethod2["PROMPTS_GET"] = "prompts/get";
+})(MCPMethod ||= {});
+
+// src/client.ts
+init_errors();
+
+// src/utils/naming.ts
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function methodToToolName(methodName, pluginId) {
+  const snakeCaseMethod = camelToSnake(methodName);
+  return `${pluginId}_${snakeCaseMethod}`;
+}
+
+// src/oauth/pkce.ts
+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 base64UrlEncode(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 base64UrlEncode(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 base64UrlEncode(array);
+}
+function base64UrlEncode(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, "");
+}
+
+// src/oauth/window-manager.ts
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+
+class OAuthWindowManager {
+  popupWindow = null;
+  popupCheckInterval = 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 = [
+      `width=${width}`,
+      `height=${height}`,
+      `left=${left}`,
+      `top=${top}`,
+      "toolbar=no",
+      "location=no",
+      "directories=no",
+      "status=no",
+      "menubar=no",
+      "scrollbars=yes",
+      "resizable=yes",
+      "copyhistory=no"
+    ].join(",");
+    this.popupWindow = window.open(url, "oauth_popup", 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);
+          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.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);
+    });
+  }
+  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);
+      const code = params.get("code");
+      const state = params.get("state");
+      const error = params.get("error");
+      const errorDescription = params.get("error_description");
+      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;
+    }
+  }
+  close() {
+    this.cleanup();
+  }
+}
+function sendCallbackToOpener(params) {
+  if (!isBrowser()) {
+    console.error("sendCallbackToOpener() can only be used in browser environments");
+    return;
+  }
+  if (!window.opener) {
+    console.error("No opener window found. This function should only be called from a popup window.");
+    return;
+  }
+  window.opener.postMessage({
+    type: "oauth_callback",
+    code: params.code,
+    state: params.state,
+    error: params.error
+  }, "*");
+  window.close();
+}
+
+// src/oauth/manager.ts
+class OAuthManager {
+  pendingAuths = new Map;
+  sessionToken;
+  windowManager;
+  flowConfig;
+  oauthApiBase;
+  constructor(oauthApiBase, flowConfig) {
+    this.oauthApiBase = oauthApiBase;
+    this.windowManager = new OAuthWindowManager;
+    this.flowConfig = {
+      mode: flowConfig?.mode || "redirect",
+      popupOptions: flowConfig?.popupOptions,
+      onAuthCallback: flowConfig?.onAuthCallback
+    };
+  }
+  async initiateFlow(provider, config) {
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = await generateCodeChallenge(codeVerifier);
+    const state = generateState();
+    const pendingAuth = {
+      provider,
+      state,
+      codeVerifier,
+      codeChallenge,
+      scopes: config.scopes,
+      redirectUri: config.redirectUri,
+      initiatedAt: Date.now()
+    };
+    this.pendingAuths.set(state, pendingAuth);
+    const authUrl = await this.getAuthorizationUrl(provider, config.scopes, 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) {
+    const pendingAuth = this.pendingAuths.get(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);
+      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);
+      this.sessionToken = response.sessionToken;
+      this.pendingAuths.delete(state);
+      return response.sessionToken;
+    } catch (error) {
+      this.pendingAuths.delete(state);
+      throw error;
+    }
+  }
+  async checkAuthStatus(provider) {
+    if (!this.sessionToken) {
+      return {
+        authorized: false,
+        provider
+      };
+    }
+    try {
+      const url = `${this.oauthApiBase}/status?provider=${encodeURIComponent(provider)}`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "X-Session-Token": this.sessionToken
+        }
+      });
+      if (!response.ok) {
+        return {
+          authorized: false,
+          provider
+        };
+      }
+      const status = await response.json();
+      return status;
+    } catch (error) {
+      console.error("Failed to check auth status:", error);
+      return {
+        authorized: false,
+        provider
+      };
+    }
+  }
+  getSessionToken() {
+    return this.sessionToken;
+  }
+  setSessionToken(token) {
+    this.sessionToken = token;
+  }
+  clearSessionToken() {
+    this.sessionToken = undefined;
+  }
+  async getAuthorizationUrl(provider, scopes, state, codeChallenge, redirectUri) {
+    const url = `${this.oauthApiBase}/authorize`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        provider,
+        scopes,
+        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.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();
+  }
+}
+
+// src/client.ts
+var MCP_SERVER_URL = "https://mcp.integrate.dev/api/v1/mcp";
+var clientCache = new Map;
+var cleanupClients = new Set;
+var cleanupHandlersRegistered = false;
+
+class MCPClient {
+  transport;
+  plugins;
+  availableTools = new Map;
+  enabledToolNames = new Set;
+  initialized = false;
+  clientInfo;
+  onReauthRequired;
+  maxReauthRetries;
+  authState = new Map;
+  connectionMode;
+  connecting = null;
+  oauthManager;
+  github;
+  gmail;
+  server;
+  constructor(config) {
+    this.transport = new HttpSessionTransport({
+      url: MCP_SERVER_URL,
+      headers: config.headers,
+      timeout: config.timeout
+    });
+    this.plugins = config.plugins;
+    this.clientInfo = config.clientInfo || {
+      name: "integrate-sdk",
+      version: "0.1.0"
+    };
+    this.onReauthRequired = config.onReauthRequired;
+    this.maxReauthRetries = config.maxReauthRetries ?? 1;
+    this.connectionMode = config.connectionMode ?? "lazy";
+    this.oauthManager = new OAuthManager(config.oauthApiBase || "/api/integrate/oauth", config.oauthFlow);
+    if (config.sessionToken) {
+      this.oauthManager.setSessionToken(config.sessionToken);
+      this.transport.setHeader("X-Session-Token", config.sessionToken);
+    }
+    for (const plugin of this.plugins) {
+      for (const toolName of plugin.tools) {
+        this.enabledToolNames.add(toolName);
+      }
+      if (plugin.oauth) {
+        this.authState.set(plugin.oauth.provider, { authenticated: true });
+      }
+    }
+    this.github = this.createPluginProxy("github");
+    this.gmail = this.createPluginProxy("gmail");
+    this.server = this.createServerProxy();
+    this.initializePlugins();
+  }
+  async ensureConnected() {
+    if (this.initialized && this.transport.isConnected()) {
+      return;
+    }
+    if (this.connecting) {
+      return this.connecting;
+    }
+    if (this.connectionMode === "manual" && !this.initialized) {
+      throw new Error("Client not connected. Call connect() first when using manual connection mode.");
+    }
+    this.connecting = this.connect();
+    try {
+      await this.connecting;
+    } finally {
+      this.connecting = null;
+    }
+  }
+  createPluginProxy(pluginId) {
+    return new Proxy({}, {
+      get: (_target, methodName) => {
+        return async (args) => {
+          await this.ensureConnected();
+          const toolName = methodToToolName(methodName, pluginId);
+          return await this.callToolWithRetry(toolName, args, 0);
+        };
+      }
+    });
+  }
+  createServerProxy() {
+    return new Proxy({}, {
+      get: (_target, methodName) => {
+        return async (args) => {
+          await this.ensureConnected();
+          const toolName = methodToToolName(methodName, "");
+          const finalToolName = toolName.startsWith("_") ? toolName.substring(1) : toolName;
+          return await this.callServerToolInternal(finalToolName, args);
+        };
+      }
+    });
+  }
+  async callServerToolInternal(name, args) {
+    if (!this.initialized) {
+      throw new Error("Client not initialized. Call connect() first.");
+    }
+    if (!this.availableTools.has(name)) {
+      throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
+    }
+    const params = {
+      name,
+      arguments: args
+    };
+    try {
+      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      return response;
+    } catch (error) {
+      const parsedError = parseServerError(error, { toolName: name });
+      throw parsedError;
+    }
+  }
+  async initializePlugins() {
+    for (const plugin of this.plugins) {
+      if (plugin.onInit) {
+        await plugin.onInit(this);
+      }
+    }
+  }
+  async connect() {
+    for (const plugin of this.plugins) {
+      if (plugin.onBeforeConnect) {
+        await plugin.onBeforeConnect(this);
+      }
+    }
+    await this.transport.connect();
+    await this.initialize();
+    await this.discoverTools();
+    for (const plugin of this.plugins) {
+      if (plugin.onAfterConnect) {
+        await plugin.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 plugins`);
+  }
+  async _callToolByName(name, args) {
+    return await this.callToolWithRetry(name, args, 0);
+  }
+  async callServerTool(name, args) {
+    if (!this.initialized) {
+      throw new Error("Client not initialized. Call connect() first.");
+    }
+    if (!this.availableTools.has(name)) {
+      throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
+    }
+    const params = {
+      name,
+      arguments: args
+    };
+    try {
+      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      return response;
+    } catch (error) {
+      const parsedError = parseServerError(error, { toolName: name });
+      throw parsedError;
+    }
+  }
+  async callToolWithRetry(name, args, retryCount = 0) {
+    if (!this.initialized) {
+      throw new Error("Client not initialized. Call connect() first.");
+    }
+    if (!this.enabledToolNames.has(name)) {
+      throw new Error(`Tool "${name}" is not enabled. Enable it by adding the appropriate plugin.`);
+    }
+    if (!this.availableTools.has(name)) {
+      throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
+    }
+    const params = {
+      name,
+      arguments: args
+    };
+    try {
+      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      const provider = this.getProviderForTool(name);
+      if (provider) {
+        this.authState.set(provider, { authenticated: true });
+      }
+      return response;
+    } catch (error) {
+      const provider = this.getProviderForTool(name);
+      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 plugin of this.plugins) {
+      if (plugin.tools.includes(toolName) && plugin.oauth) {
+        return plugin.oauth.provider;
+      }
+    }
+    return;
+  }
+  getTool(name) {
+    return this.availableTools.get(name);
+  }
+  getAvailableTools() {
+    return Array.from(this.availableTools.values());
+  }
+  getEnabledTools() {
+    return Array.from(this.availableTools.values()).filter((tool) => this.enabledToolNames.has(tool.name));
+  }
+  getOAuthConfig(pluginId) {
+    const plugin = this.plugins.find((p) => p.id === pluginId);
+    return plugin?.oauth;
+  }
+  getAllOAuthConfigs() {
+    const configs = new Map;
+    for (const plugin of this.plugins) {
+      if (plugin.oauth) {
+        configs.set(plugin.id, plugin.oauth);
+      }
+    }
+    return configs;
+  }
+  onMessage(handler) {
+    return this.transport.onMessage(handler);
+  }
+  async disconnect() {
+    for (const plugin of this.plugins) {
+      if (plugin.onDisconnect) {
+        await plugin.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) {
+    const status = await this.oauthManager.checkAuthStatus(provider);
+    return status.authorized;
+  }
+  async authorizedProviders() {
+    const authorized = [];
+    for (const plugin of this.plugins) {
+      if (plugin.oauth) {
+        const status = await this.oauthManager.checkAuthStatus(plugin.oauth.provider);
+        if (status.authorized) {
+          authorized.push(plugin.oauth.provider);
+        }
+      }
+    }
+    return authorized;
+  }
+  async getAuthorizationStatus(provider) {
+    return await this.oauthManager.checkAuthStatus(provider);
+  }
+  async authorize(provider) {
+    const plugin = this.plugins.find((p) => p.oauth?.provider === provider);
+    if (!plugin?.oauth) {
+      throw new Error(`No OAuth configuration found for provider: ${provider}`);
+    }
+    await this.oauthManager.initiateFlow(provider, plugin.oauth);
+    this.authState.set(provider, { authenticated: true });
+  }
+  async handleOAuthCallback(params) {
+    const sessionToken = await this.oauthManager.handleCallback(params.code, params.state);
+    this.transport.setHeader("X-Session-Token", sessionToken);
+    for (const plugin of this.plugins) {
+      if (plugin.oauth) {
+        this.authState.set(plugin.oauth.provider, { authenticated: true });
+      }
+    }
+  }
+  getSessionToken() {
+    return this.oauthManager.getSessionToken();
+  }
+  setSessionToken(token) {
+    this.oauthManager.setSessionToken(token);
+    this.transport.setHeader("X-Session-Token", token);
+  }
+  async reauthenticate(provider) {
+    const state = this.authState.get(provider);
+    if (!state) {
+      throw new Error(`Provider "${provider}" not found in configured plugins`);
+    }
+    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;
+  }
+}
+function registerCleanupHandlers() {
+  if (cleanupHandlersRegistered)
+    return;
+  cleanupHandlersRegistered = true;
+  const cleanup = async () => {
+    const clients = Array.from(cleanupClients);
+    cleanupClients.clear();
+    await Promise.all(clients.map(async (client) => {
+      try {
+        if (client.isConnected()) {
+          await client.disconnect();
+        }
+      } catch (error) {
+        console.error("Error disconnecting client:", error);
+      }
+    }));
+  };
+  if (typeof process !== "undefined") {
+    process.on("SIGINT", async () => {
+      await cleanup();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      await cleanup();
+      process.exit(0);
+    });
+    process.on("beforeExit", async () => {
+      await cleanup();
+    });
+  }
+}
+function generateCacheKey(config) {
+  const parts = [
+    config.clientInfo?.name || "integrate-sdk",
+    config.clientInfo?.version || "0.1.0",
+    JSON.stringify(config.plugins.map((p) => ({ id: p.id, tools: p.tools }))),
+    JSON.stringify(config.headers || {}),
+    config.timeout?.toString() || "30000"
+  ];
+  return parts.join("|");
+}
+function createMCPClient(config) {
+  const useSingleton = config.singleton ?? true;
+  const connectionMode = config.connectionMode ?? "lazy";
+  const autoCleanup = config.autoCleanup ?? true;
+  if (useSingleton) {
+    const cacheKey = generateCacheKey(config);
+    const existing = clientCache.get(cacheKey);
+    if (existing && existing.isConnected()) {
+      return existing;
+    }
+    if (existing) {
+      clientCache.delete(cacheKey);
+      cleanupClients.delete(existing);
+    }
+    const client = new MCPClient(config);
+    clientCache.set(cacheKey, client);
+    if (autoCleanup) {
+      cleanupClients.add(client);
+      registerCleanupHandlers();
+    }
+    if (connectionMode === "eager") {
+      client.connect().catch((error) => {
+        console.error("Failed to connect client:", error);
+      });
+    }
+    return client;
+  } else {
+    const client = new MCPClient(config);
+    if (autoCleanup) {
+      cleanupClients.add(client);
+      registerCleanupHandlers();
+    }
+    if (connectionMode === "eager") {
+      client.connect().catch((error) => {
+        console.error("Failed to connect client:", error);
+      });
+    }
+    return client;
+  }
+}
+async function clearClientCache() {
+  const clients = Array.from(clientCache.values());
+  clientCache.clear();
+  await Promise.all(clients.map(async (client) => {
+    try {
+      if (client.isConnected()) {
+        await client.disconnect();
+      }
+    } catch (error) {
+      console.error("Error disconnecting client during cache clear:", error);
+    }
+  }));
+}
+
+// src/adapters/base-handler.ts
+var MCP_SERVER_URL2 = "https://mcp.integrate.dev/api/v1/mcp";
+
+class OAuthHandler {
+  config;
+  serverUrl = MCP_SERVER_URL2;
+  constructor(config) {
+    this.config = config;
+  }
+  async handleAuthorize(request) {
+    const providerConfig = this.config.providers[request.provider];
+    if (!providerConfig) {
+      throw new Error(`Provider ${request.provider} not configured. Add OAuth credentials to your API route configuration.`);
+    }
+    if (!providerConfig.clientId || !providerConfig.clientSecret) {
+      throw new Error(`Missing OAuth credentials for ${request.provider}. Check your environment variables.`);
+    }
+    const url = new URL("/oauth/authorize", this.serverUrl);
+    url.searchParams.set("provider", request.provider);
+    url.searchParams.set("client_id", providerConfig.clientId);
+    url.searchParams.set("client_secret", providerConfig.clientSecret);
+    url.searchParams.set("scope", request.scopes.join(","));
+    url.searchParams.set("state", request.state);
+    url.searchParams.set("code_challenge", request.codeChallenge);
+    url.searchParams.set("code_challenge_method", request.codeChallengeMethod);
+    const redirectUri = request.redirectUri || providerConfig.redirectUri;
+    if (redirectUri) {
+      url.searchParams.set("redirect_uri", redirectUri);
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET"
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to generate authorization URL: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async handleCallback(request) {
+    const url = new URL("/oauth/callback", this.serverUrl);
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        provider: request.provider,
+        code: request.code,
+        code_verifier: request.codeVerifier,
+        state: request.state
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to exchange authorization code: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async handleStatus(provider, sessionToken) {
+    const url = new URL("/oauth/status", this.serverUrl);
+    url.searchParams.set("provider", provider);
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "X-Session-Token": sessionToken
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 401) {
+        return {
+          authorized: false,
+          provider
+        };
+      }
+      const error = await response.text();
+      throw new Error(`MCP server failed to check authorization status: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+}
+
+// src/adapters/auto-routes.ts
+var globalOAuthConfig = null;
+function setGlobalOAuthConfig(config) {
+  globalOAuthConfig = config;
+}
+async function POST(req, context) {
+  if (!globalOAuthConfig) {
+    throw new Error("OAuth configuration not found. Did you configure oauthProviders in createMCPClient?");
+  }
+  const handler = new OAuthHandler(globalOAuthConfig);
+  const action = context?.params?.action;
+  if (!action) {
+    return createErrorResponse("Missing action parameter", 400);
+  }
+  try {
+    if (action === "authorize") {
+      const body = await parseRequestBody(req);
+      const result = await handler.handleAuthorize(body);
+      return createSuccessResponse(result);
+    }
+    if (action === "callback") {
+      const body = await parseRequestBody(req);
+      const result = await handler.handleCallback(body);
+      return createSuccessResponse(result);
+    }
+    return createErrorResponse(`Unknown action: ${action}`, 404);
+  } catch (error) {
+    console.error(`[OAuth ${action}] Error:`, error);
+    return createErrorResponse(error.message, 500);
+  }
+}
+async function GET(req, context) {
+  if (!globalOAuthConfig) {
+    throw new Error("OAuth configuration not found. Did you configure oauthProviders in createMCPClient?");
+  }
+  const handler = new OAuthHandler(globalOAuthConfig);
+  const action = context?.params?.action;
+  if (!action) {
+    return createErrorResponse("Missing action parameter", 400);
+  }
+  try {
+    if (action === "status") {
+      const { provider, sessionToken } = parseQueryParams(req);
+      if (!provider || !sessionToken) {
+        return createErrorResponse("Missing provider or session token", 400);
+      }
+      const result = await handler.handleStatus(provider, sessionToken);
+      return createSuccessResponse(result);
+    }
+    return createErrorResponse(`Unknown action: ${action}`, 404);
+  } catch (error) {
+    console.error(`[OAuth ${action}] Error:`, error);
+    return createErrorResponse(error.message, 500);
+  }
+}
+async function parseRequestBody(req) {
+  if (typeof req.json === "function") {
+    return await req.json();
+  }
+  throw new Error("Unable to parse request body");
+}
+function parseQueryParams(req) {
+  let url;
+  if (req.nextUrl) {
+    url = new URL(req.nextUrl);
+  } else if (req.url) {
+    url = new URL(req.url);
+  } else {
+    return {};
+  }
+  const provider = url.searchParams.get("provider") || undefined;
+  const sessionToken = req.headers?.get?.("x-session-token") || undefined;
+  return { provider, sessionToken };
+}
+function createSuccessResponse(data) {
+  if (typeof globalThis.NextResponse !== "undefined") {
+    const NextResponse = globalThis.NextResponse;
+    return NextResponse.json(data);
+  }
+  return new Response(JSON.stringify(data), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function createErrorResponse(message, status) {
+  if (typeof globalThis.NextResponse !== "undefined") {
+    const NextResponse = globalThis.NextResponse;
+    return NextResponse.json({ error: message }, { status });
+  }
+  return new Response(JSON.stringify({ error: message }), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+// src/plugins/github.ts
+var GITHUB_TOOLS = [
+  "github_create_issue",
+  "github_list_issues",
+  "github_get_issue",
+  "github_update_issue",
+  "github_close_issue",
+  "github_create_pull_request",
+  "github_list_pull_requests",
+  "github_get_pull_request",
+  "github_merge_pull_request",
+  "github_list_repos",
+  "github_list_own_repos",
+  "github_get_repo",
+  "github_create_repo",
+  "github_list_branches",
+  "github_create_branch",
+  "github_get_user",
+  "github_list_commits",
+  "github_get_commit"
+];
+function githubPlugin(config) {
+  const oauth = {
+    provider: "github",
+    clientId: config.clientId,
+    clientSecret: config.clientSecret,
+    scopes: config.scopes || ["repo", "user"],
+    redirectUri: config.redirectUri,
+    config: {
+      apiBaseUrl: config.apiBaseUrl || "https://api.github.com",
+      ...config
+    }
+  };
+  return {
+    id: "github",
+    tools: [...GITHUB_TOOLS],
+    oauth,
+    async onInit(_client) {
+      console.log("GitHub plugin initialized");
+    },
+    async onAfterConnect(_client) {
+      console.log("GitHub plugin connected");
+    }
+  };
+}
+// src/plugins/gmail.ts
+var GMAIL_TOOLS = [
+  "gmail_send_message",
+  "gmail_list_messages",
+  "gmail_get_message",
+  "gmail_search_messages"
+];
+function gmailPlugin(config) {
+  const oauth = {
+    provider: "google",
+    clientId: config.clientId,
+    clientSecret: config.clientSecret,
+    scopes: config.scopes || [
+      "https://www.googleapis.com/auth/gmail.send",
+      "https://www.googleapis.com/auth/gmail.readonly",
+      "https://www.googleapis.com/auth/gmail.modify",
+      "https://www.googleapis.com/auth/gmail.labels"
+    ],
+    redirectUri: config.redirectUri,
+    config
+  };
+  return {
+    id: "gmail",
+    tools: [...GMAIL_TOOLS],
+    oauth,
+    async onInit(_client) {
+      console.log("Gmail plugin initialized");
+    },
+    async onAfterConnect(_client) {
+      console.log("Gmail plugin connected");
+    }
+  };
+}
+// src/plugins/generic.ts
+function genericOAuthPlugin(config) {
+  const oauth = {
+    provider: config.provider,
+    clientId: config.clientId,
+    clientSecret: config.clientSecret,
+    scopes: config.scopes,
+    redirectUri: config.redirectUri,
+    config
+  };
+  return {
+    id: config.id,
+    tools: config.tools,
+    oauth,
+    onInit: config.onInit,
+    onAfterConnect: config.onAfterConnect,
+    onDisconnect: config.onDisconnect
+  };
+}
+function createSimplePlugin(config) {
+  return {
+    id: config.id,
+    tools: config.tools,
+    onInit: config.onInit,
+    onAfterConnect: config.onAfterConnect,
+    onDisconnect: config.onDisconnect
+  };
+}
+
+// src/server.ts
+function createMCPServer(config) {
+  if (typeof window !== "undefined") {
+    throw new Error("createMCPServer() should only be called on the server-side. " + "Use createMCPClient() for client-side code.");
+  }
+  const providers = {};
+  for (const plugin of config.plugins) {
+    if (plugin.oauth) {
+      const { clientId, clientSecret, redirectUri } = plugin.oauth;
+      if (!clientId || !clientSecret) {
+        console.warn(`Warning: Plugin "${plugin.id}" is missing OAuth credentials. ` + `Provide clientId and clientSecret in the plugin configuration.`);
+        continue;
+      }
+      providers[plugin.id] = {
+        clientId,
+        clientSecret,
+        redirectUri
+      };
+    }
+  }
+  if (Object.keys(providers).length > 0) {
+    setGlobalOAuthConfig({ providers });
+  }
+  const client = new MCPClient(config);
+  return {
+    client,
+    handlers: {
+      info: "To use OAuth handlers, create a route file and add: export * from 'integrate-sdk/oauth'"
+    }
+  };
+}
+export {
+  gmailPlugin,
+  githubPlugin,
+  genericOAuthPlugin,
+  createSimplePlugin,
+  createMCPServer
+};