integrate-sdk 0.7.53 → 0.7.56

package/dist/ai/index.js

@@ -4214,24 +4214,17 @@ function convertMCPToolToAnthropic(mcpTool, _client, _options) {
     }
   };
 }
-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);
+      const result = await executeToolWithToken(client, toolUse.name, toolUse.input, options);
+      const resultString = JSON.stringify(result);
       toolResults.push({
         type: "tool_result",
         tool_use_id: toolUse.id,
-        content: result
+        content: resultString
       });
     } catch (error) {
       toolResults.push({
@@ -4254,7 +4247,8 @@ async function getAnthropicTools(client, options) {
     } catch {}
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToAnthropic(client, finalOptions);
+  const mcpTools = client.getEnabledTools();
+  return mcpTools.map((mcpTool) => convertMCPToolToAnthropic(mcpTool, client, finalOptions));
 }
 async function handleAnthropicMessage(client, message, options) {
   let providerTokens = options?.providerTokens;
@@ -4266,9 +4260,13 @@ async function handleAnthropicMessage(client, message, options) {
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
   const toolResults = await handleAnthropicToolCalls(client, message.content, finalOptions);
   if (toolResults.length === 0) {
-    return [];
+    return message;
   }
   return [
+    {
+      role: message.role,
+      content: message.content
+    },
     {
       role: "user",
       content: toolResults
@@ -4276,46 +4274,6 @@ async function handleAnthropicMessage(client, message, options) {
   ];
 }
 
-// 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 || []
-      }
-    }
-  };
-}
-function convertMCPToolsToCloudflare(client, options) {
-  const mcpTools = client.getEnabledTools();
-  const tools = {};
-  for (const mcpTool of mcpTools) {
-    tools[mcpTool.name] = convertMCPToolToCloudflare(mcpTool, client, options);
-  }
-  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 {}
-  }
-  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToCloudflare(client, finalOptions);
-}
-
 // google.ts
 async function getGoogleType() {
   try {
@@ -4385,25 +4343,6 @@ async function convertMCPToolToGoogle(mcpTool, _client, _options) {
     parameters
   };
 }
-async function convertMCPToolsToGoogle(client, options) {
-  const mcpTools = client.getEnabledTools();
-  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");
-  }
-  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 executeGoogleFunctionCalls(client, functionCalls, options) {
   if (!functionCalls || functionCalls.length === 0) {
     return [];
@@ -4415,7 +4354,14 @@ async function executeGoogleFunctionCalls(client, functionCalls, options) {
     } catch {}
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  const results = await Promise.all(functionCalls.map((call) => executeGoogleFunctionCall(client, call, finalOptions)));
+  const results = await Promise.all(functionCalls.map(async (call) => {
+    if (!call?.name) {
+      throw new Error("Function call must have a name");
+    }
+    const args = call.args || {};
+    const result = await executeToolWithToken(client, call.name, args, finalOptions);
+    return JSON.stringify(result);
+  }));
   return results;
 }
 async function getGoogleTools(client, options) {
@@ -4427,7 +4373,8 @@ async function getGoogleTools(client, options) {
     } catch {}
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToGoogle(client, finalOptions);
+  const mcpTools = client.getEnabledTools();
+  return await Promise.all(mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, finalOptions)));
 }
 
 // vercel-ai.ts
@@ -4443,14 +4390,6 @@ function convertMCPToolToVercelAI(mcpTool, client, options) {
     }
   };
 }
-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;
@@ -4460,7 +4399,12 @@ async function getVercelAITools(client, options) {
     } catch {}
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToVercelAI(client, finalOptions);
+  const mcpTools = client.getEnabledTools();
+  const vercelTools = {};
+  for (const mcpTool of mcpTools) {
+    vercelTools[mcpTool.name] = convertMCPToolToVercelAI(mcpTool, client, finalOptions);
+  }
+  return vercelTools;
 }
 
 // openai.ts
