integrate-sdk 0.7.53 → 0.7.54

package/dist/server.js

@@ -2365,548 +2365,6 @@ function createSimpleIntegration(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 updatedIntegrations = config.integrations.map((integration) => {
-    if (integration.oauth) {
-      const { clientId, clientSecret, redirectUri: integrationRedirectUri, config: oauthConfig } = integration.oauth;
-      if (!clientId || !clientSecret) {
-        console.warn(`Warning: Integration "${integration.id}" is missing OAuth credentials. ` + `Provide clientId and clientSecret in the integration configuration.`);
-        return integration;
-      }
-      const redirectUri = integrationRedirectUri || config.redirectUri || getDefaultRedirectUri();
-      providers[integration.id] = {
-        clientId,
-        clientSecret,
-        redirectUri,
-        config: oauthConfig
-      };
-      return {
-        ...integration,
-        oauth: {
-          ...integration.oauth,
-          redirectUri
-        }
-      };
-    }
-    return integration;
-  });
-  globalServerConfig = {
-    providers,
-    serverUrl: config.serverUrl,
-    apiKey: config.apiKey
-  };
-  const clientConfig = {
-    ...config,
-    integrations: updatedIntegrations,
-    connectionMode: config.connectionMode || "lazy",
-    singleton: config.singleton ?? true
-  };
-  const client = new MCPClientBase(clientConfig);
-  if (config.apiKey) {
-    client.setRequestHeader("X-API-KEY", config.apiKey);
-  }
-  client.__oauthConfig = {
-    providers,
-    serverUrl: config.serverUrl,
-    apiKey: config.apiKey,
-    getSessionContext: config.getSessionContext,
-    setProviderToken: config.setProviderToken
-  };
-  const { POST, GET } = createOAuthRouteHandlers({
-    providers,
-    serverUrl: config.serverUrl,
-    apiKey: config.apiKey,
-    getSessionContext: config.getSessionContext,
-    setProviderToken: config.setProviderToken
-  });
-  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) {
-        if (segments[0] === "mcp") {
-          action = "mcp";
-        } else {
-          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 (action === "mcp" && method === "POST") {
-      try {
-        const body = await request.json();
-        const authHeader = request.headers.get("authorization");
-        const { OAuthHandler: OAuthHandler2 } = await Promise.resolve().then(() => exports_base_handler);
-        const oauthHandler = new OAuthHandler2({
-          providers,
-          serverUrl: config.serverUrl,
-          apiKey: config.apiKey
-        });
-        const result = await oauthHandler.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 });
-      }
-    }
-    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") {
-        return Response.json({ error: `Method ${method} not allowed for /mcp route. Use POST.` }, { status: 405 });
-      }
-    }
-    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 });
-    }
-  };
-  const serverClient = client;
-  serverClient.handler = handler;
-  serverClient.POST = POST;
-  serverClient.GET = GET;
-  return {
-    client: serverClient,
-    POST,
-    GET
-  };
-}
-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(clientOrOptions, redirectOptions) {
-  let config;
-  let redirectUrl;
-  let errorRedirectUrl;
-  if (!clientOrOptions) {
-    config = globalServerConfig;
-    redirectUrl = redirectOptions?.redirectUrl;
-    errorRedirectUrl = redirectOptions?.errorRedirectUrl;
-  } else if (clientOrOptions.__oauthConfig) {
-    config = clientOrOptions.__oauthConfig;
-    redirectUrl = redirectOptions?.redirectUrl;
-    errorRedirectUrl = redirectOptions?.errorRedirectUrl;
-  } else if (typeof clientOrOptions === "object" && clientOrOptions.providers) {
-    const options = clientOrOptions;
-    config = {
-      providers: options.providers,
-      serverUrl: options.serverUrl,
-      apiKey: options.apiKey,
-      getSessionContext: options.getSessionContext,
-      setProviderToken: options.setProviderToken
-    };
-    redirectUrl = options.redirectUrl;
-    errorRedirectUrl = options.errorRedirectUrl;
-  } else {
-    config = null;
-  }
-  if (!config) {
-    throw new Error(`toNextJsHandler requires either:
-  1. A client instance from createMCPServer()
-  2. A config object with providers property
-  3. No arguments (uses global config from createMCPServer)`);
-  }
-  const POST2 = async (req, context) => {
-    const handler = createNextOAuthHandler(config);
-    const routes = handler.toNextJsHandler({
-      redirectUrl,
-      errorRedirectUrl
-    });
-    return routes.POST(req, context);
-  };
-  const GET2 = async (req, context) => {
-    const handler = createNextOAuthHandler(config);
-    const routes = handler.toNextJsHandler({
-      redirectUrl,
-      errorRedirectUrl
-    });
-    return routes.GET(req, context);
-  };
-  return { POST: POST2, GET: GET2 };
-}
-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 });
-    }
-  };
-}
-// src/adapters/node.ts
-function fromNodeHeaders(nodeHeaders) {
-  const webHeaders = new Headers;
-  for (const [key, value] of Object.entries(nodeHeaders)) {
-    if (value !== undefined) {
-      if (Array.isArray(value)) {
-        value.forEach((v) => webHeaders.append(key, v));
-      } else {
-        webHeaders.set(key, value);
-      }
-    }
-  }
-  return webHeaders;
-}
-async function toWebRequest(req) {
-  const protocol = req.socket.encrypted ? "https" : "http";
-  const host = req.headers.host || "localhost";
-  const url = `${protocol}://${host}${req.url}`;
-  const headers = fromNodeHeaders(req.headers);
-  let body;
-  if (req.method && ["POST", "PUT", "PATCH"].includes(req.method)) {
-    body = await new Promise((resolve, reject) => {
-      let data = "";
-      req.on("data", (chunk) => data += chunk);
-      req.on("end", () => resolve(data));
-      req.on("error", reject);
-    });
-  }
-  return new Request(url, {
-    method: req.method,
-    headers,
-    body: body || undefined
-  });
-}
-async function sendWebResponse(webRes, nodeRes) {
-  nodeRes.statusCode = webRes.status;
-  webRes.headers.forEach((value, key) => {
-    nodeRes.setHeader(key, value);
-  });
-  const body = await webRes.text();
-  nodeRes.end(body);
-}
-function toNodeHandler(config) {
-  const oauthHandler = new OAuthHandler(config);
-  return async (req, res) => {
-    try {
-      const webReq = await toWebRequest(req);
-      const url = new URL(webReq.url);
-      const segments = url.pathname.split("/").filter(Boolean);
-      const action = segments[segments.length - 1];
-      let webRes;
-      if (req.method === "POST") {
-        if (action === "authorize") {
-          const result = await oauthHandler.handleAuthorize(webReq);
-          const headers = { "Content-Type": "application/json" };
-          if (result.setCookie) {
-            headers["Set-Cookie"] = result.setCookie;
-          }
-          webRes = new Response(JSON.stringify(result), {
-            status: 200,
-            headers
-          });
-        } else if (action === "callback") {
-          const result = await oauthHandler.handleCallback(webReq);
-          const headers = { "Content-Type": "application/json" };
-          if (result.clearCookie) {
-            headers["Set-Cookie"] = result.clearCookie;
-          }
-          webRes = new Response(JSON.stringify(result), {
-            status: 200,
-            headers
-          });
-        } else if (action === "disconnect") {
-          const authHeader = webReq.headers.get("authorization");
-          if (!authHeader || !authHeader.startsWith("Bearer ")) {
-            webRes = new Response(JSON.stringify({ error: "Missing or invalid Authorization header" }), {
-              status: 400,
-              headers: { "Content-Type": "application/json" }
-            });
-          } else {
-            const accessToken = authHeader.substring(7);
-            const body = await webReq.json();
-            const { provider } = body;
-            if (!provider) {
-              webRes = new Response(JSON.stringify({ error: "Missing provider in request body" }), {
-                status: 400,
-                headers: { "Content-Type": "application/json" }
-              });
-            } else {
-              const result = await oauthHandler.handleDisconnect({ provider }, accessToken);
-              webRes = new Response(JSON.stringify(result), {
-                status: 200,
-                headers: { "Content-Type": "application/json" }
-              });
-            }
-          }
-        } else {
-          webRes = new Response(JSON.stringify({ error: `Unknown action: ${action}` }), {
-            status: 404,
-            headers: { "Content-Type": "application/json" }
-          });
-        }
-      } else if (req.method === "GET" && action === "status") {
-        const provider = url.searchParams.get("provider");
-        const authHeader = webReq.headers.get("authorization");
-        if (!provider) {
-          webRes = new Response(JSON.stringify({ error: "Missing provider query parameter" }), {
-            status: 400,
-            headers: { "Content-Type": "application/json" }
-          });
-        } else if (!authHeader || !authHeader.startsWith("Bearer ")) {
-          webRes = new Response(JSON.stringify({ error: "Missing or invalid Authorization header" }), {
-            status: 400,
-            headers: { "Content-Type": "application/json" }
-          });
-        } else {
-          const accessToken = authHeader.substring(7);
-          const result = await oauthHandler.handleStatus(provider, accessToken);
-          webRes = new Response(JSON.stringify(result), {
-            status: 200,
-            headers: { "Content-Type": "application/json" }
-          });
-        }
-      } else {
-        webRes = new Response(JSON.stringify({ error: `Unknown action: ${action}` }), {
-          status: 404,
-          headers: { "Content-Type": "application/json" }
-        });
-      }
-      await sendWebResponse(webRes, res);
-    } catch (error) {
-      console.error("[OAuth Handler] Error:", error);
-      const errorRes = new Response(JSON.stringify({ error: error.message || "Internal server error" }), {
-        status: 500,
-        headers: { "Content-Type": "application/json" }
-      });
-      await sendWebResponse(errorRes, res);
-    }
-  };
-}
-// 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;
 // node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -7026,78 +6484,342 @@ function jsonSchemaToZod(schema) {
     }
     return exports_external.object({});
   }
