fix: Fix TypeScript errors in MCP implementation

bhouston · bhouston · commit f5837d3a5dd2 · 2025-03-12T15:50:43.000-04:00
diff --git a/packages/agent/src/core/mcp/index.ts b/packages/agent/src/core/mcp/index.ts
@@ -1,16 +1,12 @@
 /**
  * Model Context Protocol (MCP) Integration
- *
+ * 
  * This module provides integration with the Model Context Protocol (MCP),
  * allowing MyCoder to use context from MCP-compatible servers.
- *
+ * 
  * Uses the official MCP SDK: https://www.npmjs.com/package/@modelcontextprotocol/sdk
  */
 
-import * as MCP from '@modelcontextprotocol/sdk';
-
-export { MCP };
-
 /**
  * Configuration for MCP in mycoder.config.js
  */
@@ -36,4 +32,4 @@ export interface McpServerConfig {
     /** Authentication token */
     token: string;
   };
-}
+}
diff --git a/packages/agent/src/tools/getTools.ts b/packages/agent/src/tools/getTools.ts
@@ -1,3 +1,4 @@
+import { McpConfig } from '../core/mcp/index.js';
 import { Tool } from '../core/types.js';
 
 // Import tools
@@ -8,18 +9,16 @@ import { agentStartTool } from './interaction/agentStart.js';
 import { userPromptTool } from './interaction/userPrompt.js';
 import { fetchTool } from './io/fetch.js';
 import { textEditorTool } from './io/textEditor.js';
+import { createMcpTool } from './mcp.js';
 import { listBackgroundToolsTool } from './system/listBackgroundTools.js';
 import { respawnTool } from './system/respawn.js';
 import { sequenceCompleteTool } from './system/sequenceComplete.js';
 import { shellMessageTool } from './system/shellMessage.js';
 import { shellStartTool } from './system/shellStart.js';
 import { sleepTool } from './system/sleep.js';
-import { McpTool } from './mcp.js';
 
 // Import these separately to avoid circular dependencies
 