@@ -4474,15 +4418,6 @@ function convertMCPToolToOpenAI(mcpTool, _client, options) {
     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;
@@ -4492,7 +4427,8 @@ async function getOpenAITools(client, options) {
     } catch {}
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToOpenAI(client, finalOptions);
+  const mcpTools = client.getEnabledTools();
+  return mcpTools.map((mcpTool) => convertMCPToolToOpenAI(mcpTool, client, finalOptions));
 }
 async function handleOpenAIToolCalls(client, toolCalls, options) {
   const toolOutputs = [];
@@ -4504,11 +4440,13 @@ async function handleOpenAIToolCalls(client, toolCalls, options) {
         arguments: output.arguments
       };
       try {
-        const result = await executeOpenAIToolCall(client, toolCall, options);
+        const args = JSON.parse(toolCall.arguments);
+        const result = await executeToolWithToken(client, toolCall.name, args, options);
+        const resultString = JSON.stringify(result);
         toolOutputs.push({
           call_id: output.call_id ?? output.id ?? "",
           type: "function_call_output",
-          output: result,
+          output: resultString,
           status: "completed"
         });
       } catch (error) {
@@ -4537,158 +4475,12 @@ async function handleOpenAIResponse(client, response, options) {
   }
   return handleOpenAIToolCalls(client, functionCalls, finalOptions);
 }
-
-// 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);
-    }
-  };
-}
-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);
-}
-
-// 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);
-}
-
-// 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 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 {}
-  }
-  const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToMastra(client, finalOptions);
-}
-// 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}`);
-  }
-}
 export {
-  tryGetProviderTokens,
-  jsonSchemaToZod,
-  jsonSchemaPropertyToZod,
-  handleOpenAIToolCalls,
   handleOpenAIResponse,
-  handleAnthropicToolCalls,
   handleAnthropicMessage,
   getVercelAITools,
-  getProviderTokens,
-  getProviderForTool,
   getOpenAITools,
-  getMastraTools,
-  getLlamaIndexTools,
-  getLangChainTools,
   getGoogleTools,
-  getCloudflareTools,
   getAnthropicTools,
-  getAITools,
-  executeToolWithToken,
-  executeOpenAIToolCall,
-  executeGoogleFunctionCalls,
-  executeGoogleFunctionCall,
-  executeCloudflareToolCall,
-  executeAnthropicToolCall,
-  ensureClientConnected,
-  convertMCPToolsToVercelAI,
-  convertMCPToolsToOpenAI,
-  convertMCPToolsToMastra,
-  convertMCPToolsToLlamaIndex,
-  convertMCPToolsToLangChain,
-  convertMCPToolsToGoogle,
-  convertMCPToolsToCloudflare,
-  convertMCPToolsToAnthropic,
-  convertMCPToolToVercelAI,
-  convertMCPToolToOpenAI,
-  convertMCPToolToMastra,
-  convertMCPToolToLlamaIndex,
-  convertMCPToolToLangChain,
-  convertMCPToolToGoogle,
-  convertMCPToolToCloudflare,
-  convertMCPToolToAnthropic
+  executeGoogleFunctionCalls
 };

package/dist/ai/openai.d.ts

@@ -4,7 +4,6 @@
  * Helper functions to convert MCP tools to OpenAI Responses API format
  */
 import type { MCPClient } from "../client.js";
-import type { MCPTool } from "../protocol/messages.js";
 import { type AIToolsOptions } from "./utils.js";
 import type { OpenAI } from "openai";
 /**
@@ -30,61 +29,6 @@ export interface OpenAIToolsOptions extends AIToolsOptions {
      */
     strict?: boolean;
 }
-/**
- * Convert a single MCP tool to OpenAI Responses API format
- *
- * @param mcpTool - The MCP tool definition
- * @param client - The MCP client instance (used for executing the tool)
- * @param options - Optional configuration including provider tokens and strict mode
- * @returns OpenAI compatible tool definition
- *
- * @example
- * ```typescript
- * const openaiTool = convertMCPToolToOpenAI(mcpTool, client, { strict: true });
- * ```
- */
-export declare function convertMCPToolToOpenAI(mcpTool: MCPTool, _client: MCPClient<any>, options?: OpenAIToolsOptions): OpenAITool;
-/**
- * Convert all enabled MCP tools to OpenAI Responses API format
- *
- * @param client - The MCP client instance (must be connected)
- * @param options - Optional configuration including provider tokens and strict mode
- * @returns Array of OpenAI compatible tool definitions
- *
- * @example
- * ```typescript
- * // Client-side usage
- * const tools = convertMCPToolsToOpenAI(mcpClient);
- *
- * // Server-side with provider tokens
- * const tools = convertMCPToolsToOpenAI(serverClient, {
- *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
- * });
- * ```
- */
-export declare function convertMCPToolsToOpenAI(client: MCPClient<any>, options?: OpenAIToolsOptions): OpenAITool[];
-/**
- * Execute a tool call from OpenAI's response
- *
- * @param client - The MCP client instance
- * @param toolCall - The tool call from OpenAI response
- * @param options - Optional configuration including provider tokens
- * @returns Tool execution result as JSON string
- *
- * @example
- * ```typescript
- * const result = await executeOpenAIToolCall(client, {
- *   id: 'call_123',
- *   name: 'github_create_issue',
- *   arguments: '{"owner":"user","repo":"repo","title":"Bug"}'
- * }, { providerTokens });
- * ```
- */
-export declare function executeOpenAIToolCall(client: MCPClient<any>, toolCall: {
-    id: string;
-    name: string;
-    arguments: string;
-}, options?: OpenAIToolsOptions): Promise<string>;
 /**
  * Get tools in a format compatible with OpenAI Responses API
  *
@@ -125,42 +69,6 @@ export declare function executeOpenAIToolCall(client: MCPClient<any>, toolCall:
  * ```
  */
 export declare function getOpenAITools(client: MCPClient<any>, options?: OpenAIToolsOptions): Promise<OpenAITool[]>;
