integrate-sdk 0.6.6 → 0.6.7

package/dist/src/integrations/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * AI Provider Integrations
+ *
+ * Unified interface for all AI provider integrations
+ */
+import type { MCPClient } from "../client.js";
+import type { AIToolsOptions } from "./utils.js";
+export * from "./vercel-ai.js";
+export * from "./openai.js";
+export * from "./openai-agents.js";
+export * from "./anthropic.js";
+export * from "./google.js";
+export * from "./cloudflare.js";
+export * from "./langchain.js";
+export * from "./llamaindex.js";
+export * from "./mastra.js";
+export * from "./utils.js";
+/**
+ * Supported AI provider names
+ */
+export type AIProviderName = "vercel-ai" | "openai" | "openai-agents" | "anthropic" | "google" | "cloudflare" | "langchain" | "llamaindex" | "mastra";
+/**
+ * Generic function to get AI tools for any supported provider
+ *
+ * This provides a unified interface for getting tools from any AI provider.
+ * Use this when you want to dynamically switch between providers or support multiple providers.
+ *
+ * @param client - The MCP client instance
+ * @param provider - The AI provider name
+ * @param options - Optional configuration including provider tokens for server-side usage
+ * @returns Tools in the format expected by the specified provider
+ *
+ * @example
+ * ```typescript
+ * // Dynamic provider selection
+ * import { createMCPClient, githubPlugin } from 'integrate-sdk';
+ * import { getAITools } from 'integrate-sdk/integrations';
+ *
+ * const client = createMCPClient({
+ *   plugins: [githubPlugin({ clientId: '...' })],
+ * });
+ *
+ * // Choose provider at runtime
+ * const provider = process.env.AI_PROVIDER || 'openai';
+ * const tools = await getAITools(client, provider as any);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side with provider tokens
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ * import { getAITools } from 'integrate-sdk/integrations';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   plugins: [githubPlugin({
+ *     clientId: '...',
+ *     clientSecret: '...'
+ *   })],
+ * });
+ *
+ * export async function POST(req: Request) {
+ *   const providerTokens = JSON.parse(req.headers.get('x-integrate-tokens') || '{}');
+ *
+ *   // Support multiple providers
+ *   const tools = await getAITools(serverClient, 'anthropic', { providerTokens });
+ *   // ... use with Anthropic SDK
+ * }
+ * ```
+ */
+export declare function getAITools(client: MCPClient<any>, provider: "vercel-ai", options?: AIToolsOptions): Promise<Record<string, any>>;
+export declare function getAITools(client: MCPClient<any>, provider: "openai", options?: AIToolsOptions): Promise<Array<any>>;
+export declare function getAITools(client: MCPClient<any>, provider: "openai-agents", options?: AIToolsOptions): Promise<Array<any>>;
+export declare function getAITools(client: MCPClient<any>, provider: "anthropic", options?: AIToolsOptions): Promise<Array<any>>;
+export declare function getAITools(client: MCPClient<any>, provider: "google", options?: AIToolsOptions): Promise<Array<any>>;
+export declare function getAITools(client: MCPClient<any>, provider: "cloudflare", options?: AIToolsOptions): Promise<Record<string, any>>;
+export declare function getAITools(client: MCPClient<any>, provider: "langchain", options?: AIToolsOptions): Promise<Array<any>>;
+export declare function getAITools(client: MCPClient<any>, provider: "llamaindex", options?: AIToolsOptions): Promise<Array<any>>;
+export declare function getAITools(client: MCPClient<any>, provider: "mastra", options?: AIToolsOptions): Promise<Record<string, any>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/integrations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/integrations/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAa3B;;GAEG;AACH,MAAM,MAAM,cAAc,GACtB,WAAW,GACX,QAAQ,GACR,eAAe,GACf,WAAW,GACX,QAAQ,GACR,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,QAAQ,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE,WAAW,EACrB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;AAEhC,wBAAsB,UAAU,CAC9B,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAsB,UAAU,CAC9B,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE,eAAe,EACzB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAsB,UAAU,CAC9B,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE,WAAW,EACrB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAsB,UAAU,CAC9B,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAsB,UAAU,CAC9B,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE,YAAY,EACtB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;AAEhC,wBAAsB,UAAU,CAC9B,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE,WAAW,EACrB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAsB,UAAU,CAC9B,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE,YAAY,EACtB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAsB,UAAU,CAC9B,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC"}

