integrate-sdk 0.6.6 → 0.6.8

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

@@ -0,0 +1,158 @@
+/**
+ * Cloudflare Workers AI Integration
+ *
+ * Helper functions to convert MCP tools to Cloudflare Workers AI format
+ */
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * Cloudflare AI tool definition
+ * Compatible with Cloudflare Workers AI
+ */
+export interface CloudflareTool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, {
+                type: string;
+                description?: string;
+            }>;
+            required: string[];
+        };
+    };
+}
+/**
+ * Options for converting MCP tools to Cloudflare format
+ */
+export interface CloudflareToolsOptions extends AIToolsOptions {
+}
+/**
+ * Convert a single MCP tool to Cloudflare Workers AI 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 Cloudflare compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const cloudflareTool = convertMCPToolToCloudflare(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToCloudflare(mcpTool: MCPTool, _client: MCPClient<any>, _options?: CloudflareToolsOptions): CloudflareTool;
+/**
+ * Convert all enabled MCP tools to Cloudflare Workers AI format
+ * Returns a dictionary keyed by tool name
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Dictionary of Cloudflare compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToCloudflare(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToCloudflare(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToCloudflare(client: MCPClient<any>, options?: CloudflareToolsOptions): Record<string, CloudflareTool>;
+/**
+ * Execute a tool call from Cloudflare Workers AI
+ *
+ * @param client - The MCP client instance
+ * @param toolCall - The tool call with name and arguments
+ * @param options - Optional configuration including provider tokens
+ * @returns Tool execution result as JSON string
+ *
+ * @example
+ * ```typescript
+ * const result = await executeCloudflareToolCall(client, {
+ *   name: 'github_create_issue',
+ *   arguments: { owner: 'user', repo: 'repo', title: 'Bug' }
+ * }, { providerTokens });
+ * ```
+ */
+export declare function executeCloudflareToolCall(client: MCPClient<any>, toolCall: {
+    name: string;
+    arguments: Record<string, unknown> | string;
+}, options?: CloudflareToolsOptions): Promise<string>;
+/**
+ * Get tools in a format compatible with Cloudflare Workers AI
+ *
+ * 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 Dictionary of tools ready to use with Cloudflare Workers AI
+ *
+ * @example
+ * ```typescript
+ * // Cloudflare Worker usage
+ * import { createMCPClient, githubPlugin } from 'integrate-sdk';
+ * import { getCloudflareTools, executeCloudflareToolCall } from 'integrate-sdk/integrations/cloudflare';
+ *
+ * export default {
+ *   async fetch(request: Request, env: Env): Promise<Response> {
+ *     const client = createMCPClient({
+ *       plugins: [githubPlugin({ clientId: env.GITHUB_CLIENT_ID })],
+ *     });
+ *
+ *     const tools = await getCloudflareTools(client);
+ *     const ai = new Ai(env.AI);
+ *
+ *     const response = await ai.run('@cf/meta/llama-3-8b-instruct', {
+ *       messages: [{ role: 'user', content: 'Create a GitHub issue' }],
+ *       tools: Object.values(tools)
+ *     });
+ *
+ *     return Response.json(response);
+ *   }
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ * import { getCloudflareTools, executeCloudflareToolCall } from 'integrate-sdk/integrations/cloudflare';
+ *
+ * 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 getCloudflareTools(serverClient, { providerTokens });
+ *
+ *   // Use with Cloudflare AI
+ *   const ai = new Ai(env.AI);
+ *   const response = await ai.run('@cf/meta/llama-3-8b-instruct', {
+ *     messages: [{ role: 'user', content: 'Create a GitHub issue' }],
+ *     tools: Object.values(tools)
+ *   });
+ *
+ *   // Handle tool calls
+ *   if (response.tool_calls) {
+ *     for (const toolCall of response.tool_calls) {
+ *       await executeCloudflareToolCall(serverClient, toolCall, { providerTokens });
+ *     }
+ *   }
+ *
+ *   return Response.json(response);
+ * }
+ * ```
+ */
+export declare function getCloudflareTools(client: MCPClient<any>, options?: CloudflareToolsOptions): Promise<Record<string, CloudflareTool>>;
+//# sourceMappingURL=cloudflare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../../src/integrations/cloudflare.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,EAA+C,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE9F;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE;YACV,IAAI,EAAE,QAAQ,CAAC;YACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;gBACzB,IAAI,EAAE,MAAM,CAAC;gBACb,WAAW,CAAC,EAAE,MAAM,CAAC;aACtB,CAAC,CAAC;YACH,QAAQ,EAAE,MAAM,EAAE,CAAC;SACpB,CAAC;KACH,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,cAAc;CAAI;AAElE;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,sBAAsB,GAChC,cAAc,CAahB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAShC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE;IACR,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC;CAC7C,EACD,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAGzC"}

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

