refactor: Use official @modelcontextprotocol/sdk package

Author: bhouston

packages/agent/package.json

@@ -45,6 +45,7 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.37",
+    "@modelcontextprotocol/sdk": "^1.7.0",
     "@mozilla/readability": "^0.5.0",
     "@playwright/test": "^1.50.1",
     "@vitest/browser": "^3.0.5",

packages/agent/src/core/executeToolCall.ts

@@ -110,9 +110,12 @@ export const executeToolCall = async (
     }
   }
 
-  const toolOutput =
-    typeof output === 'string' ? output : JSON.stringify(output, null, 2);
-  return toolOutput.length > OUTPUT_LIMIT
-    ? `${toolOutput.slice(0, OUTPUT_LIMIT)}...(truncated)`
-    : toolOutput;
+  const outputIsString = typeof output === 'string';
+  if (outputIsString) {
+    return output.length > OUTPUT_LIMIT
+      ? `${output.slice(0, OUTPUT_LIMIT)}...(truncated)`
+      : output;
+  } else {
+    return JSON.stringify(output, null, 2);
+  }
 };

packages/agent/src/core/mcp/index.ts

@@ -1,9 +1,39 @@
 /**
  * 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
  */
 
-export * from './client';
-export * from './types';
+import * as MCP from '@modelcontextprotocol/sdk';
+
+export { MCP };
+
+/**
+ * Configuration for MCP in mycoder.config.js
+ */
+export interface McpConfig {
+  /** Array of MCP server configurations */
+  servers?: McpServerConfig[];
+  /** Default resources to load automatically */
+  defaultResources?: string[];
+}
+
+/**
+ * Configuration for an MCP server
+ */
+export interface McpServerConfig {
+  /** Unique name for this MCP server */
+  name: string;
+  /** URL of the MCP server */
+  url: string;
+  /** Optional authentication configuration */
+  auth?: {
+    /** Authentication type (currently only 'bearer' is supported) */
+    type: 'bearer';
+    /** Authentication token */
+    token: string;
+  };
+}

packages/agent/src/core/toolAgent/toolExecutor.ts

@@ -6,11 +6,18 @@ import { Tool, ToolCall, ToolContext } from '../types.js';
 import { addToolResultToMessages } from './messageUtils.js';
 import { ToolCallResult } from './types.js';
 
-const safeParse = (value: string) => {
+const safeParse = (value: string, context: Record<string, string>) => {
   try {
     return JSON.parse(value);
   } catch (error) {
-    console.error('Error parsing JSON:', error, 'original value:', value);
+    console.error(
+      'Error parsing JSON:',
+      error,
+      'original value:',
+      value,
+      'context',
+      JSON.stringify(context),
+    );
     return { error: value };
   }
 };
@@ -77,7 +84,7 @@ export async function executeTools(
         }
       }
 
-      const parsedResult = safeParse(toolResult);
+      const parsedResult = safeParse(toolResult, { tool: call.name });
 
       // Add the tool result to messages
       addToolResultToMessages(messages, call.id, parsedResult, isError);

packages/agent/src/tools/mcp.ts

@@ -3,10 +3,11 @@
  * 
  * This tool allows the agent to interact with Model Context Protocol (MCP) servers
  * to retrieve resources and use tools provided by those servers.
+ * 
+ * Uses the official MCP SDK: https://www.npmjs.com/package/@modelcontextprotocol/sdk
  */
 
-import { McpClient } from '../core/mcp/client';
-import { McpConfig, McpResource } from '../core/mcp/types';
+import { MCP, McpConfig, McpServerConfig } from '../core/mcp';
 import { Tool } from './tool';
 import { ToolContext } from './types';
 
