@mcpilotx/intentorch 0.5.0

package/dist/mcp/index.d.ts

@@ -0,0 +1,162 @@
+/**
+ * MCP (Model Context Protocol) Module Entry
+ * Provides complete MCP protocol support, focusing on MCP tool management
+ */
+export * from './types';
+export * from './transport';
+export * from './client';
+export * from './tool-registry';
+/**
+ * Create MCP client configuration
+ */
+export declare function createMCPConfig(transportType: 'stdio' | 'http' | 'sse', options: {
+    command?: string;
+    args?: string[];
+    url?: string;
+    headers?: Record<string, string>;
+    autoConnect?: boolean;
+    timeout?: number;
+    maxRetries?: number;
+}): {
+    autoConnect?: boolean;
+    timeout?: number;
+    maxRetries?: number;
+    transport: {
+        url: string;
+        headers: Record<string, string>;
+        command: string;
+        args: string[];
+        type: "stdio" | "http" | "sse";
+    };
+};
+/**
+ * Tool category constants
+ */
+export declare const TOOL_CATEGORIES: {
+    readonly FILESYSTEM: "filesystem";
+    readonly NETWORK: "network";
+    readonly DATABASE: "database";
+    readonly AI: "ai";
+    readonly UTILITY: "utility";
+    readonly DEVELOPMENT: "development";
+    readonly SYSTEM: "system";
+};
+/**
+ * Predefined tool patterns (for tool discovery and classification)
+ */
+export declare const TOOL_PATTERNS: {
+    readonly READ_FILE: {
+        readonly name: "read_file";
+        readonly description: "Read file content";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly path: {
+                    readonly type: "string";
+                    readonly description: "File path";
+                };
+                readonly encoding: {
+                    readonly type: "string";
+                    readonly description: "Encoding format";
+                    readonly default: "utf-8";
+                };
+            };
+            readonly required: readonly ["path"];
+        };
+    };
+    readonly WRITE_FILE: {
+        readonly name: "write_file";
+        readonly description: "Write file content";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly path: {
+                    readonly type: "string";
+                    readonly description: "File path";
+                };
+                readonly content: {
+                    readonly type: "string";
+                    readonly description: "File content";
+                };
+                readonly encoding: {
+                    readonly type: "string";
+                    readonly description: "Encoding format";
+                    readonly default: "utf-8";
+                };
+            };
+            readonly required: readonly ["path", "content"];
+        };
+    };
+    readonly HTTP_REQUEST: {
+        readonly name: "http_request";
+        readonly description: "Send HTTP request";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly url: {
+                    readonly type: "string";
+                    readonly description: "Request URL";
+                };
+                readonly method: {
+                    readonly type: "string";
+                    readonly description: "HTTP method";
+                    readonly default: "GET";
+                };
+                readonly headers: {
+                    readonly type: "object";
+                    readonly description: "Request headers";
+                };
+                readonly body: {
+                    readonly type: "string";
+                    readonly description: "Request body";
+                };
+            };
+            readonly required: readonly ["url"];
+        };
+    };
+    readonly EXECUTE_COMMAND: {
+        readonly name: "execute_command";
+        readonly description: "Execute system command";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly command: {
+                    readonly type: "string";
+                    readonly description: "Command to execute";
+                };
+                readonly args: {
+                    readonly type: "array";
+                    readonly description: "Command arguments";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly cwd: {
+                    readonly type: "string";
+                    readonly description: "Working directory";
+                };
+            };
+            readonly required: readonly ["command"];
+        };
+    };
+};
+/**
+ * Discover local MCP servers
+ * Returns predefined common MCP server configurations
+ */
+export declare function discoverLocalMCPServers(): Promise<Array<{
+    name: string;
+    transport: any;
+}>>;
+/**
+ * Load MCP server configurations from environment variables
+ */
+export declare function loadMCPServersFromEnv(): Array<{
+    name: string;
+    transport: any;
+}>;
+/**
+ * Default export MCPClient class
+ */
+export { MCPClient as default } from './client';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.js