package/dist/src/integrations/langchain.d.ts

@@ -0,0 +1,139 @@
+/**
+ * LangChain Integration
+ *
+ * Helper functions to convert MCP tools to LangChain DynamicStructuredTool format
+ */
+import { z } from "zod";
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * LangChain DynamicStructuredTool definition
+ * Compatible with @langchain/core/tools
+ */
+export interface LangChainTool {
+    name: string;
+    description: string;
+    schema: z.ZodType<any>;
+    func: (...args: any[]) => Promise<string>;
+}
+/**
+ * Options for converting MCP tools to LangChain format
+ */
+export interface LangChainToolsOptions extends AIToolsOptions {
+}
+/**
+ * Convert a single MCP tool to LangChain DynamicStructuredTool 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
+ * @returns LangChain compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const langchainTool = convertMCPToolToLangChain(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToLangChain(mcpTool: MCPTool, client: MCPClient<any>, options?: LangChainToolsOptions): LangChainTool;
+/**
+ * Convert all enabled MCP tools to LangChain DynamicStructuredTool format
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of LangChain compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToLangChain(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToLangChain(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToLangChain(client: MCPClient<any>, options?: LangChainToolsOptions): LangChainTool[];
+/**
+ * Get tools in a format compatible with LangChain
+ *
+ * Automatically connects the client if not already connected.
+ * Returns tool definitions that can be used with DynamicStructuredTool.
+ *
+ * @param client - The MCP client instance
+ * @param options - Optional configuration including provider tokens for server-side usage
+ * @returns Array of tools ready to use with LangChain
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * import { createMCPClient, githubPlugin } from 'integrate-sdk';
+ * import { getLangChainTools } from 'integrate-sdk/integrations/langchain';
+ * import { DynamicStructuredTool } from '@langchain/core/tools';
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { AgentExecutor, createOpenAIFunctionsAgent } from 'langchain/agents';
+ *
+ * const client = createMCPClient({
+ *   plugins: [githubPlugin({ clientId: '...' })],
+ * });
+ *
+ * const toolConfigs = await getLangChainTools(client);
+ *
+ * // Create DynamicStructuredTools from configs
+ * const tools = toolConfigs.map(config =>
+ *   new DynamicStructuredTool(config)
+ * );
+ *
+ * const model = new ChatOpenAI({ temperature: 0 });
+ * const agent = await createOpenAIFunctionsAgent({
+ *   llm: model,
+ *   tools
+ * });
+ *
+ * const executor = new AgentExecutor({ agent, tools });
+ * const result = await executor.invoke({
+ *   input: "Create a GitHub issue"
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ * import { getLangChainTools } from 'integrate-sdk/integrations/langchain';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   plugins: [githubPlugin({
+ *     clientId: '...',
+ *     clientSecret: '...'
+ *   })],
+ * });
+ *
+ * // In your API route
+ * export async function POST(req: Request) {
+ *   const providerTokens = JSON.parse(req.headers.get('x-integrate-tokens') || '{}');
+ *   const toolConfigs = await getLangChainTools(serverClient, { providerTokens });
+ *
+ *   // Create DynamicStructuredTools
+ *   const tools = toolConfigs.map(config =>
+ *     new DynamicStructuredTool(config)
+ *   );
+ *
+ *   const model = new ChatOpenAI({ temperature: 0 });
+ *   const agent = await createOpenAIFunctionsAgent({
+ *     llm: model,
+ *     tools
+ *   });
+ *
+ *   const executor = new AgentExecutor({ agent, tools });
+ *   const result = await executor.invoke({
+ *     input: "Create a GitHub issue"
+ *   });
+ *
+ *   return Response.json(result);
+ * }
+ * ```
+ */
+export declare function getLangChainTools(client: MCPClient<any>, options?: LangChainToolsOptions): Promise<LangChainTool[]>;
+//# sourceMappingURL=langchain.d.ts.map