-/**
- * Handle multiple tool calls from OpenAI's response output
- *
- * This function processes all function_call items from the response output,
- * executes each tool call, and returns formatted results for the next request.
- *
- * @param client - The MCP client instance
- * @param toolCalls - Array of output items from OpenAI response (filters for function_call type)
- * @param options - Optional configuration including provider tokens
- * @returns Array of function call outputs to send back to OpenAI
- *
- * @example
- * ```typescript
- * // Handle tool calls from a response
- * const response = await openai.responses.create({
- *   model: 'gpt-4o-2024-11-20',
- *   input: 'Create a GitHub issue',
- *   tools: await getOpenAITools(serverClient),
- * });
- *
- * // Execute the tool calls and get outputs
- * const toolOutputs = await handleOpenAIToolCalls(
- *   serverClient,
- *   response.output,
- *   { providerTokens }
- * );
- *
- * // Continue the conversation with tool results
- * const nextResponse = await openai.responses.create({
- *   model: 'gpt-4o-2024-11-20',
- *   input: toolOutputs,
- *   tools: await getOpenAITools(serverClient),
- * });
- * ```
- */
-export declare function handleOpenAIToolCalls(client: MCPClient<any>, toolCalls: OpenAI.Responses.ResponseOutputItem[], options?: OpenAIToolsOptions): Promise<OpenAI.Responses.ResponseInputItem.FunctionCallOutput[]>;
 /**
  * Handle an entire OpenAI Response object
  *

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

@@ -1 +1 @@
-{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/ai/openai.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;AACjH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE;QACV,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,GAAG,IAAI,CAAC;IACT,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IACxD;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,UAAU,CAUZ;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,UAAU,EAAE,CAGd;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE;IACR,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,EACD,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CAIjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAevB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC,kBAAkB,EAAE,EAChD,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,CAAC,CA+BlE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,EAChE,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,GAAG;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,CAyB3H"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/ai/openai.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AACjH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE;QACV,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,GAAG,IAAI,CAAC;IACT,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IACxD;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAiCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAgBvB;AA4ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,EAChE,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,GAAG;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,CAyB3H"}

package/dist/ai/openai.js

@@ -4213,15 +4213,6 @@ function convertMCPToolToOpenAI(mcpTool, _client, options) {
     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;
@@ -4231,7 +4222,8 @@ async function getOpenAITools(client, options) {
     } catch {}
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToOpenAI(client, finalOptions);
+  const mcpTools = client.getEnabledTools();
+  return mcpTools.map((mcpTool) => convertMCPToolToOpenAI(mcpTool, client, finalOptions));
 }
 async function handleOpenAIToolCalls(client, toolCalls, options) {
   const toolOutputs = [];
@@ -4243,11 +4235,13 @@ async function handleOpenAIToolCalls(client, toolCalls, options) {
         arguments: output.arguments
       };
       try {
-        const result = await executeOpenAIToolCall(client, toolCall, options);
+        const args = JSON.parse(toolCall.arguments);
+        const result = await executeToolWithToken(client, toolCall.name, args, options);
+        const resultString = JSON.stringify(result);
         toolOutputs.push({
           call_id: output.call_id ?? output.id ?? "",
           type: "function_call_output",
-          output: result,
+          output: resultString,
           status: "completed"
         });
       } catch (error) {
@@ -4277,10 +4271,6 @@ async function handleOpenAIResponse(client, response, options) {
   return handleOpenAIToolCalls(client, functionCalls, finalOptions);
 }
 export {
-  handleOpenAIToolCalls,
   handleOpenAIResponse,
-  getOpenAITools,
-  executeOpenAIToolCall,
-  convertMCPToolsToOpenAI,
-  convertMCPToolToOpenAI
+  getOpenAITools
 };

package/dist/ai/vercel-ai.d.ts

@@ -5,7 +5,6 @@
  */
 import { z } from "zod";
 import type { MCPClient } from "../client.js";
-import type { MCPTool } from "../protocol/messages.js";
 import type { MCPContext } from "../config/types.js";
 import { type AIToolsOptions } from "./utils.js";
 /**
@@ -24,71 +23,6 @@ export interface VercelAIToolsOptions extends AIToolsOptions {
     /** User context for multi-tenant token storage */
     context?: MCPContext;
 }