@@ -30,7 +31,7 @@ interface GetResourceParams {
  * MCP Tool for interacting with MCP servers
  */
 export class McpTool extends Tool {
-  private client: McpClient;
+  private clients: Map<string, MCP.Client> = new Map();
 
   /**
    * Create a new MCP tool
@@ -64,28 +65,72 @@ export class McpTool extends Tool {
       },
     });
 
-    // Initialize the MCP client with configured servers
-    this.client = new McpClient(config.servers || []);
+    // Initialize MCP clients for each configured server
+    this.initializeClients();
+  }
+  
+  /**
+   * 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) {
+      try {
+        const clientOptions: MCP.ClientOptions = {
+          baseURL: server.url,
+        };
+        
+        // Add authentication if configured
+        if (server.auth && server.auth.type === 'bearer') {
+          clientOptions.headers = {
+            Authorization: `Bearer ${server.auth.token}`,
+          };
+        }
+        
+        const client = new MCP.Client(clientOptions);
+        this.clients.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
+   * @param _context Tool context
    * @returns List of available resources
    */
   async listResources(
     params: ListResourcesParams = {},
     _context: ToolContext,
-  ): Promise<McpResource[]> {
-    const resources = await this.client.getAvailableResources();
+  ): Promise<MCP.Resource[]> {
+    const resources: MCP.Resource[] = [];
 
-    // Filter by server if specified
+    // If a specific server is requested, only check that server
     if (params.server) {
-      return resources.filter(resource => {
-        // Simple implementation - in a real implementation, this would be more sophisticated
-        return resource.uri.startsWith(`${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);
+        }
+      }
+    } 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);
+        }
+      }
     }
 
     return resources;
@@ -94,13 +139,38 @@ export class McpTool extends Tool {
   /**
    * Fetch a resource from an MCP server
    * @param params Parameters
-   * @param context Tool context
+   * @param _context Tool context
    * @returns The resource content
    */
   async getResource(
     params: GetResourceParams,
     _context: ToolContext,
   ): Promise<string> {
-    return await this.client.fetchResource(params.uri);
+    // 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}`);
+    }
+    
+    // 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;
   }
 }

packages/cli/README.md

@@ -119,7 +119,7 @@ export default {
   customPrompt: '',
   profile: false,
   tokenCache: true,
-  
+
   // MCP configuration
   mcp: {
     servers: [
@@ -128,14 +128,12 @@ export default {
         url: 'https://mcp.example.com',
         auth: {
           type: 'bearer',
-          token: 'your-token-here'
-        }
-      }
+          token: 'your-token-here',
+        },
+      },
     ],
-    defaultResources: [
-      'example://docs/api'
-    ]
-  }
+    defaultResources: ['example://docs/api'],
+  },
 };
 ```
 
@@ -180,13 +178,15 @@ export default {
 
 ### Model Context Protocol (MCP) Configuration
 
-MyCoder supports the Model Context Protocol (MCP), which allows the agent to access external context sources and tools. To configure MCP support, add an `mcp` section to your `mycoder.config.js` file:
+MyCoder supports the [Model Context Protocol (MCP)](https://modelcontextprotocol.io), which allows the agent to access external context sources and tools. MyCoder uses the official [@modelcontextprotocol/sdk](https://www.npmjs.com/package/@modelcontextprotocol/sdk) package for MCP integration.
+
+To configure MCP support, add an `mcp` section to your `mycoder.config.js` file:
 
 ```javascript
 // mycoder.config.js
 export default {
   // Other configuration...
-  
+
   // MCP configuration
   mcp: {
     // MCP Servers to connect to
@@ -197,17 +197,15 @@ export default {
         // Optional authentication
         auth: {
           type: 'bearer',
-          token: process.env.MCP_SERVER_TOKEN
-        }
-      }
+          token: process.env.MCP_SERVER_TOKEN,
+        },
+      },
     ],
-    
+
     // Optional: Default context resources to load
-    defaultResources: [
-      'company-docs://api/reference'
-    ]
-  }
-}
+    defaultResources: ['company-docs://api/reference'],
+  },
+};
 ```
 
 When MCP is configured, the agent will have access to a new `mcp` tool that allows it to: