integrate-sdk 0.7.47 → 0.7.49

package/dist/server.js

@@ -261,6 +261,280 @@ function base64UrlDecode(str) {
   }
 }
 
+// src/adapters/session-detector.ts
+var exports_session_detector = {};
+__export(exports_session_detector, {
+  tryDecodeJWT: () => tryDecodeJWT,
+  detectSessionContext: () => detectSessionContext
+});
+function tryDecodeJWT(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      return;
+    }
+    const payloadPart = parts[1];
+    if (!payloadPart) {
+      return;
+    }
+    const base64 = payloadPart.replace(/-/g, "+").replace(/_/g, "/");
+    const jsonPayload = decodeURIComponent(atob(base64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join(""));
+    return JSON.parse(jsonPayload);
+  } catch (error) {
+    return;
+  }
+}
+function getCookies(request) {
+  const cookies = new Map;
+  const cookieHeader = request.headers.get("cookie");
+  if (!cookieHeader) {
+    return cookies;
+  }
+  const pairs = cookieHeader.split(";");
+  for (const pair of pairs) {
+    const [name, ...valueParts] = pair.split("=");
+    if (name && valueParts.length > 0) {
+      const trimmedName = name.trim();
+      const value = valueParts.join("=").trim();
+      cookies.set(trimmedName, value);
+    }
+  }
+  return cookies;
+}
+function tryBetterAuth(cookies) {
+  const sessionToken = cookies.get("better-auth.session_token");
+  if (!sessionToken) {
+    return;
+  }
+  const payload = tryDecodeJWT(sessionToken);
+  if (!payload) {
+    return;
+  }
+  const userId = payload.sub || payload.userId || payload.user_id || payload.id;
+  if (!userId) {
+    return;
+  }
+  return {
+    userId,
+    sessionId: payload.jti || payload.sessionId
+  };
+}
+function tryNextAuth(cookies) {
+  const sessionToken = cookies.get("__Secure-next-auth.session-token") || cookies.get("next-auth.session-token");
+  if (!sessionToken) {
+    return;
+  }
+  if (sessionToken.includes(".")) {
+    const payload = tryDecodeJWT(sessionToken);
+    if (payload) {
+      return {
+        userId: payload.sub || payload.userId || payload.user_id || payload.id,
+        sessionId: payload.jti
+      };
+    }
+  }
+  return;
+}
+function tryClerk(cookies) {
+  const sessionToken = cookies.get("__session");
+  if (!sessionToken) {
+    return;
+  }
+  const payload = tryDecodeJWT(sessionToken);
+  if (!payload) {
+    return;
+  }
+  return {
+    userId: payload.sub || payload.userId,
+    organizationId: payload.org_id || payload.organizationId,
+    sessionId: payload.sid || payload.sessionId
+  };
+}
+function tryLucia(cookies) {
+  const sessionToken = cookies.get("lucia_session");
+  if (!sessionToken) {
+    return;
+  }
+  return {
+    sessionId: sessionToken
+  };
+}
+function tryGenericSession(cookies) {
+  const sessionToken = cookies.get("auth_session") || cookies.get("session");
+  if (!sessionToken) {
+    return;
+  }
+  if (sessionToken.includes(".")) {
+    const payload = tryDecodeJWT(sessionToken);
+    if (payload) {
+      return {
+        userId: payload.sub || payload.userId || payload.user_id || payload.id,
+        sessionId: payload.jti || payload.sessionId || payload.sid
+      };
+    }
+  }
+  return {
+    sessionId: sessionToken
+  };
+}
+async function detectSessionContext(request) {
+  const cookies = getCookies(request);
+  let context;
+  context = tryBetterAuth(cookies);
+  if (context?.userId) {
+    return context;
+  }
+  context = tryNextAuth(cookies);
+  if (context?.userId) {
+    return context;
+  }
+  context = tryClerk(cookies);
+  if (context?.userId) {
+    return context;
+  }
+  context = tryLucia(cookies);
+  if (context?.userId) {
+    return context;
+  }
+  context = tryGenericSession(cookies);
+  if (context?.userId) {
+    return context;
+  }
+  return;
+}
+
+// src/adapters/context-cookie.ts
+var exports_context_cookie = {};
+__export(exports_context_cookie, {
+  readContextCookie: () => readContextCookie,
+  getSetCookieHeader: () => getSetCookieHeader,
+  getContextCookieFromRequest: () => getContextCookieFromRequest,
+  getClearCookieHeader: () => getClearCookieHeader,
+  createContextCookie: () => createContextCookie,
+  CONTEXT_COOKIE_NAME: () => CONTEXT_COOKIE_NAME,
+  CONTEXT_COOKIE_MAX_AGE: () => CONTEXT_COOKIE_MAX_AGE
+});
+async function deriveKey(secret) {
+  const encoder = new TextEncoder;
+  const secretData = encoder.encode(secret);
+  const keyMaterial = await crypto.subtle.importKey("raw", secretData, { name: "PBKDF2" }, false, ["deriveBits", "deriveKey"]);
+  const salt = encoder.encode("integrate-oauth-context-v1");
+  return await crypto.subtle.deriveKey({
+    name: "PBKDF2",
+    salt,
+    iterations: 1e5,
+    hash: "SHA-256"
+  }, keyMaterial, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+}
+async function encryptPayload(payload, secret) {
+  const key = await deriveKey(secret);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const encoder = new TextEncoder;
+  const data = encoder.encode(JSON.stringify(payload));
+  const encrypted = await crypto.subtle.encrypt({
+    name: "AES-GCM",
+    iv
+  }, key, data);
+  const combined = new Uint8Array(iv.length + encrypted.byteLength);
+  combined.set(iv, 0);
+  combined.set(new Uint8Array(encrypted), iv.length);
+  return base64UrlEncode2(combined);
+}
+async function decryptPayload(cookieValue, secret) {
+  try {
+    const combined = base64UrlDecode2(cookieValue);
+    const iv = combined.slice(0, 12);
+    const encrypted = combined.slice(12);
+    const key = await deriveKey(secret);
+    const decrypted = await crypto.subtle.decrypt({
+      name: "AES-GCM",
+      iv
+    }, key, encrypted);
+    const decoder = new TextDecoder;
+    const json = decoder.decode(decrypted);
+    const payload = JSON.parse(json);
+    const age = Date.now() - payload.timestamp;
+    if (age > CONTEXT_COOKIE_MAX_AGE * 1000) {
+      return;
+    }
+    return payload;
+  } catch (error) {
+    return;
+  }
+}
+function base64UrlEncode2(data) {
+  const base64 = btoa(String.fromCharCode(...data));
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64UrlDecode2(str) {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = base64.length % 4;
+  if (padding) {
+    base64 += "=".repeat(4 - padding);
+  }
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function createContextCookie(context, provider, secret) {
+  const payload = {
+    context,
+    provider,
+    timestamp: Date.now()
+  };
+  return await encryptPayload(payload, secret);
+}
+async function readContextCookie(cookieValue, secret) {
+  const payload = await decryptPayload(cookieValue, secret);
+  if (!payload) {
+    return;
+  }
+  return {
+    context: payload.context,
+    provider: payload.provider
+  };
+}
+function getSetCookieHeader(cookieValue, maxAge = CONTEXT_COOKIE_MAX_AGE) {
+  const attributes = [
+    `${CONTEXT_COOKIE_NAME}=${cookieValue}`,
+    `Max-Age=${maxAge}`,
+    "HttpOnly",
+    "Secure",
+    "SameSite=Lax",
+    "Path=/"
+  ];
+  return attributes.join("; ");
+}
+function getClearCookieHeader() {
+  const attributes = [
+    `${CONTEXT_COOKIE_NAME}=`,
+    "Max-Age=0",
+    "HttpOnly",
+    "Secure",
+    "SameSite=Lax",
+    "Path=/"
+  ];
+  return attributes.join("; ");
+}
+function getContextCookieFromRequest(request) {
+  const cookieHeader = request.headers.get("cookie");
+  if (!cookieHeader) {
+    return;
+  }
+  const cookies = cookieHeader.split(";");
+  for (const cookie of cookies) {
+    const [name, ...valueParts] = cookie.split("=");
+    if (name && name.trim() === CONTEXT_COOKIE_NAME) {
+      return valueParts.join("=").trim();
+    }
+  }
+  return;
+}
+var CONTEXT_COOKIE_NAME = "__integrate_oauth_ctx", CONTEXT_COOKIE_MAX_AGE = 300;
+
 // src/adapters/base-handler.ts
 var exports_base_handler = {};
 __export(exports_base_handler, {
@@ -289,25 +563,35 @@ class OAuthHandler {
     return headers;
   }
   async handleAuthorize(request) {
-    const providerConfig = this.config.providers[request.provider];
+    let webRequest;
+    let authorizeRequest;
+    if (request instanceof Request) {
+      webRequest = request;
+      authorizeRequest = await request.json();
+    } else if (typeof request === "object" && "json" in request && typeof request.json === "function") {
+      authorizeRequest = await request.json();
+    } else {
+      authorizeRequest = request;
+    }
+    const providerConfig = this.config.providers[authorizeRequest.provider];
     if (!providerConfig) {
-      throw new Error(`Provider ${request.provider} not configured. Add OAuth credentials to your API route configuration.`);
+      throw new Error(`Provider ${authorizeRequest.provider} not configured. Add OAuth credentials to your API route configuration.`);
     }
     if (!providerConfig.clientId || !providerConfig.clientSecret) {
-      throw new Error(`Missing OAuth credentials for ${request.provider}. Check your environment variables.`);
+      throw new Error(`Missing OAuth credentials for ${authorizeRequest.provider}. Check your environment variables.`);
     }
     const url = new URL("/oauth/authorize", this.serverUrl);
-    url.searchParams.set("provider", request.provider);
+    url.searchParams.set("provider", authorizeRequest.provider);
     url.searchParams.set("client_id", providerConfig.clientId);
     url.searchParams.set("client_secret", providerConfig.clientSecret);
-    const scopes = request.scopes || providerConfig.scopes || [];
+    const scopes = authorizeRequest.scopes || providerConfig.scopes || [];
     if (scopes.length > 0) {
       url.searchParams.set("scope", scopes.join(","));
     }
-    url.searchParams.set("state", request.state);
-    url.searchParams.set("code_challenge", request.codeChallenge);
-    url.searchParams.set("code_challenge_method", request.codeChallengeMethod);
-    const redirectUri = request.redirectUri || providerConfig.redirectUri;
+    url.searchParams.set("state", authorizeRequest.state);
+    url.searchParams.set("code_challenge", authorizeRequest.codeChallenge);
+    url.searchParams.set("code_challenge_method", authorizeRequest.codeChallengeMethod);
+    const redirectUri = authorizeRequest.redirectUri || providerConfig.redirectUri;
     if (redirectUri) {
       url.searchParams.set("redirect_uri", redirectUri);
     }
@@ -320,15 +604,62 @@ class OAuthHandler {
       throw new Error(`MCP server failed to generate authorization URL: ${error}`);
     }
     const data = await response.json();
-    return data;
+    const result = data;
+    if (webRequest) {
+      try {
+        const { detectSessionContext: detectSessionContext2 } = await Promise.resolve().then(() => exports_session_detector);
+        const { createContextCookie: createContextCookie2, getSetCookieHeader: getSetCookieHeader2 } = await Promise.resolve().then(() => exports_context_cookie);
+        let context;
+        if (this.config.getSessionContext) {
+          context = await this.config.getSessionContext(webRequest);
+        }
+        if (!context || !context.userId) {
+          context = await detectSessionContext2(webRequest);
+        }
+        if (context && context.userId) {
+          const secret = this.apiKey || providerConfig.clientSecret;
+          const cookieValue = await createContextCookie2(context, authorizeRequest.provider, secret);
+          result.setCookie = getSetCookieHeader2(cookieValue);
+        }
+      } catch (error) {
+        console.warn("[OAuth] Failed to capture user context:", error);
+      }
+    }
+    return result;
   }
   async handleCallback(request) {
-    const providerConfig = this.config.providers[request.provider];
+    let webRequest;
+    let callbackRequest;
+    if (request instanceof Request) {
+      webRequest = request;
+      callbackRequest = await request.json();
+    } else if (typeof request === "object" && "json" in request && typeof request.json === "function") {
+      callbackRequest = await request.json();
+    } else {
+      callbackRequest = request;
+    }
+    const providerConfig = this.config.providers[callbackRequest.provider];
     if (!providerConfig) {
-      throw new Error(`Provider ${request.provider} not configured. Add OAuth credentials to your API route configuration.`);
+      throw new Error(`Provider ${callbackRequest.provider} not configured. Add OAuth credentials to your API route configuration.`);
     }
     if (!providerConfig.clientId || !providerConfig.clientSecret) {
-      throw new Error(`Missing OAuth credentials for ${request.provider}. Check your environment variables.`);
+      throw new Error(`Missing OAuth credentials for ${callbackRequest.provider}. Check your environment variables.`);
+    }
+    let context;
+    if (webRequest) {
+      try {
+        const { getContextCookieFromRequest: getContextCookieFromRequest2, readContextCookie: readContextCookie2 } = await Promise.resolve().then(() => exports_context_cookie);
+        const cookieValue = getContextCookieFromRequest2(webRequest);
+        if (cookieValue) {
+          const secret = this.apiKey || providerConfig.clientSecret;
+          const contextData = await readContextCookie2(cookieValue, secret);
+          if (contextData && contextData.provider === callbackRequest.provider) {
+            context = contextData.context;
+          }
+        }
+      } catch (error) {
+        console.warn("[OAuth] Failed to restore user context:", error);
+      }
     }
     const url = new URL("/oauth/callback", this.serverUrl);
     const response = await fetch(url.toString(), {
@@ -337,10 +668,10 @@ class OAuthHandler {
         "Content-Type": "application/json"
       }),
       body: JSON.stringify({
-        provider: request.provider,
-        code: request.code,
-        code_verifier: request.codeVerifier,
-        state: request.state,
+        provider: callbackRequest.provider,
+        code: callbackRequest.code,
+        code_verifier: callbackRequest.codeVerifier,
+        state: callbackRequest.state,
         client_id: providerConfig.clientId,
         client_secret: providerConfig.clientSecret,
         redirect_uri: providerConfig.redirectUri
@@ -351,7 +682,26 @@ class OAuthHandler {
       throw new Error(`MCP server failed to exchange authorization code: ${error}`);
     }
     const data = await response.json();
-    return data;
+    const result = data;
+    if (this.config.setProviderToken && context) {
+      try {
+        const tokenData = {
+          accessToken: result.accessToken,
+          refreshToken: result.refreshToken,
+          tokenType: result.tokenType,
+          expiresIn: result.expiresIn,
+          expiresAt: result.expiresAt
+        };
+        await this.config.setProviderToken(callbackRequest.provider, tokenData, context);
+      } catch (error) {
+        console.error("[OAuth] Failed to save provider token:", error);
+      }
+    }
+    if (webRequest) {
+      const { getClearCookieHeader: getClearCookieHeader2 } = await Promise.resolve().then(() => exports_context_cookie);
+      result.clearCookie = getClearCookieHeader2();
+    }
+    return result;
   }
   async handleStatus(provider, accessToken) {
     const url = new URL("/oauth/status", this.serverUrl);
@@ -1667,9 +2017,12 @@ function createNextOAuthHandler(config) {
   const handlers = {
     async authorize(req) {
       try {
-        const body = await req.json();
-        const result = await handler.handleAuthorize(body);
-        return Response.json(result);
+        const result = await handler.handleAuthorize(req);
+        const response = Response.json(result);
+        if (result.setCookie) {
+          response.headers.set("Set-Cookie", result.setCookie);
+        }
+        return response;
       } catch (error) {
         console.error("[OAuth Authorize] Error:", error);
         return Response.json({ error: error.message || "Failed to get authorization URL" }, { status: 500 });
@@ -1677,9 +2030,12 @@ function createNextOAuthHandler(config) {
     },
     async callback(req) {
       try {
-        const body = await req.json();
-        const result = await handler.handleCallback(body);
-        return Response.json(result);
+        const result = await handler.handleCallback(req);
+        const response = Response.json(result);
+        if (result.clearCookie) {
+          response.headers.set("Set-Cookie", result.clearCookie);
+        }
+        return response;
       } catch (error) {
         console.error("[OAuth Callback] Error:", error);
         return Response.json({ error: error.message || "Failed to exchange authorization code" }, { status: 500 });
@@ -2034,12 +2390,16 @@ function createMCPServer(config) {
   client.__oauthConfig = {
     providers,
     serverUrl: config.serverUrl,
-    apiKey: config.apiKey
+    apiKey: config.apiKey,
+    getSessionContext: config.getSessionContext,
+    setProviderToken: config.setProviderToken
   };
   const { POST, GET } = createOAuthRouteHandlers({
     providers,
     serverUrl: config.serverUrl,
-    apiKey: config.apiKey
+    apiKey: config.apiKey,
+    getSessionContext: config.getSessionContext,
+    setProviderToken: config.setProviderToken
   });
   const handler = async (request, context) => {
     const method = request.method.toUpperCase();
@@ -2200,7 +2560,9 @@ function toNextJsHandler(clientOrOptions, redirectOptions) {
     config = {
       providers: options.providers,
       serverUrl: options.serverUrl,
-      apiKey: options.apiKey
+      apiKey: options.apiKey,
+      getSessionContext: options.getSessionContext,
+      setProviderToken: options.setProviderToken
     };
     redirectUrl = options.redirectUrl;
     errorRedirectUrl = options.errorRedirectUrl;
@@ -2341,6 +2703,171 @@ function toSvelteKitHandler(clientOrHandlerOrOptions, _redirectOptions) {
     }
   };
 }
+// 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, {
@@ -6362,13 +6889,6 @@ async function getProviderTokens(manualTokens) {
   }
   throw new Error("Provider tokens not found. Please pass tokens manually via options.providerTokens or set the x-integrate-tokens header in your request.");
 }
-async function tryGetProviderTokens(manualTokens) {
-  try {
-    return await getProviderTokens(manualTokens);
-  } catch {
-    return null;
-  }
-}
 
 // src/ai/utils.ts
 function getProviderForTool(client, toolName) {
@@ -6580,49 +7100,6 @@ async function getOpenAITools(client, options) {
   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 {
@@ -6643,29 +7120,6 @@ 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;
@@ -6677,29 +7131,14 @@ async function getAnthropicTools(client, options) {
   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 {}
-  }
-  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  const toolResults = await handleAnthropicToolCalls(client, message.content, finalOptions);
-  if (toolResults.length === 0) {
-    return [];
-  }
-  return [
-    {
-      role: "user",
-      content: toolResults
-    }
-  ];
-}
 // src/ai/google.ts
 async function getGoogleType() {
-  const { Type } = await import("@google/genai");
-  return Type;
+  const packageName = ["@google", "genai"].join("/");
+  const googleGenAI = await import(packageName).catch(() => null);
+  if (!googleGenAI) {
+    throw new Error("The @google/genai package is required to use Google AI integration. Install it with: npm install @google/genai");
+  }
+  return googleGenAI.Type;
 }
 function convertJsonSchemaTypeToGoogleType(type, TypeEnum) {
   const typeMap = {
@@ -6951,183 +7390,16 @@ async function getAITools(client, provider, options) {
       throw new Error(`Unsupported AI provider: ${provider}`);
   }
 }
-// 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 body = await webReq.json();
-          const result = await oauthHandler.handleAuthorize(body);
-          webRes = new Response(JSON.stringify(result), {
-            status: 200,
-            headers: { "Content-Type": "application/json" }
-          });
-        } else if (action === "callback") {
-          const body = await webReq.json();
-          const result = await oauthHandler.handleCallback(body);
-          webRes = new Response(JSON.stringify(result), {
-            status: 200,
-            headers: { "Content-Type": "application/json" }
-          });
-        } 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;
 export {
-  tryGetProviderTokens,
   toTanStackStartHandler,
   toSvelteKitHandler,
   toSolidStartHandler,
   toNodeHandler,
   toNextJsHandler,
   svelteKitHandler,
-  jsonSchemaToZod,
-  jsonSchemaPropertyToZod,
-  handleOpenAIToolCalls,
-  handleOpenAIResponse,
-  handleAnthropicToolCalls,
-  handleAnthropicMessage,
   gmailIntegration,
   githubIntegration,
   getVercelAITools,
-  getProviderTokens,
   getProviderForTool,
   getOpenAITools,
   getMastraTools,
@@ -7145,7 +7417,6 @@ export {
   executeGoogleFunctionCall,
   executeCloudflareToolCall,
   executeAnthropicToolCall,
-  ensureClientConnected,
   createTanStackOAuthHandler,
   createSimpleIntegration,
   createNextOAuthHandler,