@@ -0,0 +1,159 @@
+/**
+ * Google GenAI Integration
+ *
+ * Helper functions to convert MCP tools to Google GenAI format
+ */
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * Google GenAI function declaration
+ * Compatible with @google/genai SDK
+ */
+export interface GoogleTool {
+    name: string;
+    description: string;
+    parameters: {
+        type: 'object';
+        description?: string;
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [key: string]: unknown;
+    };
+}
+/**
+ * Google GenAI function call
+ */
+export interface GoogleFunctionCall {
+    name: string;
+    args: Record<string, unknown>;
+}
+/**
+ * Options for converting MCP tools to Google GenAI format
+ */
+export interface GoogleToolsOptions extends AIToolsOptions {
+}
+/**
+ * Convert a single MCP tool to Google GenAI 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 Google GenAI compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const googleTool = convertMCPToolToGoogle(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToGoogle(mcpTool: MCPTool, _client: MCPClient<any>, _options?: GoogleToolsOptions): GoogleTool;
+/**
+ * Convert all enabled MCP tools to Google GenAI format
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of Google GenAI compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToGoogle(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToGoogle(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToGoogle(client: MCPClient<any>, options?: GoogleToolsOptions): GoogleTool[];
+/**
+ * Execute a function call from Google GenAI
+ *
+ * @param client - The MCP client instance
+ * @param functionCall - The function call from Google GenAI response
+ * @param options - Optional configuration including provider tokens
+ * @returns Tool execution result as JSON string
+ *
+ * @example
+ * ```typescript
+ * const result = await executeGoogleFunctionCall(client, {
+ *   name: 'github_create_issue',
+ *   args: { owner: 'user', repo: 'repo', title: 'Bug' }
+ * }, { providerTokens });
+ * ```
+ */
+export declare function executeGoogleFunctionCall(client: MCPClient<any>, functionCall: GoogleFunctionCall, options?: GoogleToolsOptions): Promise<string>;
+/**
+ * Get tools in a format compatible with Google GenAI
+ *
+ * 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 Google GenAI
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * import { createMCPClient, githubPlugin } from 'integrate-sdk';
+ * import { getGoogleTools } from 'integrate-sdk/integrations/google';
+ * import { GoogleGenerativeAI } from '@google/generative-ai';
+ *
+ * const client = createMCPClient({
+ *   plugins: [githubPlugin({ clientId: '...' })],
+ * });
+ *
+ * const tools = await getGoogleTools(client);
+ * const genAI = new GoogleGenerativeAI('YOUR_API_KEY');
+ * const model = genAI.getGenerativeModel({
+ *   model: 'gemini-pro',
+ *   tools: [{ functionDeclarations: tools }]
+ * });
+ *
+ * const result = await model.generateContent({
+ *   contents: [{ role: 'user', parts: [{ text: 'Create a GitHub issue' }] }]
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ * import { getGoogleTools, executeGoogleFunctionCall } from 'integrate-sdk/integrations/google';
+ *
+ * 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 getGoogleTools(serverClient, { providerTokens });
+ *
+ *   const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);
+ *   const model = genAI.getGenerativeModel({
+ *     model: 'gemini-pro',
+ *     tools: [{ functionDeclarations: tools }]
+ *   });
+ *
+ *   const result = await model.generateContent({
+ *     contents: [{ role: 'user', parts: [{ text: 'Create a GitHub issue' }] }]
+ *   });
+ *
+ *   // Handle function calls if any
+ *   const functionCalls = result.response.functionCalls();
+ *   if (functionCalls) {
+ *     for (const call of functionCalls) {
+ *       await executeGoogleFunctionCall(serverClient, call, { providerTokens });
+ *     }
+ *   }
+ *
+ *   return Response.json(result.response);
+ * }
+ * ```
+ */
+export declare function getGoogleTools(client: MCPClient<any>, options?: GoogleToolsOptions): Promise<GoogleTool[]>;
+//# sourceMappingURL=google.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/integrations/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,EAA+C,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE9F;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE;QACV,IAAI,EAAE,QAAQ,CAAC;QACf,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;CAAI;AAE9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,UAAU,CAWZ;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,UAAU,EAAE,CAGd;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,YAAY,EAAE,kBAAkB,EAChC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CAGjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAGvB"}

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"}