integrate-sdk 0.6.8 → 0.7.0

package/dist/adapters/tanstack-start.js

@@ -8,6 +8,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/adapters/tanstack-start.ts
 function toTanStackStartHandler(handler) {

package/dist/index.js

@@ -1014,6 +1014,7 @@ class MCPClient {
   connecting = null;
   oauthManager;
   eventEmitter = new SimpleEventEmitter;
+  apiRouteBase;
   github;
   gmail;
   server;
@@ -1025,6 +1026,7 @@ class MCPClient {
     });
     const oauthApiBase = config.oauthApiBase || "/api/integrate/oauth";
     const defaultRedirectUri = this.getDefaultRedirectUri(oauthApiBase);
+    this.apiRouteBase = config.apiRouteBase || "/api/integrate";
     this.plugins = config.plugins.map((plugin) => {
       if (plugin.oauth && !plugin.oauth.redirectUri) {
         return {
@@ -1116,12 +1118,8 @@ class MCPClient {
     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 response = await this.callToolThroughHandler(name, args);
       return response;
     } catch (error) {
       const parsedError = parseServerError(error, { toolName: name });
@@ -1180,18 +1178,58 @@ class MCPClient {
     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 response = await this.callToolThroughHandler(name, args);
       return response;
     } catch (error) {
       const parsedError = parseServerError(error, { toolName: name });
       throw parsedError;
     }
   }
+  async callToolThroughHandler(name, args, provider) {
+    const url = `${this.apiRouteBase}/mcp`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (provider) {
+      const tokenData = this.oauthManager.getProviderToken(provider);
+      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) {
     if (!this.initialized) {
       throw new Error("Client not initialized. Call connect() first.");
@@ -1203,35 +1241,24 @@ class MCPClient {
       throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
     }
     const provider = this.getProviderForTool(name);
-    if (provider) {
-      const tokenData = this.oauthManager.getProviderToken(provider);
-      if (tokenData) {
-        this.transport.setHeader("Authorization", `Bearer ${tokenData.accessToken}`);
-      }
-    }
-    const params = {
-      name,
-      arguments: args
-    };
     try {
-      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      const response = await this.callToolThroughHandler(name, args, provider);
       if (provider) {
         this.authState.set(provider, { authenticated: true });
       }
       return response;
     } catch (error) {
-      const provider2 = this.getProviderForTool(name);
-      const parsedError = parseServerError(error, { toolName: name, provider: provider2 });
+      const parsedError = parseServerError(error, { toolName: name, provider });
       if (isAuthError(parsedError) && retryCount < this.maxReauthRetries) {
-        if (provider2) {
-          this.authState.set(provider2, {
+        if (provider) {
+          this.authState.set(provider, {
             authenticated: false,
             lastError: parsedError
           });
         }
-        if (this.onReauthRequired && provider2) {
+        if (this.onReauthRequired && provider) {
           const reauthSuccess = await this.onReauthRequired({
-            provider: provider2,
+            provider,
             error: parsedError,
             toolName: name
           });
@@ -1684,6 +1711,41 @@ class OAuthHandler {
     const data = await response.json();
     return data;
   }
+  async handleToolCall(request, authHeader) {
+    const url = new URL("/tools/call", 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.toString(), {
+      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;
+  }
 }
 // src/adapters/nextjs.ts
 function createNextOAuthHandler(config) {
@@ -1760,6 +1822,9 @@ function createNextOAuthHandler(config) {
           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) {
@@ -1772,6 +1837,17 @@ function createNextOAuthHandler(config) {
         }
       };
     },
+    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";
@@ -1792,6 +1868,9 @@ function createNextOAuthHandler(config) {
             }
             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) {
@@ -2025,64 +2104,10 @@ function toNodeHandler(config) {
     }
   };
 }
-// src/adapters/solid-start.ts
-function toSolidStartHandler(baseHandler) {
-  const handler = async (event) => {
-    return baseHandler(event.request);
-  };
-  return {
-    GET: handler,
-    POST: handler,
-    PATCH: handler,
-    PUT: handler,
-    DELETE: handler
-  };
-}
-// src/adapters/svelte-kit.ts
-async function svelteKitHandler({
-  authConfig,
-  event,
-  resolve,
-  basePath = "/api/integrate"
-}) {
-  const { url } = event;
-  const baseUrl = new URL(basePath, url.origin);
-  if (!url.pathname.startsWith(baseUrl.pathname)) {
-    return resolve(event);
-  }
-  return authConfig(event.request);
-}
-function toSvelteKitHandler(baseHandler) {
-  return async (event) => {
-    return baseHandler(event.request);
-  };
-}
-// src/adapters/tanstack-start.ts
-function toTanStackStartHandler(handler) {
-  const baseHandler = async ({ request }) => {
-    return handler(request);
-  };
-  return {
-    GET: baseHandler,
-    POST: baseHandler
-  };
-}
-var createTanStackOAuthHandler = toTanStackStartHandler;
-
-// src/index.ts
-init_errors();
-
 // src/utils/env.ts
 function getEnv(key) {
   try {
-    const getMetaEnv = () => {
-      try {
-        return typeof import.meta !== "undefined" ? import.meta.env : undefined;
-      } catch {
-        return;
-      }
-    };
-    const metaEnv = getMetaEnv();
+    const metaEnv = import.meta.env;
     if (metaEnv && typeof metaEnv === "object" && metaEnv !== null) {
       const value = metaEnv[key];
       if (value !== undefined && value !== null && value !== "") {
@@ -2206,6 +2231,320 @@ function createSimplePlugin(config) {
     onDisconnect: config.onDisconnect
   };
 }
+
+// src/server.ts
+var globalServerConfig = null;
+function getDefaultRedirectUri() {
+  if (typeof window !== "undefined") {
+    return `${window.location.origin}/api/integrate/oauth/callback`;
+  }
+  const integrateUrl = getEnv("INTEGRATE_URL");
+  if (integrateUrl) {
+    return `${integrateUrl}/api/integrate/oauth/callback`;
+  }
+  const vercelUrl = getEnv("VERCEL_URL");
+  if (vercelUrl) {
+    return `https://${vercelUrl}/api/integrate/oauth/callback`;
+  }
+  return "http://localhost:3000/api/integrate/oauth/callback";
+}
+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 = {};
+  const updatedPlugins = config.plugins.map((plugin) => {
+    if (plugin.oauth) {
+      const { clientId, clientSecret, redirectUri: pluginRedirectUri } = plugin.oauth;
+      if (!clientId || !clientSecret) {
+        console.warn(`Warning: Plugin "${plugin.id}" is missing OAuth credentials. ` + `Provide clientId and clientSecret in the plugin configuration.`);
+        return plugin;
+      }
+      const redirectUri = pluginRedirectUri || config.redirectUri || getDefaultRedirectUri();
+      providers[plugin.id] = {
+        clientId,
+        clientSecret,
+        redirectUri
+      };
+      return {
+        ...plugin,
+        oauth: {
+          ...plugin.oauth,
+          redirectUri
+        }
+      };
+    }
+    return plugin;
+  });
+  globalServerConfig = {
+    providers,
+    serverUrl: config.serverUrl,
+    apiKey: config.apiKey
+  };
+  const clientConfig = {
+    ...config,
+    plugins: updatedPlugins,
+    connectionMode: config.connectionMode || "lazy",
+    singleton: config.singleton ?? true
+  };
+  const client = new MCPClient(clientConfig);
+  if (config.apiKey) {
+    client.setRequestHeader("X-API-KEY", config.apiKey);
+  }
+  client.__oauthConfig = {
+    providers,
+    serverUrl: config.serverUrl,
+    apiKey: config.apiKey
+  };
+  const { POST, GET } = createOAuthRouteHandlers({
+    providers,
+    serverUrl: config.serverUrl,
+    apiKey: config.apiKey
+  });
+  const handler = async (request, context) => {
+    const method = request.method.toUpperCase();
+    let action;
+    let segments = [];
+    if (context?.params?.action) {
+      action = context.params.action;
+    } else if (context?.params?.all) {
+      const all = context.params.all;
+      if (Array.isArray(all)) {
+        segments = all;
+      } else if (typeof all === "string") {
+        segments = all.split("/").filter(Boolean);
+      }
+      if (segments.length === 2 && segments[0] === "oauth") {
+        action = segments[1];
+      } else if (segments.length === 1) {
+        action = segments[0];
+      } else if (segments.length > 0) {
+        action = segments[segments.length - 1];
+      }
+    } else {
+      const url = new URL(request.url);
+      const pathParts = url.pathname.split("/").filter(Boolean);
+      segments = pathParts;
+      const oauthIndex = pathParts.indexOf("oauth");
+      if (oauthIndex >= 0 && oauthIndex < pathParts.length - 1) {
+        action = pathParts[oauthIndex + 1];
+      } else if (pathParts.length > 0) {
+        action = pathParts[pathParts.length - 1];
+      } else {
+        action = "callback";
+      }
+    }
+    if (segments.length > 0) {
+      if (segments.length === 2 && segments[0] !== "oauth") {
+        return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
+      }
+      if (segments.length === 1 && segments[0] === "mcp") {}
+    }
+    if (method === "GET" && action === "callback") {
+      const url = new URL(request.url);
+      const searchParams = url.searchParams;
+      const code = searchParams.get("code");
+      const state = searchParams.get("state");
+      const error = searchParams.get("error");
+      const errorDescription = searchParams.get("error_description");
+      const defaultRedirectUrl = "/";
+      const errorRedirectUrl = "/auth-error";
+      if (error) {
+        const errorMsg = errorDescription || error;
+        console.error("[OAuth Redirect] Error:", errorMsg);
+        return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent(errorMsg)}`, request.url));
+      }
+      if (!code || !state) {
+        console.error("[OAuth Redirect] Missing code or state parameter");
+        return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, request.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 = request.headers.get("referer") || request.headers.get("referrer");
+          if (referrer) {
+            const referrerUrl = new URL(referrer);
+            const currentUrl = new URL(request.url);
+            if (referrerUrl.origin === currentUrl.origin) {
+              returnUrl = referrerUrl.pathname + referrerUrl.search;
+            }
+          }
+        } catch {}
+      }
+      const targetUrl = new URL(returnUrl, request.url);
+      targetUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state }))}`;
+      return Response.redirect(targetUrl);
+    }
+    const handlerContext = { params: { action: action || "callback" } };
+    if (method === "POST") {
+      return POST(request, handlerContext);
+    } else if (method === "GET") {
+      return GET(request, handlerContext);
+    } else {
+      return Response.json({ error: `Method ${method} not allowed` }, { status: 405 });
+    }
+  };
+  return {
+    client,
+    POST,
+    GET,
+    handler
+  };
+}
+function createOAuthRouteHandlers(config) {
+  const handler = createNextOAuthHandler(config);
+  return handler.createRoutes();
+}
+var POST = async (req, context) => {
+  if (!globalServerConfig) {
+    return Response.json({ error: "OAuth not configured. Call createMCPServer() in your server initialization file first." }, { status: 500 });
+  }
+  const handler = createNextOAuthHandler(globalServerConfig);
+  const routes = handler.createRoutes();
+  return routes.POST(req, context);
+};
+var GET = async (req, context) => {
+  if (!globalServerConfig) {
+    return Response.json({ error: "OAuth not configured. Call createMCPServer() in your server initialization file first." }, { status: 500 });
+  }
+  const handler = createNextOAuthHandler(globalServerConfig);
+  const routes = handler.createRoutes();
+  return routes.GET(req, context);
+};
+function toNextJsHandler(options) {
+  const POST2 = async (req, context) => {
+    const config = options.config || options.client?.__oauthConfig;
+    if (!config) {
+      return Response.json({ error: 'OAuth not configured. You must pass either "client" (from createMCPServer) or "config" to toNextJsHandler().' }, { status: 500 });
+    }
+    const handler = createNextOAuthHandler(config);
+    const routes = handler.toNextJsHandler({
+      redirectUrl: options.redirectUrl,
+      errorRedirectUrl: options.errorRedirectUrl
+    });
+    return routes.POST(req, context);
+  };
+  const GET2 = async (req, context) => {
+    const config = options.config || options.client?.__oauthConfig;
+    if (!config) {
+      return Response.json({ error: 'OAuth not configured. You must pass either "client" (from createMCPServer) or "config" to toNextJsHandler().' }, { status: 500 });
+    }
+    const handler = createNextOAuthHandler(config);
+    const routes = handler.toNextJsHandler({
+      redirectUrl: options.redirectUrl,
+      errorRedirectUrl: options.errorRedirectUrl
+    });
+    return routes.GET(req, context);
+  };
+  return { POST: POST2, GET: GET2 };
+}
+function toAstroHandler(baseHandler, options) {
+  const defaultRedirectUrl = options?.redirectUrl || "/";
+  const errorRedirectUrl = options?.errorRedirectUrl || "/auth-error";
+  return async (ctx) => {
+    const wrappedHandler = async (request, context) => {
+      const url = new URL(request.url);
+      const method = request.method.toUpperCase();
+      const pathParts = url.pathname.split("/").filter(Boolean);
+      const oauthIndex = pathParts.indexOf("oauth");
+      if (method === "GET" && oauthIndex >= 0 && pathParts[oauthIndex + 1] === "callback") {
+        const searchParams = url.searchParams;
+        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)}`, request.url));
+        }
+        if (!code || !state) {
+          console.error("[OAuth Redirect] Missing code or state parameter");
+          return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, request.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 = request.headers.get("referer") || request.headers.get("referrer");
+            if (referrer) {
+              const referrerUrl = new URL(referrer);
+              const currentUrl = new URL(request.url);
+              if (referrerUrl.origin === currentUrl.origin) {
+                returnUrl = referrerUrl.pathname + referrerUrl.search;
+              }
+            }
+          } catch {}
+        }
+        const targetUrl = new URL(returnUrl, request.url);
+        targetUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state }))}`;
+        return Response.redirect(targetUrl);
+      }
+      return baseHandler(request, context);
+    };
+    return wrappedHandler(ctx.request, { params: { all: ctx.params.all } });
+  };
+}
+function toSolidStartHandler(baseHandler, options) {
+  const wrappedHandler = toAstroHandler(baseHandler, options);
+  const handler = async (event) => {
+    return wrappedHandler({ request: event.request, params: {} });
+  };
+  return {
+    GET: handler,
+    POST: handler,
+    PATCH: handler,
+    PUT: handler,
+    DELETE: handler
+  };
+}
+function toSvelteKitHandler(baseHandler, options) {
+  const wrappedHandler = toAstroHandler(baseHandler, options);
+  return async (event) => {
+    const all = event.params?.all;
+    return wrappedHandler({ request: event.request, params: { all } });
+  };
+}
+// src/adapters/svelte-kit.ts
+async function svelteKitHandler({
+  authConfig,
+  event,
+  resolve,
+  basePath = "/api/integrate"
+}) {
+  const { url } = event;
+  const baseUrl = new URL(basePath, url.origin);
+  if (!url.pathname.startsWith(baseUrl.pathname)) {
+    return resolve(event);
+  }
+  return authConfig(event.request);
+}
+// src/adapters/tanstack-start.ts
+function toTanStackStartHandler(handler) {
+  const baseHandler = async ({ request }) => {
+    return handler(request);
+  };
+  return {
+    GET: baseHandler,
+    POST: baseHandler
+  };
+}
+var createTanStackOAuthHandler = toTanStackStartHandler;
+
+// src/index.ts
+init_errors();
+
 // node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {

package/dist/oauth.js

@@ -139,6 +139,41 @@ class OAuthHandler {
     const data = await response.json();
     return data;
   }
+  async handleToolCall(request, authHeader) {
+    const url = new URL("/tools/call", 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.toString(), {
+      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;
+  }
 }
 
 // src/adapters/auto-routes.ts