package/dist/src/integrations/langchain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain.d.ts","sourceRoot":"","sources":["../../../src/integrations/langchain.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,EAIL,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACvB,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,cAAc;CAAG;AAEhE;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,CAYf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,EAAE,CAGjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,aAAa,EAAE,CAAC,CAG1B"}

package/dist/src/integrations/llamaindex.d.ts

@@ -0,0 +1,125 @@
+/**
+ * LlamaIndex Integration
+ *
+ * Helper functions to convert MCP tools to LlamaIndex tool format
+ */
+import { z } from "zod";
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * LlamaIndex tool definition
+ * Compatible with llamaindex package
+ */
+export interface LlamaIndexTool {
+    name: string;
+    description: string;
+    parameters: z.ZodType<any>;
+    execute: (input: Record<string, unknown>) => Promise<string>;
+}
+/**
+ * Options for converting MCP tools to LlamaIndex format
+ */
+export interface LlamaIndexToolsOptions extends AIToolsOptions {
+}
+/**
+ * Convert a single MCP tool to LlamaIndex 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
+ * @returns LlamaIndex compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const llamaIndexTool = convertMCPToolToLlamaIndex(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToLlamaIndex(mcpTool: MCPTool, client: MCPClient<any>, options?: LlamaIndexToolsOptions): LlamaIndexTool;
+/**
+ * Convert all enabled MCP tools to LlamaIndex format
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of LlamaIndex compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToLlamaIndex(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToLlamaIndex(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToLlamaIndex(client: MCPClient<any>, options?: LlamaIndexToolsOptions): LlamaIndexTool[];
+/**
+ * Get tools in a format compatible with LlamaIndex
+ *
+ * Automatically connects the client if not already connected.
+ * Returns tool configurations that can be used with LlamaIndex's tool system.
+ *
+ * @param client - The MCP client instance
+ * @param options - Optional configuration including provider tokens for server-side usage
+ * @returns Array of tools ready to use with LlamaIndex
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * import { createMCPClient, githubPlugin } from 'integrate-sdk';
+ * import { getLlamaIndexTools } from 'integrate-sdk/integrations/llamaindex';
+ * import { OpenAIAgent, tool } from 'llamaindex';
+ *
+ * const client = createMCPClient({
+ *   plugins: [githubPlugin({ clientId: '...' })],
+ * });
+ *
+ * const toolConfigs = await getLlamaIndexTools(client);
+ *
+ * // Create LlamaIndex tools
+ * const tools = toolConfigs.map(config =>
+ *   tool(config)
+ * );
+ *
+ * const agent = new OpenAIAgent({ tools });
+ * const response = await agent.chat({
+ *   message: "Create a GitHub issue"
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ * import { getLlamaIndexTools } from 'integrate-sdk/integrations/llamaindex';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   plugins: [githubPlugin({
+ *     clientId: '...',
+ *     clientSecret: '...'
+ *   })],
+ * });
+ *
+ * // In your API route
+ * export async function POST(req: Request) {
+ *   const providerTokens = JSON.parse(req.headers.get('x-integrate-tokens') || '{}');
+ *   const toolConfigs = await getLlamaIndexTools(serverClient, { providerTokens });
+ *
+ *   // Create LlamaIndex tools
+ *   const tools = toolConfigs.map(config =>
+ *     tool(config)
+ *   );
+ *
+ *   const agent = new OpenAIAgent({ tools });
+ *   const response = await agent.chat({
+ *     message: "Create a GitHub issue"
+ *   });
+ *
+ *   return Response.json(response);
+ * }
+ * ```
+ */
+export declare function getLlamaIndexTools(client: MCPClient<any>, options?: LlamaIndexToolsOptions): Promise<LlamaIndexTool[]>;
+//# sourceMappingURL=llamaindex.d.ts.map