-  if (schema.type !== "object") {
-    return exports_external.object({});
+  if (schema.type !== "object") {
+    return exports_external.object({});
+  }
+  if (schema.properties && typeof schema.properties === "object") {
+    const shape = {};
+    const required = schema.required || [];
+    for (const [key, value] of Object.entries(schema.properties)) {
+      let propSchema = jsonSchemaPropertyToZod(value);
+      if (!required.includes(key)) {
+        propSchema = propSchema.optional();
+      }
+      shape[key] = propSchema;
+    }
+    return exports_external.object(shape);
+  }
+  return exports_external.object({});
+}
+async function executeToolWithToken(client, toolName, args, options) {
+  if (options?.providerTokens) {
+    const provider = getProviderForTool(client, toolName);
+    if (provider && options.providerTokens[provider]) {
+      const oauthManager = client.oauthManager;
+      if (oauthManager && typeof oauthManager.setProviderToken === "function") {
+        const existingToken = oauthManager.getProviderToken(provider);
+        try {
+          oauthManager.setProviderToken(provider, {
+            accessToken: options.providerTokens[provider],
+            tokenType: "Bearer"
+          });
+          const result2 = await client._callToolByName(toolName, args);
+          return result2;
+        } finally {
+          if (existingToken) {
+            oauthManager.setProviderToken(provider, existingToken);
+          } else if (typeof oauthManager.removeProviderToken === "function") {
+            oauthManager.removeProviderToken(provider);
+          }
+        }
+      }
+    }
+  }
+  const result = await client._callToolByName(toolName, args);
+  return result;
+}
+async function ensureClientConnected(client) {
+  if (!client.isConnected()) {
+    await client.connect();
+  }
+}
+
+// src/ai/vercel-ai.ts
+function convertMCPToolToVercelAI(mcpTool, client, options) {
+  return {
+    description: mcpTool.description || `Execute ${mcpTool.name}`,
+    inputSchema: jsonSchemaToZod(mcpTool.inputSchema),
+    execute: async (args) => {
+      if (options?.providerTokens) {
+        return await executeToolWithToken(client, mcpTool.name, args, options);
+      }
+      return await client._callToolByName(mcpTool.name, args, options?.context ? { context: options.context } : undefined);
+    }
+  };
+}
+function convertMCPToolsToVercelAI(client, options) {
+  const mcpTools = client.getEnabledTools();
+  const vercelTools = {};
+  for (const mcpTool of mcpTools) {
+    vercelTools[mcpTool.name] = convertMCPToolToVercelAI(mcpTool, client, options);
+  }
+  return vercelTools;
+}
+async function getVercelAITools(client, options) {
+  await ensureClientConnected(client);
+  let providerTokens = options?.providerTokens;
+  if (!providerTokens) {
+    try {
+      providerTokens = await getProviderTokens();
+    } catch {}
+  }
+  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
+  return convertMCPToolsToVercelAI(client, finalOptions);
+}
+// src/ai/openai.ts
+function convertMCPToolToOpenAI(mcpTool, _client, options) {
+  const inputParams = mcpTool.inputSchema;
+  return {
+    type: "function",
+    name: mcpTool.name,
+    parameters: inputParams || null,
+    strict: options?.strict ?? null,
+    description: mcpTool.description || null
+  };
+}
+function convertMCPToolsToOpenAI(client, options) {
+  const mcpTools = client.getEnabledTools();
+  return mcpTools.map((mcpTool) => convertMCPToolToOpenAI(mcpTool, client, options));
+}
+async function executeOpenAIToolCall(client, toolCall, options) {
+  const args = JSON.parse(toolCall.arguments);
+  const result = await executeToolWithToken(client, toolCall.name, args, options);
+  return JSON.stringify(result);
+}
+async function getOpenAITools(client, options) {
+  await ensureClientConnected(client);
+  let providerTokens = options?.providerTokens;
+  if (!providerTokens) {
+    try {
+      providerTokens = await getProviderTokens();
+    } catch {}
+  }
+  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
+  return convertMCPToolsToOpenAI(client, finalOptions);
+}
+async function handleOpenAIToolCalls(client, toolCalls, options) {
+  const toolOutputs = [];
+  for (const output of toolCalls) {
+    if (output.type === "function_call") {
+      const toolCall = {
+        id: output.id ?? "",
+        name: output.name,
+        arguments: output.arguments
+      };
+      try {
+        const result = await executeOpenAIToolCall(client, toolCall, options);
+        toolOutputs.push({
+          call_id: output.call_id ?? output.id ?? "",
+          type: "function_call_output",
+          output: result,
+          status: "completed"
+        });
+      } catch (error) {
+        toolOutputs.push({
+          call_id: output.call_id ?? output.id ?? "",
+          type: "function_call_output",
+          output: error instanceof Error ? error.message : "Unknown error",
+          status: "incomplete"
+        });
+      }
+    }
+  }
+  return toolOutputs;
+}
+async function handleOpenAIResponse(client, response, options) {
+  let providerTokens = options?.providerTokens;
+  if (!providerTokens) {
+    try {
+      providerTokens = await getProviderTokens();
+    } catch {}
+  }
+  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
+  const functionCalls = response.output.filter((output) => output.type === "function_call");
+  if (functionCalls.length === 0) {
+    return response;
+  }
+  return handleOpenAIToolCalls(client, functionCalls, finalOptions);
+}
+// src/ai/anthropic.ts
+function convertMCPToolToAnthropic(mcpTool, _client, _options) {
+  return {
+    name: mcpTool.name,
+    description: mcpTool.description || `Execute ${mcpTool.name}`,
+    input_schema: mcpTool.inputSchema || {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  };
+}
+function convertMCPToolsToAnthropic(client, options) {
+  const mcpTools = client.getEnabledTools();
+  return mcpTools.map((mcpTool) => convertMCPToolToAnthropic(mcpTool, client, options));
+}
+async function executeAnthropicToolCall(client, toolUse, options) {
+  const result = await executeToolWithToken(client, toolUse.name, toolUse.input, options);
+  return JSON.stringify(result);
+}
+async function handleAnthropicToolCalls(client, messageContent, options) {
+  const toolResults = [];
+  const toolUseBlocks = messageContent.filter((block) => block.type === "tool_use" && ("id" in block) && ("name" in block) && ("input" in block));
+  for (const toolUse of toolUseBlocks) {
+    try {
+      const result = await executeAnthropicToolCall(client, toolUse, options);
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: toolUse.id,
+        content: result
+      });
+    } catch (error) {
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: toolUse.id,
+        content: JSON.stringify({
+          error: error instanceof Error ? error.message : "Unknown error"
+        })
+      });
+    }
+  }
+  return toolResults;
+}
+async function getAnthropicTools(client, options) {
+  await ensureClientConnected(client);
+  let providerTokens = options?.providerTokens;
+  if (!providerTokens) {
+    try {
+      providerTokens = await getProviderTokens();
+    } catch {}
+  }
+  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
+  return convertMCPToolsToAnthropic(client, finalOptions);
+}
+async function handleAnthropicMessage(client, message, options) {
+  let providerTokens = options?.providerTokens;
+  if (!providerTokens) {
+    try {
+      providerTokens = await getProviderTokens();
+    } catch {}
   }
-  if (schema.properties && typeof schema.properties === "object") {
-    const shape = {};
-    const required = schema.required || [];
-    for (const [key, value] of Object.entries(schema.properties)) {
-      let propSchema = jsonSchemaPropertyToZod(value);
-      if (!required.includes(key)) {
-        propSchema = propSchema.optional();
-      }
-      shape[key] = propSchema;
+  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
+  const toolResults = await handleAnthropicToolCalls(client, message.content, finalOptions);
+  if (toolResults.length === 0) {
+    return message;
+  }
+  return [
+    {
+      role: message.role,
+      content: message.content
+    },
+    {
+      role: "user",
+      content: toolResults
     }
-    return exports_external.object(shape);
+  ];
+}
+// src/ai/google.ts
+async function getGoogleType() {
+  try {
+    const dynamicImport = new Function("specifier", "return import(specifier)");
+    const packageName = "@" + "google" + "/" + "genai";
+    const googleGenAI = await dynamicImport(packageName);
+    return googleGenAI.Type;
+  } catch (error) {
+    throw new Error("The @google/genai package is required to use Google AI integration. Install it with: npm install @google/genai");
   }
-  return exports_external.object({});
 }
-async function executeToolWithToken(client, toolName, args, options) {
-  if (options?.providerTokens) {
-    const provider = getProviderForTool(client, toolName);
-    if (provider && options.providerTokens[provider]) {
-      const oauthManager = client.oauthManager;
-      if (oauthManager && typeof oauthManager.setProviderToken === "function") {
-        const existingToken = oauthManager.getProviderToken(provider);
-        try {
-          oauthManager.setProviderToken(provider, {
-            accessToken: options.providerTokens[provider],
-            tokenType: "Bearer"
-          });
-          const result2 = await client._callToolByName(toolName, args);
-          return result2;
-        } finally {
-          if (existingToken) {
-            oauthManager.setProviderToken(provider, existingToken);
-          } else if (typeof oauthManager.removeProviderToken === "function") {
-            oauthManager.removeProviderToken(provider);
-          }
-        }
+function convertJsonSchemaTypeToGoogleType(type, TypeEnum) {
+  const typeMap = {
+    string: TypeEnum.STRING,
+    number: TypeEnum.NUMBER,
+    integer: TypeEnum.INTEGER,
+    boolean: TypeEnum.BOOLEAN,
+    array: TypeEnum.ARRAY,
+    object: TypeEnum.OBJECT
+  };
+  return typeMap[type.toLowerCase()] || TypeEnum.STRING;
+}
+function convertPropertiesToSchema(properties, TypeEnum) {
+  const result = {};
+  for (const [key, value] of Object.entries(properties)) {
+    if (!value || typeof value !== "object") {
+      result[key] = value;
+      continue;
+    }
+    const schema = {
+      description: value.description,
+      enum: value.enum
+    };
+    if (value.type) {
+      schema.type = convertJsonSchemaTypeToGoogleType(value.type, TypeEnum);
+    }
+    if (value.items) {
+      schema.items = convertPropertiesToSchema({ items: value.items }, TypeEnum).items;
+    }
+    if (value.properties) {
+      schema.properties = convertPropertiesToSchema(value.properties, TypeEnum);
+    }
+    for (const [k, v] of Object.entries(value)) {
+      if (!["type", "description", "enum", "items", "properties"].includes(k)) {
+        schema[k] = v;
       }
     }
+    result[key] = schema;
   }
-  const result = await client._callToolByName(toolName, args);
   return result;
 }
-async function ensureClientConnected(client) {
-  if (!client.isConnected()) {
-    await client.connect();
+async function convertMCPToolToGoogle(mcpTool, _client, _options) {
+  const TypeEnum = await getGoogleType();
+  const properties = mcpTool.inputSchema?.properties || {};
+  const convertedProperties = convertPropertiesToSchema(properties, TypeEnum);
+  const parameters = {
+    type: TypeEnum.OBJECT,
+    description: mcpTool.description || "",
+    properties: convertedProperties
+  };
+  if (mcpTool.inputSchema?.required && mcpTool.inputSchema.required.length > 0) {
+    parameters.required = mcpTool.inputSchema.required;
   }
-}
-
-// src/ai/vercel-ai.ts
-function convertMCPToolToVercelAI(mcpTool, client, options) {
   return {
+    name: mcpTool.name,
     description: mcpTool.description || `Execute ${mcpTool.name}`,
-    inputSchema: jsonSchemaToZod(mcpTool.inputSchema),
-    execute: async (args) => {
-      if (options?.providerTokens) {
-        return await executeToolWithToken(client, mcpTool.name, args, options);
-      }
-      return await client._callToolByName(mcpTool.name, args, options?.context ? { context: options.context } : undefined);
-    }
+    parameters
   };
 }
-function convertMCPToolsToVercelAI(client, options) {
+async function convertMCPToolsToGoogle(client, options) {
   const mcpTools = client.getEnabledTools();
-  const vercelTools = {};
-  for (const mcpTool of mcpTools) {
-    vercelTools[mcpTool.name] = convertMCPToolToVercelAI(mcpTool, client, options);
+  return await Promise.all(mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, options)));
+}
+async function executeGoogleFunctionCall(client, functionCall, options) {
+  if (!functionCall?.name) {
+    throw new Error("Function call must have a name");
   }
-  return vercelTools;
+  let providerTokens = options?.providerTokens;
+  if (!providerTokens) {
+    try {
+      providerTokens = await getProviderTokens();
+    } catch {}
+  }
+  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
+  const args = functionCall.args || {};
+  const result = await executeToolWithToken(client, functionCall.name, args, finalOptions);
+  return JSON.stringify(result);
 }
-async function getVercelAITools(client, options) {
+async function executeGoogleFunctionCalls(client, functionCalls, options) {
+  if (!functionCalls || functionCalls.length === 0) {
+    return [];
+  }
+  let providerTokens = options?.providerTokens;
+  if (!providerTokens) {
+    try {
+      providerTokens = await getProviderTokens();
+    } catch {}
+  }
+  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
+  const results = await Promise.all(functionCalls.map((call) => executeGoogleFunctionCall(client, call, finalOptions)));
+  return results;
+}
+async function getGoogleTools(client, options) {
   await ensureClientConnected(client);
   let providerTokens = options?.providerTokens;
   if (!providerTokens) {
@@ -7106,29 +6828,37 @@ async function getVercelAITools(client, options) {
     } catch {}
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToVercelAI(client, finalOptions);
+  return convertMCPToolsToGoogle(client, finalOptions);
 }
-// src/ai/openai.ts
-function convertMCPToolToOpenAI(mcpTool, _client, options) {
-  const inputParams = mcpTool.inputSchema;
+// src/ai/cloudflare.ts
+function convertMCPToolToCloudflare(mcpTool, _client, _options) {
   return {
     type: "function",
-    name: mcpTool.name,
-    parameters: inputParams || null,
-    strict: options?.strict ?? null,
-    description: mcpTool.description || null
+    function: {
+      name: mcpTool.name,
+      description: mcpTool.description || `Execute ${mcpTool.name}`,
+      parameters: {
+        type: "object",
+        properties: mcpTool.inputSchema?.properties || {},
+        required: mcpTool.inputSchema?.required || []
+      }
+    }
   };
 }
-function convertMCPToolsToOpenAI(client, options) {
+function convertMCPToolsToCloudflare(client, options) {
   const mcpTools = client.getEnabledTools();
-  return mcpTools.map((mcpTool) => convertMCPToolToOpenAI(mcpTool, client, options));
+  const tools = {};
+  for (const mcpTool of mcpTools) {
+    tools[mcpTool.name] = convertMCPToolToCloudflare(mcpTool, client, options);
+  }
+  return tools;
 }
-async function executeOpenAIToolCall(client, toolCall, options) {
-  const args = JSON.parse(toolCall.arguments);
+async function executeCloudflareToolCall(client, toolCall, options) {
+  const args = typeof toolCall.arguments === "string" ? JSON.parse(toolCall.arguments) : toolCall.arguments;
   const result = await executeToolWithToken(client, toolCall.name, args, options);
   return JSON.stringify(result);
 }
-async function getOpenAITools(client, options) {
+async function getCloudflareTools(client, options) {
   await ensureClientConnected(client);
   let providerTokens = options?.providerTokens;
   if (!providerTokens) {
@@ -7137,29 +6867,84 @@ async function getOpenAITools(client, options) {
     } catch {}
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToOpenAI(client, finalOptions);
+  return convertMCPToolsToCloudflare(client, finalOptions);
 }
-// src/ai/anthropic.ts
-function convertMCPToolToAnthropic(mcpTool, _client, _options) {
+// src/ai/langchain.ts
+function convertMCPToolToLangChain(mcpTool, client, options) {
   return {
     name: mcpTool.name,
     description: mcpTool.description || `Execute ${mcpTool.name}`,
-    input_schema: mcpTool.inputSchema || {
-      type: "object",
-      properties: {},
-      required: []
+    schema: jsonSchemaToZod(mcpTool.inputSchema),
+    func: async (...args) => {
+      const input = args[0];
+      const result = await executeToolWithToken(client, mcpTool.name, input, options);
+      return JSON.stringify(result);
+    }
+  };
+}
+function convertMCPToolsToLangChain(client, options) {
+  const mcpTools = client.getEnabledTools();
+  return mcpTools.map((mcpTool) => convertMCPToolToLangChain(mcpTool, client, options));
+}
+async function getLangChainTools(client, options) {
+  await ensureClientConnected(client);
+  let providerTokens = options?.providerTokens;
+  if (!providerTokens) {
+    try {
+      providerTokens = await getProviderTokens();
+    } catch {}
+  }
+  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
+  return convertMCPToolsToLangChain(client, finalOptions);
+}
+// src/ai/llamaindex.ts
+function convertMCPToolToLlamaIndex(mcpTool, client, options) {
+  return {
+    name: mcpTool.name,
+    description: mcpTool.description || `Execute ${mcpTool.name}`,
+    parameters: jsonSchemaToZod(mcpTool.inputSchema),
+    execute: async (input) => {
+      const result = await executeToolWithToken(client, mcpTool.name, input, options);
+      return JSON.stringify(result);
+    }
+  };
+}
+function convertMCPToolsToLlamaIndex(client, options) {
+  const mcpTools = client.getEnabledTools();
+  return mcpTools.map((mcpTool) => convertMCPToolToLlamaIndex(mcpTool, client, options));
+}
+async function getLlamaIndexTools(client, options) {
+  await ensureClientConnected(client);
+  let providerTokens = options?.providerTokens;
+  if (!providerTokens) {
+    try {
+      providerTokens = await getProviderTokens();
+    } catch {}
+  }
+  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
+  return convertMCPToolsToLlamaIndex(client, finalOptions);
+}
+// src/ai/mastra.ts
+function convertMCPToolToMastra(mcpTool, client, options) {
+  return {
+    id: mcpTool.name,
+    description: mcpTool.description || `Execute ${mcpTool.name}`,
+    inputSchema: jsonSchemaToZod(mcpTool.inputSchema),
+    execute: async ({ context }) => {
+      const result = await executeToolWithToken(client, mcpTool.name, context, options);
+      return result;
     }
   };
 }
-function convertMCPToolsToAnthropic(client, options) {
+function convertMCPToolsToMastra(client, options) {
   const mcpTools = client.getEnabledTools();
-  return mcpTools.map((mcpTool) => convertMCPToolToAnthropic(mcpTool, client, options));
-}
-async function executeAnthropicToolCall(client, toolUse, options) {
-  const result = await executeToolWithToken(client, toolUse.name, toolUse.input, options);
-  return JSON.stringify(result);
+  const tools = {};
+  for (const mcpTool of mcpTools) {
+    tools[mcpTool.name] = convertMCPToolToMastra(mcpTool, client, options);
+  }
+  return tools;
 }
-async function getAnthropicTools(client, options) {
+async function getMastraTools(client, options) {
   await ensureClientConnected(client);
   let providerTokens = options?.providerTokens;
   if (!providerTokens) {
@@ -7168,269 +6953,573 @@ async function getAnthropicTools(client, options) {
     } catch {}
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToAnthropic(client, finalOptions);
+  return convertMCPToolsToMastra(client, finalOptions);
 }
-// src/ai/google.ts
-async function getGoogleType() {
-  try {
-    const dynamicImport = new Function("specifier", "return import(specifier)");
-    const packageName = "@" + "google" + "/" + "genai";
-    const googleGenAI = await dynamicImport(packageName);
-    return googleGenAI.Type;
-  } catch (error) {
-    throw new Error("The @google/genai package is required to use Google AI integration. Install it with: npm install @google/genai");
+// src/ai/index.ts
+async function getAITools(client, provider, options) {
+  switch (provider) {
+    case "vercel-ai":
+      return await getVercelAITools(client, options);
+    case "openai":
+      return await getOpenAITools(client, options);
+    case "anthropic":
+      return await getAnthropicTools(client, options);
+    case "google":
+      return await getGoogleTools(client, options);
+    case "cloudflare":
+      return await getCloudflareTools(client, options);
+    case "langchain":
+      return await getLangChainTools(client, options);
+    case "llamaindex":
+      return await getLlamaIndexTools(client, options);
+    case "mastra":
+      return await getMastraTools(client, options);
+    default:
+      throw new Error(`Unsupported AI provider: ${provider}`);
   }
 }
-function convertJsonSchemaTypeToGoogleType(type, TypeEnum) {
-  const typeMap = {
-    string: TypeEnum.STRING,
-    number: TypeEnum.NUMBER,
-    integer: TypeEnum.INTEGER,
-    boolean: TypeEnum.BOOLEAN,
-    array: TypeEnum.ARRAY,
-    object: TypeEnum.OBJECT
-  };
-  return typeMap[type.toLowerCase()] || TypeEnum.STRING;
+
+// 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 convertPropertiesToSchema(properties, TypeEnum) {
-  const result = {};
-  for (const [key, value] of Object.entries(properties)) {
-    if (!value || typeof value !== "object") {
-      result[key] = value;
-      continue;
+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 updatedIntegrations = config.integrations.map((integration) => {
+    if (integration.oauth) {
+      const { clientId, clientSecret, redirectUri: integrationRedirectUri, config: oauthConfig } = integration.oauth;
+      if (!clientId || !clientSecret) {
+        console.warn(`Warning: Integration "${integration.id}" is missing OAuth credentials. ` + `Provide clientId and clientSecret in the integration configuration.`);
+        return integration;
+      }
+      const redirectUri = integrationRedirectUri || config.redirectUri || getDefaultRedirectUri();
+      providers[integration.id] = {
+        clientId,
+        clientSecret,
+        redirectUri,
+        config: oauthConfig
+      };
+      return {
+        ...integration,
+        oauth: {
+          ...integration.oauth,
+          redirectUri
+        }
+      };
     }
-    const schema = {
-      description: value.description,
-      enum: value.enum
-    };
-    if (value.type) {
-      schema.type = convertJsonSchemaTypeToGoogleType(value.type, TypeEnum);
+    return integration;
+  });
+  globalServerConfig = {
+    providers,
+    serverUrl: config.serverUrl,
+    apiKey: config.apiKey
+  };
+  const clientConfig = {
+    ...config,
+    integrations: updatedIntegrations,
+    connectionMode: config.connectionMode || "lazy",
+    singleton: config.singleton ?? true
+  };
+  const client = new MCPClientBase(clientConfig);
+  if (config.apiKey) {
+    client.setRequestHeader("X-API-KEY", config.apiKey);
+  }
+  client.__oauthConfig = {
+    providers,
+    serverUrl: config.serverUrl,
+    apiKey: config.apiKey,
+    getSessionContext: config.getSessionContext,
+    setProviderToken: config.setProviderToken
+  };
+  const { POST, GET } = createOAuthRouteHandlers({
+    providers,
+    serverUrl: config.serverUrl,
+    apiKey: config.apiKey,
+    getSessionContext: config.getSessionContext,
+    setProviderToken: config.setProviderToken
+  });
+  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) {
+        if (segments[0] === "mcp") {
+          action = "mcp";
+        } else {
+          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 (value.items) {
-      schema.items = convertPropertiesToSchema({ items: value.items }, TypeEnum).items;
+    if (action === "mcp" && method === "POST") {
+      try {
+        const body = await request.json();
+        const authHeader = request.headers.get("authorization");
+        const { OAuthHandler: OAuthHandler2 } = await Promise.resolve().then(() => exports_base_handler);
+        const oauthHandler = new OAuthHandler2({
+          providers,
+          serverUrl: config.serverUrl,
+          apiKey: config.apiKey
+        });
+        const result = await oauthHandler.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 });
+      }
     }
-    if (value.properties) {
-      schema.properties = convertPropertiesToSchema(value.properties, TypeEnum);
+    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") {
+        return Response.json({ error: `Method ${method} not allowed for /mcp route. Use POST.` }, { status: 405 });
+      }
     }
-    for (const [k, v] of Object.entries(value)) {
-      if (!["type", "description", "enum", "items", "properties"].includes(k)) {
-        schema[k] = v;
+    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 });
     }
-    result[key] = schema;
-  }
-  return result;
-}
-async function convertMCPToolToGoogle(mcpTool, _client, _options) {
-  const TypeEnum = await getGoogleType();
-  const properties = mcpTool.inputSchema?.properties || {};
-  const convertedProperties = convertPropertiesToSchema(properties, TypeEnum);
-  const parameters = {
-    type: TypeEnum.OBJECT,
-    description: mcpTool.description || "",
-    properties: convertedProperties
   };
-  if (mcpTool.inputSchema?.required && mcpTool.inputSchema.required.length > 0) {
-    parameters.required = mcpTool.inputSchema.required;
-  }
+  const serverClient = client;
+  serverClient.handler = handler;
+  serverClient.POST = POST;
+  serverClient.GET = GET;
   return {
-    name: mcpTool.name,
-    description: mcpTool.description || `Execute ${mcpTool.name}`,
-    parameters
+    client: serverClient,
+    POST,
+    GET
   };
 }
-async function convertMCPToolsToGoogle(client, options) {
-  const mcpTools = client.getEnabledTools();
-  return await Promise.all(mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, options)));
+function createOAuthRouteHandlers(config) {
+  const handler = createNextOAuthHandler(config);
+  return handler.createRoutes();
 }
-async function executeGoogleFunctionCall(client, functionCall, options) {
-  if (!functionCall?.name) {
-    throw new Error("Function call must have a name");
+var POST = async (req, context) => {
+  if (!globalServerConfig) {
+    return Response.json({ error: "OAuth not configured. Call createMCPServer() in your server initialization file first." }, { status: 500 });
   }
-  let providerTokens = options?.providerTokens;
-  if (!providerTokens) {
-    try {
-      providerTokens = await getProviderTokens();
-    } catch {}
+  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 finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  const args = functionCall.args || {};
-  const result = await executeToolWithToken(client, functionCall.name, args, finalOptions);
-  return JSON.stringify(result);
-}
-async function executeGoogleFunctionCalls(client, functionCalls, options) {
-  if (!functionCalls || functionCalls.length === 0) {
-    return [];
+  const handler = createNextOAuthHandler(globalServerConfig);
+  const routes = handler.createRoutes();
+  return routes.GET(req, context);
+};
+function toNextJsHandler(clientOrOptions, redirectOptions) {
+  let config;
+  let redirectUrl;
+  let errorRedirectUrl;
+  if (!clientOrOptions) {
+    config = globalServerConfig;
+    redirectUrl = redirectOptions?.redirectUrl;
+    errorRedirectUrl = redirectOptions?.errorRedirectUrl;
+  } else if (clientOrOptions.__oauthConfig) {
+    config = clientOrOptions.__oauthConfig;
+    redirectUrl = redirectOptions?.redirectUrl;
+    errorRedirectUrl = redirectOptions?.errorRedirectUrl;
+  } else if (typeof clientOrOptions === "object" && clientOrOptions.providers) {
+    const options = clientOrOptions;
+    config = {
+      providers: options.providers,
+      serverUrl: options.serverUrl,
+      apiKey: options.apiKey,
+      getSessionContext: options.getSessionContext,
+      setProviderToken: options.setProviderToken
+    };
+    redirectUrl = options.redirectUrl;
+    errorRedirectUrl = options.errorRedirectUrl;
+  } else {
+    config = null;
   }
-  let providerTokens = options?.providerTokens;
-  if (!providerTokens) {
-    try {
-      providerTokens = await getProviderTokens();
-    } catch {}
+  if (!config) {
+    throw new Error(`toNextJsHandler requires either:
+  1. A client instance from createMCPServer()
+  2. A config object with providers property
+  3. No arguments (uses global config from createMCPServer)`);
   }
-  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  const results = await Promise.all(functionCalls.map((call) => executeGoogleFunctionCall(client, call, finalOptions)));
-  return results;
+  const POST2 = async (req, context) => {
+    const handler = createNextOAuthHandler(config);
+    const routes = handler.toNextJsHandler({
+      redirectUrl,
+      errorRedirectUrl
+    });
+    return routes.POST(req, context);
+  };
+  const GET2 = async (req, context) => {
+    const handler = createNextOAuthHandler(config);
+    const routes = handler.toNextJsHandler({
+      redirectUrl,
+      errorRedirectUrl
+    });
+    return routes.GET(req, context);
+  };
+  return { POST: POST2, GET: GET2 };
 }
-async function getGoogleTools(client, options) {
-  await ensureClientConnected(client);
-  let providerTokens = options?.providerTokens;
-  if (!providerTokens) {
-    try {
-      providerTokens = await getProviderTokens();
-    } catch {}
+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
+    };
   }
-  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToGoogle(client, finalOptions);
-}
-// src/ai/cloudflare.ts
-function convertMCPToolToCloudflare(mcpTool, _client, _options) {
-  return {
-    type: "function",
-    function: {
-      name: mcpTool.name,
-      description: mcpTool.description || `Execute ${mcpTool.name}`,
-      parameters: {
-        type: "object",
-        properties: mcpTool.inputSchema?.properties || {},
-        required: mcpTool.inputSchema?.required || []
-      }
+  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 convertMCPToolsToCloudflare(client, options) {
-  const mcpTools = client.getEnabledTools();
-  const tools = {};
-  for (const mcpTool of mcpTools) {
-    tools[mcpTool.name] = convertMCPToolToCloudflare(mcpTool, client, options);
+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 } });
+    };
   }
-  return tools;
-}
-async function executeCloudflareToolCall(client, toolCall, options) {
-  const args = typeof toolCall.arguments === "string" ? JSON.parse(toolCall.arguments) : toolCall.arguments;
-  const result = await executeToolWithToken(client, toolCall.name, args, options);
-  return JSON.stringify(result);
-}
-async function getCloudflareTools(client, options) {
-  await ensureClientConnected(client);
-  let providerTokens = options?.providerTokens;
-  if (!providerTokens) {
-    try {
-      providerTokens = await getProviderTokens();
-    } catch {}
+  if (typeof clientOrHandlerOrOptions === "function") {
+    const baseHandler = clientOrHandlerOrOptions;
+    return async (event) => {
+      const all = event.params?.all;
+      return baseHandler(event.request, { params: { all } });
+    };
   }
-  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToCloudflare(client, finalOptions);
-}
-// src/ai/langchain.ts
-function convertMCPToolToLangChain(mcpTool, client, options) {
-  return {
-    name: mcpTool.name,
-    description: mcpTool.description || `Execute ${mcpTool.name}`,
-    schema: jsonSchemaToZod(mcpTool.inputSchema),
-    func: async (...args) => {
-      const input = args[0];
-      const result = await executeToolWithToken(client, mcpTool.name, input, options);
-      return JSON.stringify(result);
+  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 });
     }
   };
 }
-function convertMCPToolsToLangChain(client, options) {
-  const mcpTools = client.getEnabledTools();
-  return mcpTools.map((mcpTool) => convertMCPToolToLangChain(mcpTool, client, options));
-}
-async function getLangChainTools(client, options) {
-  await ensureClientConnected(client);
-  let providerTokens = options?.providerTokens;
-  if (!providerTokens) {
-    try {
-      providerTokens = await getProviderTokens();
-    } catch {}
+// src/adapters/node.ts
+function fromNodeHeaders(nodeHeaders) {
+  const webHeaders = new Headers;
+  for (const [key, value] of Object.entries(nodeHeaders)) {
+    if (value !== undefined) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => webHeaders.append(key, v));
+      } else {
+        webHeaders.set(key, value);
+      }
+    }
   }
-  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToLangChain(client, finalOptions);
+  return webHeaders;
 }
-// src/ai/llamaindex.ts
-function convertMCPToolToLlamaIndex(mcpTool, client, options) {
-  return {
-    name: mcpTool.name,
-    description: mcpTool.description || `Execute ${mcpTool.name}`,
-    parameters: jsonSchemaToZod(mcpTool.inputSchema),
-    execute: async (input) => {
-      const result = await executeToolWithToken(client, mcpTool.name, input, options);
-      return JSON.stringify(result);
-    }
-  };
+async function toWebRequest(req) {
+  const protocol = req.socket.encrypted ? "https" : "http";
+  const host = req.headers.host || "localhost";
+  const url = `${protocol}://${host}${req.url}`;
+  const headers = fromNodeHeaders(req.headers);
+  let body;
+  if (req.method && ["POST", "PUT", "PATCH"].includes(req.method)) {
+    body = await new Promise((resolve, reject) => {
+      let data = "";
+      req.on("data", (chunk) => data += chunk);
+      req.on("end", () => resolve(data));
+      req.on("error", reject);
+    });
+  }
+  return new Request(url, {
+    method: req.method,
+    headers,
+    body: body || undefined
+  });
 }
-function convertMCPToolsToLlamaIndex(client, options) {
-  const mcpTools = client.getEnabledTools();
-  return mcpTools.map((mcpTool) => convertMCPToolToLlamaIndex(mcpTool, client, options));
+async function sendWebResponse(webRes, nodeRes) {
+  nodeRes.statusCode = webRes.status;
+  webRes.headers.forEach((value, key) => {
+    nodeRes.setHeader(key, value);
+  });
+  const body = await webRes.text();
+  nodeRes.end(body);
 }
-async function getLlamaIndexTools(client, options) {
-  await ensureClientConnected(client);
-  let providerTokens = options?.providerTokens;
-  if (!providerTokens) {
+function toNodeHandler(config) {
+  const oauthHandler = new OAuthHandler(config);
+  return async (req, res) => {
     try {
-      providerTokens = await getProviderTokens();
-    } catch {}
-  }
-  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToLlamaIndex(client, finalOptions);
-}
-// src/ai/mastra.ts
-function convertMCPToolToMastra(mcpTool, client, options) {
-  return {
-    id: mcpTool.name,
-    description: mcpTool.description || `Execute ${mcpTool.name}`,
-    inputSchema: jsonSchemaToZod(mcpTool.inputSchema),
-    execute: async ({ context }) => {
-      const result = await executeToolWithToken(client, mcpTool.name, context, options);
-      return result;
+      const webReq = await toWebRequest(req);
+      const url = new URL(webReq.url);
+      const segments = url.pathname.split("/").filter(Boolean);
+      const action = segments[segments.length - 1];
+      let webRes;
+      if (req.method === "POST") {
+        if (action === "authorize") {
+          const result = await oauthHandler.handleAuthorize(webReq);
+          const headers = { "Content-Type": "application/json" };
+          if (result.setCookie) {
+            headers["Set-Cookie"] = result.setCookie;
+          }
+          webRes = new Response(JSON.stringify(result), {
+            status: 200,
+            headers
+          });
+        } else if (action === "callback") {
+          const result = await oauthHandler.handleCallback(webReq);
+          const headers = { "Content-Type": "application/json" };
+          if (result.clearCookie) {
+            headers["Set-Cookie"] = result.clearCookie;
+          }
+          webRes = new Response(JSON.stringify(result), {
+            status: 200,
+            headers
+          });
+        } else if (action === "disconnect") {
+          const authHeader = webReq.headers.get("authorization");
+          if (!authHeader || !authHeader.startsWith("Bearer ")) {
+            webRes = new Response(JSON.stringify({ error: "Missing or invalid Authorization header" }), {
+              status: 400,
+              headers: { "Content-Type": "application/json" }
+            });
+          } else {
+            const accessToken = authHeader.substring(7);
+            const body = await webReq.json();
+            const { provider } = body;
+            if (!provider) {
+              webRes = new Response(JSON.stringify({ error: "Missing provider in request body" }), {
+                status: 400,
+                headers: { "Content-Type": "application/json" }
+              });
+            } else {
+              const result = await oauthHandler.handleDisconnect({ provider }, accessToken);
+              webRes = new Response(JSON.stringify(result), {
+                status: 200,
+                headers: { "Content-Type": "application/json" }
+              });
+            }
+          }
+        } else {
+          webRes = new Response(JSON.stringify({ error: `Unknown action: ${action}` }), {
+            status: 404,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      } else if (req.method === "GET" && action === "status") {
+        const provider = url.searchParams.get("provider");
+        const authHeader = webReq.headers.get("authorization");
+        if (!provider) {
+          webRes = new Response(JSON.stringify({ error: "Missing provider query parameter" }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" }
+          });
+        } else if (!authHeader || !authHeader.startsWith("Bearer ")) {
+          webRes = new Response(JSON.stringify({ error: "Missing or invalid Authorization header" }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" }
+          });
+        } else {
+          const accessToken = authHeader.substring(7);
+          const result = await oauthHandler.handleStatus(provider, accessToken);
+          webRes = new Response(JSON.stringify(result), {
+            status: 200,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      } else {
+        webRes = new Response(JSON.stringify({ error: `Unknown action: ${action}` }), {
+          status: 404,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      await sendWebResponse(webRes, res);
+    } catch (error) {
+      console.error("[OAuth Handler] Error:", error);
+      const errorRes = new Response(JSON.stringify({ error: error.message || "Internal server error" }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+      await sendWebResponse(errorRes, res);
     }
   };
 }
-function convertMCPToolsToMastra(client, options) {
-  const mcpTools = client.getEnabledTools();
-  const tools = {};
-  for (const mcpTool of mcpTools) {
-    tools[mcpTool.name] = convertMCPToolToMastra(mcpTool, client, options);
-  }
-  return tools;
-}
-async function getMastraTools(client, options) {
-  await ensureClientConnected(client);
-  let providerTokens = options?.providerTokens;
-  if (!providerTokens) {
-    try {
-      providerTokens = await getProviderTokens();
-    } catch {}
+// 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);
   }
-  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToMastra(client, finalOptions);
+  return authConfig(event.request);
 }
-// src/ai/index.ts
-async function getAITools(client, provider, options) {
-  switch (provider) {
-    case "vercel-ai":
-      return await getVercelAITools(client, options);
-    case "openai":
-      return await getOpenAITools(client, options);
-    case "anthropic":
-      return await getAnthropicTools(client, options);
-    case "google":
-      return await getGoogleTools(client, options);
-    case "cloudflare":
-      return await getCloudflareTools(client, options);
-    case "langchain":
-      return await getLangChainTools(client, options);
-    case "llamaindex":
-      return await getLlamaIndexTools(client, options);
-    case "mastra":
-      return await getMastraTools(client, options);
-    default:
-      throw new Error(`Unsupported AI provider: ${provider}`);
-  }
+// src/adapters/tanstack-start.ts
+function toTanStackStartHandler(handler) {
+  const baseHandler = async ({ request }) => {
+    return handler(request);
+  };
+  return {
+    GET: baseHandler,
+    POST: baseHandler
+  };
 }
+var createTanStackOAuthHandler = toTanStackStartHandler;
 export {
   toTanStackStartHandler,
   toSvelteKitHandler,
@@ -7439,6 +7528,10 @@ export {
   toNextJsHandler,
   svelteKitHandler,
   notionIntegration,
+  handleOpenAIToolCalls,
+  handleOpenAIResponse,
+  handleAnthropicToolCalls,
+  handleAnthropicMessage,
   gmailIntegration,
   githubIntegration,
   getVercelAITools,