@@ -0,0 +1,199 @@
+/**
+ * MCP (Model Context Protocol) Module Entry
+ * Provides complete MCP protocol support, focusing on MCP tool management
+ */
+// Export type definitions
+export * from './types.js';
+// Export transport layer
+export * from './transport.js';
+// Export client
+export * from './client.js';
+// Export tool registry
+export * from './tool-registry.js';
+// ==================== Utility Functions ====================
+/**
+ * Create MCP client configuration
+ */
+export function createMCPConfig(transportType, options) {
+    const { command, args, url, headers, ...clientOptions } = options;
+    return {
+        transport: {
+            type: transportType,
+            ...(transportType === 'stdio' && command && { command, args }),
+            ...(transportType === 'http' && url && { url, headers }),
+            ...(transportType === 'sse' && url && { url, headers }),
+        },
+        ...clientOptions,
+    };
+}
+/**
+ * Tool category constants
+ */
+export const TOOL_CATEGORIES = {
+    FILESYSTEM: 'filesystem',
+    NETWORK: 'network',
+    DATABASE: 'database',
+    AI: 'ai',
+    UTILITY: 'utility',
+    DEVELOPMENT: 'development',
+    SYSTEM: 'system',
+};
+/**
+ * Predefined tool patterns (for tool discovery and classification)
+ */
+export const TOOL_PATTERNS = {
+    // Filesystem tools
+    READ_FILE: {
+        name: 'read_file',
+        description: 'Read file content',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'File path' },
+                encoding: { type: 'string', description: 'Encoding format', default: 'utf-8' },
+            },
+            required: ['path'],
+        },
+    },
+    WRITE_FILE: {
+        name: 'write_file',
+        description: 'Write file content',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'File path' },
+                content: { type: 'string', description: 'File content' },
+                encoding: { type: 'string', description: 'Encoding format', default: 'utf-8' },
+            },
+            required: ['path', 'content'],
+        },
+    },
+    // Network tools
+    HTTP_REQUEST: {
+        name: 'http_request',
+        description: 'Send HTTP request',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'Request URL' },
+                method: { type: 'string', description: 'HTTP method', default: 'GET' },
+                headers: { type: 'object', description: 'Request headers' },
+                body: { type: 'string', description: 'Request body' },
+            },
+            required: ['url'],
+        },
+    },
+    // System tools
+    EXECUTE_COMMAND: {
+        name: 'execute_command',
+        description: 'Execute system command',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'Command to execute' },
+                args: { type: 'array', description: 'Command arguments', items: { type: 'string' } },
+                cwd: { type: 'string', description: 'Working directory' },
+            },
+            required: ['command'],
+        },
+    },
+};
+// ==================== Tool Discovery Helper Functions ====================
+/**
+ * Discover local MCP servers
+ * Returns predefined common MCP server configurations
+ */
+export async function discoverLocalMCPServers() {
+    const servers = [];
+    // Predefined common MCP servers
+    const commonServers = [
+        // Filesystem server
+        {
+            name: 'filesystem',
+            command: 'npx',
+            args: ['@modelcontextprotocol/server-filesystem'],
+        },
+        // Clock server
+        {
+            name: 'clock',
+            command: 'npx',
+            args: ['@modelcontextprotocol/server-clock'],
+        },
+        // GitHub server
+        {
+            name: 'github',
+            command: 'npx',
+            args: ['@modelcontextprotocol/server-github'],
+        },
+    ];
+    for (const server of commonServers) {
+        servers.push({
+            name: server.name,
+            transport: {
+                type: 'stdio',
+                command: server.command,
+                args: server.args,
+            },
+        });
+    }
+    return servers;
+}
+/**
+ * Load MCP server configurations from environment variables
+ */
+export function loadMCPServersFromEnv() {
+    const servers = [];
+    // Read MCP server configurations from environment variables
+    // Format: MCP_SERVER_<NAME>_TYPE=stdio|http|sse
+    //         MCP_SERVER_<NAME>_COMMAND=command (for stdio)
+    //         MCP_SERVER_<NAME>_URL=url (for http/sse)
+    const envPrefix = 'MCP_SERVER_';
+    Object.keys(process.env).forEach(key => {
+        if (key.startsWith(envPrefix) && key.endsWith('_TYPE')) {
+            const serverName = key.slice(envPrefix.length, -5).toLowerCase();
+            const transportType = process.env[key];
+            const transport = { type: transportType };
+            if (transportType === 'stdio') {
+                const commandKey = `${envPrefix}${serverName.toUpperCase()}_COMMAND`;
+                const argsKey = `${envPrefix}${serverName.toUpperCase()}_ARGS`;
+                if (process.env[commandKey]) {
+                    transport.command = process.env[commandKey];
+                    if (process.env[argsKey]) {
+                        try {
+                            transport.args = JSON.parse(process.env[argsKey]);
+                        }
+                        catch {
+                            transport.args = process.env[argsKey].split(' ');
+                        }
+                    }
+                }
+            }
+            else if (transportType === 'http' || transportType === 'sse') {
+                const urlKey = `${envPrefix}${serverName.toUpperCase()}_URL`;
+                const headersKey = `${envPrefix}${serverName.toUpperCase()}_HEADERS`;
+                if (process.env[urlKey]) {
+                    transport.url = process.env[urlKey];
+                    if (process.env[headersKey]) {
+                        try {
+                            transport.headers = JSON.parse(process.env[headersKey]);
+                        }
+                        catch {
+                            // Ignore parsing errors
+                        }
+                    }
+                }
+            }
+            servers.push({
+                name: serverName,
+                transport,
+            });
+        }
+    });
+    return servers;
+}
+// ==================== Default Export ====================
+/**
+ * Default export MCPClient class
+ */
+export { MCPClient as default } from './client.js';
+//# sourceMappingURL=index.js.map

