integrate-sdk 0.8.39 → 0.8.41-dev.0

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

@@ -1,158 +0,0 @@
-/**
- * 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, githubIntegration } from 'integrate-sdk';
- * import { getCloudflareTools, executeCloudflareToolCall } from 'integrate-sdk/ai/cloudflare';
- *
- * export default {
- *   async fetch(request: Request, env: Env): Promise<Response> {
- *     const client = createMCPClient({
- *       integrations: [githubIntegration({ 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, githubIntegration } from 'integrate-sdk/server';
- * import { getCloudflareTools, executeCloudflareToolCall } from 'integrate-sdk/ai/cloudflare';
- *
- * const { client: serverClient } = createMCPServer({
- *   integrations: [githubIntegration({
- *     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/ai/cloudflare.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../../src/ai/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,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjH;;;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,CAezC"}

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

@@ -1,139 +0,0 @@
-/**
- * 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, githubIntegration } from 'integrate-sdk';
- * import { getLangChainTools } from 'integrate-sdk/ai/langchain';
- * import { DynamicStructuredTool } from '@langchain/core/tools';
- * import { ChatOpenAI } from '@langchain/openai';
- * import { AgentExecutor, createOpenAIFunctionsAgent } from 'langchain/agents';
- *
- * const client = createMCPClient({
- *   integrations: [githubIntegration({ 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, githubIntegration } from 'integrate-sdk/server';
- * import { getLangChainTools } from 'integrate-sdk/ai/langchain';
- *
- * const { client: serverClient } = createMCPServer({
- *   integrations: [githubIntegration({
- *     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/ai/langchain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"langchain.d.ts","sourceRoot":"","sources":["../../../src/ai/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,EAKL,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;CAAI;AAEjE;;;;;;;;;;;;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,CAe1B"}

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

@@ -1,125 +0,0 @@
-/**
- * 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, githubIntegration } from 'integrate-sdk';
- * import { getLlamaIndexTools } from 'integrate-sdk/ai/llamaindex';
- * import { OpenAIAgent, tool } from 'llamaindex';
- *
- * const client = createMCPClient({
- *   integrations: [githubIntegration({ 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, githubIntegration } from 'integrate-sdk/server';
- * import { getLlamaIndexTools } from 'integrate-sdk/ai/llamaindex';
- *
- * const { client: serverClient } = createMCPServer({
- *   integrations: [githubIntegration({
- *     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/ai/llamaindex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"llamaindex.d.ts","sourceRoot":"","sources":["../../../src/ai/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,EAKL,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;CAAI;AAElE;;;;;;;;;;;;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,CAe3B"}

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

@@ -1,138 +0,0 @@
-/**
- * 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, githubIntegration } from 'integrate-sdk';
- * import { getMastraTools } from 'integrate-sdk/ai/mastra';
- * import { createTool, Agent } from '@mastra/core';
- *
- * const client = createMCPClient({
- *   integrations: [githubIntegration({ 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, githubIntegration } from 'integrate-sdk/server';
- * import { getMastraTools } from 'integrate-sdk/ai/mastra';
- *
- * const { client: serverClient } = createMCPServer({
- *   integrations: [githubIntegration({
- *     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/ai/mastra.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mastra.d.ts","sourceRoot":"","sources":["../../../src/ai/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,EAKL,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;CAAI;AAE9D;;;;;;;;;;;;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,CAerC"}