integrate-sdk 0.7.46 → 0.7.48

package/dist/ai/google.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/ai/google.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjH,OAAO,KAAK,EACV,MAAM,EACN,mBAAmB,EACnB,YAAY,EACZ,IAAI,EACL,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAC7C,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAAC;AAC9C,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAW7B;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;CAAI;AA4D9D;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,OAAO,CAAC,UAAU,CAAC,CAqBrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAKvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,YAAY,EAAE,kBAAkB,EAChC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA2BjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,aAAa,EAAE,kBAAkB,EAAE,GAAG,SAAS,GAAG,IAAI,EACtD,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,EAAE,CAAC,CAsBnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAevB"}
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/ai/google.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjH,OAAO,KAAK,EACV,MAAM,EACN,mBAAmB,EACnB,YAAY,EACZ,IAAI,EACL,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAC7C,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAAC;AAC9C,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAqB7B;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;CAAI;AA4D9D;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,OAAO,CAAC,UAAU,CAAC,CAqBrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAKvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,YAAY,EAAE,kBAAkB,EAChC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA2BjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,aAAa,EAAE,kBAAkB,EAAE,GAAG,SAAS,GAAG,IAAI,EACtD,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,EAAE,CAAC,CAsBnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAevB"}

package/dist/ai/google.js