package/dist/mcp/tool-registry.d.ts

@@ -0,0 +1,71 @@
+/**
+ * MCP Tool Registration and Management
+ * Focuses on MCP tool management, providing tool registration, discovery, execution and other functions
+ */
+import { Tool, ToolCall, ToolResult } from './types';
+export interface ToolExecutor {
+    (args: Record<string, any>): Promise<ToolResult>;
+}
+export interface RegisteredTool {
+    tool: Tool;
+    executor: ToolExecutor;
+    metadata: {
+        serverId: string;
+        serverName?: string;
+        discoveredAt: number;
+        lastUsed?: number;
+        usageCount?: number;
+    };
+}
+/**
+ * MCP Tool Registry
+ * Focuses on managing tools discovered from MCP servers
+ */
+export declare class ToolRegistry {
+    private tools;
+    private serverTools;
+    /**
+     * Register tool
+     */
+    registerTool(tool: Tool, executor: ToolExecutor, serverId: string, serverName?: string): void;
+    /**
+     * Batch register tools
+     */
+    registerTools(tools: Tool[], executorFactory: (toolName: string) => ToolExecutor, serverId: string, serverName?: string): void;
+    /**
+     * Unregister tool
+     */
+    unregisterTool(toolName: string): boolean;
+    /**
+     * Unregister all tools for specified server
+     */
+    unregisterServerTools(serverId: string): boolean;
+    /**
+     * Execute tool
+     */
+    executeTool(toolCall: ToolCall): Promise<ToolResult>;
+    getTool(name: string): RegisteredTool | undefined;
+    getAllTools(): RegisteredTool[];
+    getToolsByServer(serverId: string): RegisteredTool[];
+    getServerIds(): string[];
+    /**
+     * Get connected servers with their names
+     */
+    getConnectedServers(): string[];
+    searchTools(query: string): RegisteredTool[];
+    private validateToolArguments;
+    getToolStatistics(): {
+        totalTools: number;
+        byServer: Record<string, number>;
+        mostUsed: {
+            name: string;
+            serverId: string;
+            serverName: string;
+            usageCount: number;
+            lastUsed: number;
+        }[];
+    };
+    private emitToolUpdate;
+    clear(): void;
+}
+//# sourceMappingURL=tool-registry.d.ts.map