package/dist/src/integrations/llamaindex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llamaindex.d.ts","sourceRoot":"","sources":["../../../src/integrations/llamaindex.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,EAIL,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC3B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC9D;AAED;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,cAAc;CAAG;AAEjE;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,cAAc,CAUhB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,cAAc,EAAE,CAGlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,cAAc,EAAE,CAAC,CAG3B"}

package/dist/src/integrations/mastra.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Mastra AI SDK Integration
+ *
+ * Helper functions to convert MCP tools to Mastra AI SDK format
+ */
+import { z } from "zod";
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * Mastra tool definition
+ * Compatible with @mastra/core
+ */
+export interface MastraTool {
+    id: string;
+    description: string;
+    inputSchema?: z.ZodType<any>;
+    outputSchema?: z.ZodType<any>;
+    execute: (params: {
+        context: Record<string, unknown>;
+    }) => Promise<any>;
+}
+/**
+ * Options for converting MCP tools to Mastra format
+ */
+export interface MastraToolsOptions extends AIToolsOptions {
+}
+/**
+ * Convert a single MCP tool to Mastra 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
+ * @returns Mastra compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const mastraTool = convertMCPToolToMastra(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToMastra(mcpTool: MCPTool, client: MCPClient<any>, options?: MastraToolsOptions): MastraTool;
+/**
+ * Convert all enabled MCP tools to Mastra AI SDK format
+ * Returns a dictionary keyed by tool ID
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Dictionary of Mastra compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToMastra(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToMastra(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToMastra(client: MCPClient<any>, options?: MastraToolsOptions): Record<string, MastraTool>;
+/**
+ * Get tools in a format compatible with Mastra AI SDK
+ *
+ * Automatically connects the client if not already connected.
+ * Returns tool configurations that can be used with Mastra's tool system.
+ *
+ * @param client - The MCP client instance
+ * @param options - Optional configuration including provider tokens for server-side usage
+ * @returns Dictionary of tools ready to use with Mastra AI SDK
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * import { createMCPClient, githubPlugin } from 'integrate-sdk';
+ * import { getMastraTools } from 'integrate-sdk/integrations/mastra';
+ * import { createTool, Agent } from '@mastra/core';
+ *
+ * const client = createMCPClient({
+ *   plugins: [githubPlugin({ clientId: '...' })],
+ * });
+ *
+ * const toolConfigs = await getMastraTools(client);
+ *
+ * // Create Mastra tools
+ * const tools = Object.fromEntries(
+ *   Object.entries(toolConfigs).map(([id, config]) => [
+ *     id,
+ *     createTool(config)
+ *   ])
+ * );
+ *
+ * const agent = new Agent({
+ *   tools,
+ *   model: { provider: 'openai', name: 'gpt-4' }
+ * });
+ *
+ * const result = await agent.generate('Create a GitHub issue');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ * import { getMastraTools } from 'integrate-sdk/integrations/mastra';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   plugins: [githubPlugin({
+ *     clientId: '...',
+ *     clientSecret: '...'
+ *   })],
+ * });
+ *
+ * // In your API route
+ * export async function POST(req: Request) {
+ *   const providerTokens = JSON.parse(req.headers.get('x-integrate-tokens') || '{}');
+ *   const toolConfigs = await getMastraTools(serverClient, { providerTokens });
+ *
+ *   // Create Mastra tools
+ *   const tools = Object.fromEntries(
+ *     Object.entries(toolConfigs).map(([id, config]) => [
+ *       id,
+ *       createTool(config)
+ *     ])
+ *   );
+ *
+ *   const agent = new Agent({
+ *     tools,
+ *     model: { provider: 'openai', name: 'gpt-4' }
+ *   });
+ *
+ *   const result = await agent.generate('Create a GitHub issue');
+ *   return Response.json(result);
+ * }
+ * ```
+ */
+export declare function getMastraTools(client: MCPClient<any>, options?: MastraToolsOptions): Promise<Record<string, MastraTool>>;
+//# sourceMappingURL=mastra.d.ts.map