-/**
- * Convert a single MCP tool to Vercel AI SDK format
- *
- * @param mcpTool - The MCP tool definition
- * @param client - The MCP client instance (used for executing the tool)
- * @param options - Optional configuration including provider tokens and context
- * @returns Vercel AI SDK compatible tool definition
- */
-export declare function convertMCPToolToVercelAI(mcpTool: MCPTool, client: MCPClient<any>, options?: VercelAIToolsOptions): VercelAITool;
-/**
- * Convert all enabled MCP tools to Vercel AI SDK v5 format
- *
- * @param client - The MCP client instance (must be connected)
- * @param options - Optional configuration including provider tokens for server-side usage
- * @returns Object mapping tool names to Vercel AI SDK v5 tool definitions (compatible with CoreTool from 'ai' package v5)
- *
- * @example
- * ```typescript
- * // Client-side usage
- * import { createMCPClient, githubIntegration } from 'integrate-sdk';
- * import { convertMCPToolsToVercelAI } from 'integrate-sdk/vercel-ai';
- * import { generateText } from 'ai';
- *
- * const mcpClient = createMCPClient({
- *   integrations: [githubIntegration({ clientId: '...', clientSecret: '...' })],
- * });
- *
- * await mcpClient.connect();
- *
- * const tools = convertMCPToolsToVercelAI(mcpClient);
- *
- * const result = await generateText({
- *   model: openai('gpt-5'),
- *   prompt: 'Create a GitHub issue in my repo',
- *   tools,
- * });
- * ```
- *
- * @example
- * ```typescript
- * // Server-side usage with token passing
- * import { createMCPServer, githubIntegration } from 'integrate-sdk/server';
- * import { convertMCPToolsToVercelAI } from 'integrate-sdk/vercel-ai';
- *
- * const { client: serverClient } = createMCPServer({
- *   integrations: [githubIntegration({ clientId: '...', clientSecret: '...' })],
- * });
- *
- * // In your API route handler
- * export async function POST(req: Request) {
- *   const providerTokens = JSON.parse(req.headers.get('x-integrate-tokens') || '{}');
- *
- *   const tools = convertMCPToolsToVercelAI(serverClient, { providerTokens });
- *
- *   const result = await generateText({
- *     model: openai('gpt-4'),
- *     prompt: 'Create a GitHub issue',
- *     tools,
- *   });
- *
- *   return Response.json(result);
- * }
- * ```
- */
-export declare function convertMCPToolsToVercelAI(client: MCPClient<any>, options?: VercelAIToolsOptions): Record<string, any>;
 /**
  * Get tools in a format compatible with Vercel AI SDK v5's tools parameter
  *

package/dist/ai/vercel-ai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vercel-ai.d.ts","sourceRoot":"","sources":["../../../src/ai/vercel-ai.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC5B,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,cAAc;IAC1D,kDAAkD;IAClD,OAAO,CAAC,EAAE,UAAU,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,YAAY,CAcd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CASrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,oBAAoB,gCAkB/B"}
+{"version":3,"file":"vercel-ai.d.ts","sourceRoot":"","sources":["../../../src/ai/vercel-ai.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC5B,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,cAAc;IAC1D,kDAAkD;IAClD,OAAO,CAAC,EAAE,UAAU,CAAC;CACtB;AA+BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,oBAAoB,gCAyB/B"}

package/dist/ai/vercel-ai.js

@@ -4215,14 +4215,6 @@ function convertMCPToolToVercelAI(mcpTool, client, options) {
     }
   };
 }
-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;
@@ -4232,10 +4224,13 @@ async function getVercelAITools(client, options) {
     } catch {}
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
-  return convertMCPToolsToVercelAI(client, finalOptions);
+  const mcpTools = client.getEnabledTools();
+  const vercelTools = {};
+  for (const mcpTool of mcpTools) {
+    vercelTools[mcpTool.name] = convertMCPToolToVercelAI(mcpTool, client, finalOptions);
+  }
+  return vercelTools;
 }
 export {
-  getVercelAITools,
-  convertMCPToolsToVercelAI,
-  convertMCPToolToVercelAI
+  getVercelAITools
 };

package/dist/index.d.ts

@@ -52,5 +52,5 @@ export * from './src/index.js';
  * const messages = await client.gmail.listMessages({});
  * ```
  */
-export declare const client: import("./index.js").MCPClient<(import("./index.js").MCPIntegration<"github"> | import("./index.js").MCPIntegration<"gmail">)[]>;
+export declare const client: import("./index.js").MCPClient<(import("./index.js").MCPIntegration<"github"> | import("./index.js").MCPIntegration<"gmail"> | import("./index.js").MCPIntegration<"notion">)[]>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,cAAc,gBAAgB,CAAC;AAO/B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,MAAM,kIAKjB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,cAAc,gBAAgB,CAAC;AAQ/B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,MAAM,kLAMjB,CAAC"}