@@ -4204,8 +4204,12 @@ async function ensureClientConnected(client) {
 
 // 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 = {

package/dist/ai/index.js

@@ -4318,8 +4318,12 @@ async function getCloudflareTools(client, options) {
 
 // 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 = {

package/dist/server.d.ts

@@ -18,6 +18,6 @@
  * ```
  */
 export * from './src/server.js';
-export * from './src/ai/index.js';
 export * from './src/adapters/index.js';
+export { getVercelAITools, convertMCPToolsToVercelAI, convertMCPToolToVercelAI, getOpenAITools, convertMCPToolsToOpenAI, convertMCPToolToOpenAI, executeOpenAIToolCall, getAnthropicTools, convertMCPToolsToAnthropic, convertMCPToolToAnthropic, executeAnthropicToolCall, getGoogleTools, convertMCPToolsToGoogle, convertMCPToolToGoogle, executeGoogleFunctionCall, executeGoogleFunctionCalls, getCloudflareTools, convertMCPToolsToCloudflare, convertMCPToolToCloudflare, executeCloudflareToolCall, getLangChainTools, convertMCPToolsToLangChain, convertMCPToolToLangChain, getLlamaIndexTools, convertMCPToolsToLlamaIndex, convertMCPToolToLlamaIndex, getMastraTools, convertMCPToolsToMastra, convertMCPToolToMastra, getAITools, getProviderForTool, executeToolWithToken, type AIProviderName, type AIToolsOptions, type VercelAITool, type OpenAITool, type AnthropicTool, type GoogleTool, type CloudflareTool, } from './src/ai/index.js';
 //# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,cAAc,iBAAiB,CAAC;AAGhC,cAAc,yBAAyB,CAAC;AAGxC,OAAO,EAEL,gBAAgB,EAChB,yBAAyB,EACzB,wBAAwB,EAExB,cAAc,EACd,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,EAErB,iBAAiB,EACjB,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,EAExB,cAAc,EACd,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,EACzB,0BAA0B,EAE1B,kBAAkB,EAClB,2BAA2B,EAC3B,0BAA0B,EAC1B,yBAAyB,EAEzB,iBAAiB,EACjB,0BAA0B,EAC1B,yBAAyB,EAEzB,kBAAkB,EAClB,2BAA2B,EAC3B,0BAA0B,EAE1B,cAAc,EACd,uBAAuB,EACvB,sBAAsB,EAEtB,UAAU,EAEV,kBAAkB,EAClB,oBAAoB,EAEpB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,cAAc,GACpB,MAAM,mBAAmB,CAAC"}

package/dist/server.js

@@ -2341,6 +2341,165 @@ 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 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;
 // node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -6362,13 +6521,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 +6732,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 +6752,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 +6763,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 +7022,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 +7049,6 @@ export {
   executeGoogleFunctionCall,
   executeCloudflareToolCall,
   executeAnthropicToolCall,
-  ensureClientConnected,
   createTanStackOAuthHandler,
   createSimpleIntegration,
   createNextOAuthHandler,

package/dist/src/ai/google.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/ai/google.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjH,OAAO,KAAK,EACV,MAAM,EACN,mBAAmB,EACnB,YAAY,EACZ,IAAI,EACL,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAC7C,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAAC;AAC9C,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAW7B;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;CAAI;AA4D9D;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,OAAO,CAAC,UAAU,CAAC,CAqBrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAKvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,YAAY,EAAE,kBAAkB,EAChC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA2BjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,aAAa,EAAE,kBAAkB,EAAE,GAAG,SAAS,GAAG,IAAI,EACtD,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,EAAE,CAAC,CAsBnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAevB"}
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/ai/google.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjH,OAAO,KAAK,EACV,MAAM,EACN,mBAAmB,EACnB,YAAY,EACZ,IAAI,EACL,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAC7C,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAAC;AAC9C,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAqB7B;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;CAAI;AA4D9D;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,OAAO,CAAC,UAAU,CAAC,CAqBrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAKvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,YAAY,EAAE,kBAAkB,EAChC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA2BjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,aAAa,EAAE,kBAAkB,EAAE,GAAG,SAAS,GAAG,IAAI,EACtD,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,EAAE,CAAC,CAsBnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAevB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "integrate-sdk",
-  "version": "0.7.46",
+  "version": "0.7.48",
   "description": "Type-safe 3rd party integration SDK for the Integrate MCP server",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,6 +30,38 @@
     "./integrations": {
       "types": "./dist/integrations.d.ts",
       "import": "./dist/integrations.js"
+    },
+    "./ai/vercel": {
+      "types": "./dist/ai/vercel-ai.d.ts",
+      "import": "./dist/ai/vercel-ai.js"
+    },
+    "./ai/openai": {
+      "types": "./dist/ai/openai.d.ts",
+      "import": "./dist/ai/openai.js"
+    },
+    "./ai/anthropic": {
+      "types": "./dist/ai/anthropic.d.ts",
+      "import": "./dist/ai/anthropic.js"
+    },
+    "./ai/google": {
+      "types": "./dist/ai/google.d.ts",
+      "import": "./dist/ai/google.js"
+    },
+    "./ai/cloudflare": {
+      "types": "./dist/ai/cloudflare.d.ts",
+      "import": "./dist/ai/cloudflare.js"
+    },
+    "./ai/langchain": {
+      "types": "./dist/ai/langchain.d.ts",
+      "import": "./dist/ai/langchain.js"
+    },
+    "./ai/llamaindex": {
+      "types": "./dist/ai/llamaindex.d.ts",
+      "import": "./dist/ai/llamaindex.js"
+    },
+    "./ai/mastra": {
+      "types": "./dist/ai/mastra.d.ts",
+      "import": "./dist/ai/mastra.js"
     }
   },
   "files": [
@@ -71,11 +103,8 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.32.1",
-    "@google/genai": "^1.29.0",
     "@types/bun": "latest",
     "@types/react": "^18.3.0",
-    "openai": "^4.77.3",
     "react": "^19.2.0",
     "simple-git-hooks": "^2.13.1",
     "typescript": "^5.3.3"
@@ -85,7 +114,6 @@
     "react": ">=19.0.0",
     "ai": ">=4.0.0",
     "openai": ">=4.0.0",
-    "@openai/agents": ">=0.1.0",
     "@anthropic-ai/sdk": ">=0.20.0",
     "@google/genai": "",
     "@cloudflare/workers-types": ">=4.0.0",

package/server.ts

@@ -18,7 +18,63 @@
  * ```
  */
 
+// Core server exports
 export * from './src/server.js';
-export * from './src/ai/index.js';
+
+// Framework adapter exports  
 export * from './src/adapters/index.js';
 
+// AI provider exports - explicitly imported to prevent tree-shaking
+export {
+  // Vercel AI
+  getVercelAITools,
+  convertMCPToolsToVercelAI,
+  convertMCPToolToVercelAI,
+  // OpenAI
+  getOpenAITools,
+  convertMCPToolsToOpenAI,
+  convertMCPToolToOpenAI,
+  executeOpenAIToolCall,
+  // Anthropic
+  getAnthropicTools,
+  convertMCPToolsToAnthropic,
+  convertMCPToolToAnthropic,
+  executeAnthropicToolCall,
+  // Google
+  getGoogleTools,
+  convertMCPToolsToGoogle,
+  convertMCPToolToGoogle,
+  executeGoogleFunctionCall,
+  executeGoogleFunctionCalls,
+  // Cloudflare
+  getCloudflareTools,
+  convertMCPToolsToCloudflare,
+  convertMCPToolToCloudflare,
+  executeCloudflareToolCall,
+  // LangChain
+  getLangChainTools,
+  convertMCPToolsToLangChain,
+  convertMCPToolToLangChain,
+  // LlamaIndex
+  getLlamaIndexTools,
+  convertMCPToolsToLlamaIndex,
+  convertMCPToolToLlamaIndex,
+  // Mastra
+  getMastraTools,
+  convertMCPToolsToMastra,
+  convertMCPToolToMastra,
+  // Unified interface
+  getAITools,
+  // Utilities
+  getProviderForTool,
+  executeToolWithToken,
+  // Types
+  type AIProviderName,
+  type AIToolsOptions,
+  type VercelAITool,
+  type OpenAITool,
+  type AnthropicTool,
+  type GoogleTool,
+  type CloudflareTool,
+} from './src/ai/index.js';
+