package/dist/src/integrations/mastra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mastra.d.ts","sourceRoot":"","sources":["../../../src/integrations/mastra.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,EAIL,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC7B,YAAY,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC9B,OAAO,EAAE,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACzE;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;CAAG;AAE7D;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,UAAU,CAUZ;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAS5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAGrC"}

package/dist/src/integrations/openai-agents.d.ts

@@ -0,0 +1,117 @@
+/**
+ * OpenAI Agents Integration
+ *
+ * Helper functions to convert MCP tools to @openai/agents format
+ */
+import { z } from "zod";
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * OpenAI Agents tool definition
+ * Compatible with @openai/agents package
+ */
+export interface OpenAIAgentsTool {
+    name: string;
+    description: string;
+    parameters: z.ZodType<any>;
+    execute: (args: any) => Promise<any>;
+}
+/**
+ * Options for converting MCP tools to OpenAI Agents format
+ */
+export interface OpenAIAgentsToolsOptions extends AIToolsOptions {
+}
+/**
+ * Convert a single MCP tool to OpenAI Agents 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
+ * @returns OpenAI Agents compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const agentTool = convertMCPToolToOpenAIAgents(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToOpenAIAgents(mcpTool: MCPTool, client: MCPClient<any>, options?: OpenAIAgentsToolsOptions): OpenAIAgentsTool;
+/**
+ * Convert all enabled MCP tools to OpenAI Agents format
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of OpenAI Agents compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToOpenAIAgents(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToOpenAIAgents(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToOpenAIAgents(client: MCPClient<any>, options?: OpenAIAgentsToolsOptions): OpenAIAgentsTool[];
+/**
+ * Get tools in a format compatible with @openai/agents
+ *
+ * Automatically connects the client if not already connected.
+ *
+ * @param client - The MCP client instance
+ * @param options - Optional configuration including provider tokens for server-side usage
+ * @returns Array of tools ready to use with @openai/agents
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * import { createMCPClient, githubPlugin } from 'integrate-sdk';
+ * import { getOpenAIAgentsTools } from 'integrate-sdk/integrations/openai-agents';
+ * import { Agent } from '@openai/agents';
+ *
+ * const client = createMCPClient({
+ *   plugins: [githubPlugin({ clientId: '...' })],
+ * });
+ *
+ * const tools = await getOpenAIAgentsTools(client);
+ *
+ * const agent = new Agent({
+ *   model: 'gpt-4o',
+ *   tools,
+ * });
+ *
+ * const result = await agent.run('Create a GitHub issue');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ * import { getOpenAIAgentsTools } from 'integrate-sdk/integrations/openai-agents';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   plugins: [githubPlugin({
+ *     clientId: '...',
+ *     clientSecret: '...'
+ *   })],
+ * });
+ *
+ * // In your API route
+ * export async function POST(req: Request) {
+ *   const providerTokens = JSON.parse(req.headers.get('x-integrate-tokens') || '{}');
+ *   const tools = await getOpenAIAgentsTools(serverClient, { providerTokens });
+ *
+ *   const agent = new Agent({
+ *     model: 'gpt-4o',
+ *     tools,
+ *   });
+ *
+ *   const result = await agent.run('Create a GitHub issue');
+ *   return Response.json({ result });
+ * }
+ * ```
+ */
+export declare function getOpenAIAgentsTools(client: MCPClient<any>, options?: OpenAIAgentsToolsOptions): Promise<OpenAIAgentsTool[]>;
+//# sourceMappingURL=openai-agents.d.ts.map

package/dist/src/integrations/openai-agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-agents.d.ts","sourceRoot":"","sources":["../../../src/integrations/openai-agents.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,EAIL,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC3B,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,cAAc;CAAG;AAEnE;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,wBAAwB,GACjC,gBAAgB,CASlB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,wBAAwB,GACjC,gBAAgB,EAAE,CAGpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAG7B"}