-import { McpConfig } from '../core/mcp/types.js';
-
 interface GetToolsOptions {
   userPrompt?: boolean;
   mcpConfig?: McpConfig;
@@ -52,8 +51,8 @@ export function getTools(options?: GetToolsOptions): Tool[] {
 
   // Add MCP tool if we have any servers configured
   if (mcpConfig.servers && mcpConfig.servers.length > 0) {
-    const mcpTool = new McpTool(mcpConfig);
-    tools.push(mcpTool as unknown as Tool);
+    const mcpTool = createMcpTool(mcpConfig);
+    tools.push(mcpTool);
   }
 
   return tools;
diff --git a/packages/agent/src/tools/mcp.ts b/packages/agent/src/tools/mcp.ts
@@ -7,170 +7,191 @@
  * Uses the official MCP SDK: https://www.npmjs.com/package/@modelcontextprotocol/sdk
  */
 
-import { MCP, McpConfig, McpServerConfig } from '../core/mcp';
-import { Tool } from './tool';
-import { ToolContext } from './types';
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
 
-/**
- * Parameters for listResources method
- */
-interface ListResourcesParams {
-  /** Optional server name to filter resources by */
-  server?: string;
-}
+import { Tool } from '../core/types.js';
+import { McpConfig } from '../core/mcp/index.js';
 
-/**
- * Parameters for getResource method
- */
-interface GetResourceParams {
-  /** URI of the resource to fetch */
-  uri: string;
-}
+// Parameters for listResources method
+const listResourcesSchema = z.object({
+  server: z
+    .string()
+    .optional()
+    .describe('Optional server name to filter resources by'),
+});
+
+// Parameters for getResource method
+const getResourceSchema = z.object({
+  uri: z
+    .string()
+    .describe('URI of the resource to fetch in the format "scheme://path"'),
+});
+
+// Return type for listResources
+const listResourcesReturnSchema = z.array(
+  z.object({
+    uri: z.string(),
+    metadata: z.record(z.unknown()).optional(),
+  })
+);
+
+// Return type for getResource
+const getResourceReturnSchema = z.string();
+
+type ListResourcesParams = z.infer<typeof listResourcesSchema>;
+type GetResourceParams = z.infer<typeof getResourceSchema>;
+type ListResourcesReturn = z.infer<typeof listResourcesReturnSchema>;
+type GetResourceReturn = z.infer<typeof getResourceReturnSchema>;
+
+// Map to store MCP clients
+const mcpClients = new Map<string, any>();
 
 /**
- * MCP Tool for interacting with MCP servers
+ * Create a new MCP tool with the specified configuration
+ * @param config MCP configuration
+ * @returns The MCP tool
  */
-export class McpTool extends Tool {
-  private clients: Map<string, MCP.Client> = new Map();
+export function createMcpTool(config: McpConfig): Tool {
+  // We'll import the MCP SDK dynamically to avoid TypeScript errors
+  // This is a temporary solution until we can properly add type declarations
+  const mcpSdk = require('@modelcontextprotocol/sdk');
   
-  /**
-   * Create a new MCP tool
-   * @param config MCP configuration
-   */
-  constructor(private config: McpConfig = { servers: [], defaultResources: [] }) {
-    super({
-      name: 'mcp',
-      description: 'Interact with Model Context Protocol (MCP) servers to retrieve resources',
-      schema: {
-        listResources: {
-          description: 'List available resources from MCP servers',
-          parameters: {
-            server: {
-              type: 'string',
-              description: 'Optional server name to filter resources by',
-              required: false,
-            },
-          },
-        },
-        getResource: {
-          description: 'Fetch a resource from an MCP server',
-          parameters: {
-            uri: {
-              type: 'string',
-              description: 'URI of the resource to fetch in the format "scheme://path"',
-              required: true,
-            },
-          },
-        },
-      },
-    });
-    
-    // Initialize MCP clients for each configured server
-    this.initializeClients();
-  }
+  // Initialize MCP clients for each configured server
+  mcpClients.clear();
   
-  /**
-   * Initialize MCP clients for each configured server
-   */
-  private initializeClients(): void {
-    if (!this.config.servers || this.config.servers.length === 0) {
-      return;
-    }
-    
-    for (const server of this.config.servers) {
+  if (config.servers && config.servers.length > 0) {
+    for (const server of config.servers) {
       try {
-        const clientOptions: MCP.ClientOptions = {
+        let clientOptions: any = {
           baseURL: server.url,
         };
         
         // Add authentication if configured
         if (server.auth && server.auth.type === 'bearer') {
-          clientOptions.headers = {
-            Authorization: `Bearer ${server.auth.token}`,
+          clientOptions = {
+            ...clientOptions,
+            headers: {
+              Authorization: `Bearer ${server.auth.token}`,
+            },
           };
         }
         
-        const client = new MCP.Client(clientOptions);
-        this.clients.set(server.name, client);
+        const client = new mcpSdk.Client(clientOptions);
+        mcpClients.set(server.name, client);
       } catch (error) {
         console.error(`Failed to initialize MCP client for server ${server.name}:`, error);
       }
     }
   }
   
-  /**
-   * List available resources from MCP servers
-   * @param params Optional parameters
-   * @param _context Tool context
-   * @returns List of available resources
-   */
-  async listResources(
-    params: ListResourcesParams = {},
-    _context: ToolContext,
-  ): Promise<MCP.Resource[]> {
-    const resources: MCP.Resource[] = [];
+  // Define the MCP tool
+  return {
+    name: 'mcp',
+    description: 'Interact with Model Context Protocol (MCP) servers to retrieve resources',
+    parameters: z.discriminatedUnion('method', [
+      z.object({
+        method: z.literal('listResources'),
+        params: listResourcesSchema.optional(),
+      }),
+      z.object({
+        method: z.literal('getResource'),
+        params: getResourceSchema,
+      }),
+    ]),
+    parametersJsonSchema: zodToJsonSchema(
+      z.discriminatedUnion('method', [
+        z.object({
+          method: z.literal('listResources'),
+          params: listResourcesSchema.optional(),
+        }),
+        z.object({
+          method: z.literal('getResource'),
+          params: getResourceSchema,
+        }),
+      ])
+    ),
+    returns: z.union([listResourcesReturnSchema, getResourceReturnSchema]),
+    returnsJsonSchema: zodToJsonSchema(z.union([listResourcesReturnSchema, getResourceReturnSchema])),
     
-    // If a specific server is requested, only check that server
-    if (params.server) {
-      const client = this.clients.get(params.server);
-      if (client) {
-        try {
-          const serverResources = await client.resources();
-          resources.push(...serverResources);
-        } catch (error) {
-          console.error(`Failed to fetch resources from server ${params.server}:`, error);
-        }
+    execute: async ({ method, params }, { logger }) => {
+      // Extract the server name from a resource URI
+      function getServerNameFromUri(uri: string): string | undefined {
+        const match = uri.match(/^([^:]+):\/\//);
+        return match ? match[1] : undefined;
       }
-    } else {
-      // Otherwise, check all servers
-      for (const [serverName, client] of this.clients.entries()) {
-        try {
-          const serverResources = await client.resources();
-          resources.push(...serverResources);
-        } catch (error) {
-          console.error(`Failed to fetch resources from server ${serverName}:`, error);
+      
+      if (method === 'listResources') {
+        // List available resources from MCP servers
+        const resources: any[] = [];
+        const serverFilter = params?.server;
+        
+        // If a specific server is requested, only check that server
+        if (serverFilter) {
+          const client = mcpClients.get(serverFilter);
+          if (client) {
+            try {
+              logger.verbose(`Fetching resources from server: ${serverFilter}`);
+              const serverResources = await client.resources();
+              resources.push(...(serverResources as any[]));
+            } catch (error) {
+              logger.error(`Failed to fetch resources from server ${serverFilter}:`, error);
+            }
+          } else {
+            logger.warn(`Server not found: ${serverFilter}`);
+          }
+        } else {
+          // Otherwise, check all servers
+          for (const [serverName, client] of mcpClients.entries()) {
+            try {
+              logger.verbose(`Fetching resources from server: ${serverName}`);
+              const serverResources = await client.resources();
+              resources.push(...(serverResources as any[]));
+            } catch (error) {
+              logger.error(`Failed to fetch resources from server ${serverName}:`, error);
+            }
+          }
         }
+        
+        return resources;
+      } else if (method === 'getResource') {
+        // Fetch a resource from an MCP server
+        const uri = params.uri;
+        
+        // Parse the URI to determine which server to use
+        const serverName = getServerNameFromUri(uri);
+        if (!serverName) {
+          throw new Error(`Could not determine server from URI: ${uri}`);
+        }
+        
+        const client = mcpClients.get(serverName);
+        if (!client) {
+          throw new Error(`Server not found: ${serverName}`);
+        }
+        
+        // Use the MCP SDK to fetch the resource
+        logger.verbose(`Fetching resource: ${uri}`);
+        const resource = await client.resource(uri);
+        return resource.content;
       }
-    }
+      
+      throw new Error(`Unknown method: ${method}`);
+    },
     
-    return resources;
-  }
-  
-  /**
-   * Fetch a resource from an MCP server
-   * @param params Parameters
-   * @param _context Tool context
-   * @returns The resource content
-   */
-  async getResource(
-    params: GetResourceParams,
-    _context: ToolContext,
-  ): Promise<string> {
-    // Parse the URI to determine which server to use
-    const serverName = this.getServerNameFromUri(params.uri);
-    if (!serverName) {
-      throw new Error(`Could not determine server from URI: ${params.uri}`);
-    }
-    
-    const client = this.clients.get(serverName);
-    if (!client) {
-      throw new Error(`Server not found: ${serverName}`);
-    }
+    logParameters: (params, { logger }) => {
+      if (params.method === 'listResources') {
+        logger.verbose(`Listing MCP resources${params.params?.server ? ` from server: ${params.params.server}` : ''}`);
+      } else if (params.method === 'getResource') {
+        logger.verbose(`Fetching MCP resource: ${params.params.uri}`);
+      }
+    },
     
-    // Use the MCP SDK to fetch the resource
-    const resource = await client.resource(params.uri);
-    return resource.content;
-  }
-  
-  /**
-   * Extract the server name from a resource URI
-   * @param uri Resource URI in the format 'scheme://path'
-   * @returns The server name or undefined if not found
-   * @private
-   */
-  private getServerNameFromUri(uri: string): string | undefined {
-    // For simplicity, we'll use the first part of the URI as the server name
-    const match = uri.match(/^([^:]+):\/\//);
-    return match ? match[1] : undefined;
-  }
+    logReturns: (result, { logger }) => {
+      if (Array.isArray(result)) {
+        logger.verbose(`Found ${result.length} MCP resources`);
+      } else {
+        logger.verbose(`Retrieved MCP resource content (${result.length} characters)`);
+      }
+    },
+  };
 }
