MCP client connecting to servers in all contexts.

Author: glassBead-tc

.gitignore

@@ -48,4 +48,8 @@ docs/
 vite.config.ts.timestamp-*.mjs
 
 # Roo Code
-.roomodes
+.roomodes
+
+# MCP config
+packages/api/srcbook_mcp_config.json
+MCPClientDevGuide.md

packages/api/ai/generate.mts

@@ -14,6 +14,7 @@ import { PROMPTS_DIR } from '../constants.mjs';
 import { encode, decodeCells } from '../srcmd.mjs';
 import { buildProjectXml, type FileContent } from '../ai/app-parser.mjs';
 import { logAppGeneration } from './logger.mjs';
+import { formatMCPToolsForAI } from './mcp-tools.mjs';
 
 const makeGenerateSrcbookSystemPrompt = () => {
   return readFileSync(Path.join(PROMPTS_DIR, 'srcbook-generator.txt'), 'utf-8');
@@ -33,25 +34,55 @@ const makeAppEditorSystemPrompt = () => {
   return readFileSync(Path.join(PROMPTS_DIR, 'app-editor.txt'), 'utf-8');
 };
 
-const makeAppEditorUserPrompt = (projectId: string, files: FileContent[], query: string) => {
+const makeAppEditorUserPrompt = async (projectId: string, files: FileContent[], query: string) => {
   const projectXml = buildProjectXml(files, projectId);
   const userRequestXml = `<userRequest>${query}</userRequest>`;
+
+  // Get MCP tools if available
+  let mcpToolsXml = '';
+  try {
+    const mcpTools = await formatMCPToolsForAI();
+    if (mcpTools && mcpTools !== 'No MCP tools are available.' && mcpTools !== 'Error retrieving MCP tools.') {
+      mcpToolsXml = `<mcpTools>
+${mcpTools}
+</mcpTools>`;
+    }
+  } catch (error) {
+    console.error('Error getting MCP tools for app editor:', error);
+  }
+
   return `Following below are the project XML and the user request.
 
 ${projectXml}
 
 ${userRequestXml}
+${mcpToolsXml ? '\n\n' + mcpToolsXml : ''}
   `.trim();
 };
 
-const makeAppCreateUserPrompt = (projectId: string, files: FileContent[], query: string) => {
+const makeAppCreateUserPrompt = async (projectId: string, files: FileContent[], query: string) => {
   const projectXml = buildProjectXml(files, projectId);
   const userRequestXml = `<userRequest>${query}</userRequest>`;
+
+  // Get MCP tools if available
+  let mcpToolsXml = '';
+  try {
+    const mcpTools = await formatMCPToolsForAI();
+    if (mcpTools && mcpTools !== 'No MCP tools are available.' && mcpTools !== 'Error retrieving MCP tools.') {
+      mcpToolsXml = `<mcpTools>
+${mcpTools}
+</mcpTools>`;
+    }
+  } catch (error) {
+    console.error('Error getting MCP tools for app creation:', error);
+  }
+
   return `Following below are the project XML and the user request.
 
 ${projectXml}
 
 ${userRequestXml}
+${mcpToolsXml ? '\n\n' + mcpToolsXml : ''}
   `.trim();
 };
 
@@ -252,7 +283,7 @@ export async function generateApp(
   const result = await generateText({
     model,
     system: makeAppBuilderSystemPrompt(),
-    prompt: makeAppCreateUserPrompt(projectId, files, query),
+    prompt: await makeAppCreateUserPrompt(projectId, files, query),
   });
   return result.text;
 }
@@ -267,7 +298,7 @@ export async function streamEditApp(
   const model = await getModel();
 
   const systemPrompt = makeAppEditorSystemPrompt();
-  const userPrompt = makeAppEditorUserPrompt(projectId, files, query);
+  const userPrompt = await makeAppEditorUserPrompt(projectId, files, query);
 
   let response = '';
 

packages/api/ai/mcp-tools.mts

@@ -0,0 +1,114 @@
+/**
+ * MCP Tools Formatter
+ * 
+ * This module provides functions to format MCP tools for AI consumption.
+ * It converts MCP tool definitions into a format that can be included in AI prompts.
+ */
+
+import { getMCPClientManager, type MCPTool } from '../mcp/client-manager.mjs';
+
+/**
+ * Format MCP tools for inclusion in AI prompts
+ * 
+ * @returns A formatted string describing all available MCP tools
+ */
+export async function formatMCPToolsForAI(): Promise<string> {
+  try {
+    // Get the MCP client manager
+    const clientManager = getMCPClientManager();
+    
+    // Get all available tools
+    const tools = await clientManager.getTools();
+    
+    if (tools.length === 0) {
+      return "No MCP tools are available.";
+    }
+    
+    // Format the tools as a string
+    return formatToolsAsString(tools);
+  } catch (error) {
+    console.error('Error formatting MCP tools for AI:', error);
+    return "Error retrieving MCP tools.";
+  }
+}
+
+/**
+ * Format a list of MCP tools as a string
+ * 
+ * @param tools The list of MCP tools to format
+ * @returns A formatted string describing the tools
+ */
+function formatToolsAsString(tools: MCPTool[]): string {
+  // Start with a header
+  let result = "## Available MCP Tools\n\n";
+  result += "You can use the following tools to perform actions:\n\n";
+  
+  // Add each tool
+  tools.forEach((tool) => {
+    // Add tool name and description
+    result += `### ${tool.name}\n`;
+    if (tool.annotations?.title) {
+      result += `**${tool.annotations.title}**\n`;
+    }
+    if (tool.description) {
+      result += `${tool.description}\n`;
+    }
+    
+    // Add tool annotations as hints
+    const hints: string[] = [];
+    if (tool.annotations?.readOnlyHint) hints.push("Read-only");
+    if (tool.annotations?.destructiveHint) hints.push("Destructive");
+    if (tool.annotations?.idempotentHint) hints.push("Idempotent");
+    if (tool.annotations?.openWorldHint) hints.push("Interacts with external systems");
+    
+    if (hints.length > 0) {
+      result += `**Hints:** ${hints.join(", ")}\n`;
+    }
+    
+    // Add input schema
+    result += "\n**Input Schema:**\n";
+    result += "```json\n";
+    result += JSON.stringify(tool.inputSchema, null, 2);
+    result += "\n```\n\n";
+    
+    // Add server ID
+    result += `**Server:** ${tool.serverId}\n\n`;
+    
+    // Add separator between tools
+    result += "---\n\n";
+  });
+  
+  // Add usage instructions
+  result += `## How to Use These Tools
+
+To use a tool, include a tool call in your response using the following format:
+
+\`\`\`
+<tool name="TOOL_NAME" server="SERVER_ID">
+{
+  "param1": "value1",
+  "param2": "value2"
+}
+</tool>
+\`\`\`
+
+Replace TOOL_NAME with the name of the tool you want to use, SERVER_ID with the server ID, and include the appropriate parameters as specified in the tool's input schema.
+`;
+  
+  return result;
+}
+
+/**
+ * Get the list of MCP tools
+ * 
+ * @returns The list of available MCP tools
+ */
+export async function getMCPTools(): Promise<MCPTool[]> {
+  try {
+    const clientManager = getMCPClientManager();
+    return await clientManager.getTools();
+  } catch (error) {
+    console.error('Error getting MCP tools:', error);
+    return [];
+  }
+}

packages/api/ai/plan-parser.mts

@@ -4,6 +4,7 @@ import { type App as DBAppType } from '../db/schema.mjs';
 import { loadFile } from '../apps/disk.mjs';
 import { StreamingXMLParser, TagType } from './stream-xml-parser.mjs';
 import { ActionChunkType, DescriptionChunkType } from '@srcbook/shared';
+import { getMCPClientManager } from '../mcp/client-manager.mjs';
 
 // The ai proposes a plan that we expect to contain both files and commands
 // Here is an example of a plan:
@@ -60,6 +61,15 @@ type NpmInstallCommand = {
   description: string;
 };
 
+// MCP Tool Action type
+interface MCPToolAction {
+  type: 'tool';
+  toolName: string;
+  serverId: string;
+  parameters: string; // JSON string of parameters
+  description: string;
+}
+
 // Later we can add more commands. For now, we only support npm install
 type Command = NpmInstallCommand;
 
@@ -69,7 +79,7 @@ export interface Plan {
   id: string;
   query: string;
   description: string;
-  actions: (FileAction | Command)[];
+  actions: (FileAction | Command | MCPToolAction)[];
 }
 
 interface ParsedResult {
@@ -82,13 +92,19 @@ interface ParsedResult {
           file?: { '@_filename': string; '#text': string };
           commandType?: string;
           package?: string | string[];
+          toolName?: string;
+          serverId?: string;
+          parameters?: string;
         }[]
       | {
           '@_type': string;
           description: string;
           file?: { '@_filename': string; '#text': string };
           commandType?: string;
           package?: string | string[];
+          toolName?: string;
+          serverId?: string;
+          parameters?: string;
         };
   };
 }
@@ -151,6 +167,30 @@ export async function parsePlan(
           packages: Array.isArray(action.package) ? action.package : [action.package],
           description: action.description,
         });
+      } else if (action['@_type'] === 'tool' && action.toolName && action.serverId) {
+        // Handle MCP tool action
+        try {
+          // Validate that the tool exists
+          const clientManager = getMCPClientManager();
+          const tools = await clientManager.getTools();
+          const tool = tools.find(t => t.name === action.toolName && t.serverId === action.serverId);
+
+          if (!tool) {
+            console.error(`Tool ${action.toolName} not found on server ${action.serverId}`);
+            continue;
+          }
+
+          plan.actions.push({
+            type: 'tool',
+            toolName: action.toolName,
+            serverId: action.serverId,
+            parameters: action.parameters || '{}',
+            description: action.description,
+          });
+        } catch (error) {
+          console.error('Error handling MCP tool action:', error);
+          continue;
+        }
       }
     }
 
@@ -274,6 +314,37 @@ async function toStreamingChunk(
             packages: packageTags.map((t) => t.content),
           },
         } as ActionChunkType;
+      } else if (type === 'tool') {
+        const toolNameTag = tag.children.find((t) => t.name === 'toolName')!;
+        const serverIdTag = tag.children.find((t) => t.name === 'serverId')!;
+        const parametersTag = tag.children.find((t) => t.name === 'parameters');
+
+        // Validate that the tool exists
+        try {
+          const clientManager = getMCPClientManager();
+          const tools = await clientManager.getTools();
+          const tool = tools.find(t => t.name === toolNameTag.content && t.serverId === serverIdTag.content);
+
+          if (!tool) {
+            console.error(`Tool ${toolNameTag.content} not found on server ${serverIdTag.content}`);
+            return null;
+          }
+
+          return {
+            type: 'action',
+            planId: planId,
+            data: {
+              type: 'tool',
+              description,
+              toolName: toolNameTag.content,
+              serverId: serverIdTag.content,
+              parameters: parametersTag ? parametersTag.content : '{}',
+            },
+          } as ActionChunkType;
+        } catch (error) {
+          console.error('Error handling MCP tool action in streaming parser:', error);
+          return null;
+        }
       } else {
         return null;
       }

packages/api/ai/stream-xml-parser.mts

@@ -12,6 +12,9 @@ export const xmlSchema: Record<string, NodeSchema> = {
   commandType: { isContentNode: true, hasCdata: false },
   package: { isContentNode: true, hasCdata: false },
   planDescription: { isContentNode: true, hasCdata: true },
+  toolName: { isContentNode: true, hasCdata: false },
+  serverId: { isContentNode: true, hasCdata: false },
+  parameters: { isContentNode: true, hasCdata: true },
 };
 
 export type TagType = {

packages/api/apps/disk.mts

@@ -11,6 +11,7 @@ import { FileContent } from '../ai/app-parser.mjs';
 import type { Plan } from '../ai/plan-parser.mjs';
 import archiver from 'archiver';
 import { wss } from '../index.mjs';
+import { executeMCPTool } from './mcp-tools.mjs';
 
 export function pathToApp(id: string) {
   return Path.join(APPS_DIR, id);
@@ -52,6 +53,23 @@ export async function applyPlan(app: DBAppType, plan: Plan) {
           source: item.modified,
           binary: isBinary(basename),
         });
+      } else if (item.type === 'tool') {
+        // Execute MCP tool
+        try {
+          console.log(`Executing MCP tool ${item.toolName} on server ${item.serverId}`);
+          const result = await executeMCPTool(item.toolName, item.serverId, item.parameters);
+          console.log(`MCP tool execution result:`, result);
+
+          // Notify clients about the tool execution
+          wss.broadcast(`app:${app.externalId}`, 'mcp:tool-executed', {
+            toolName: item.toolName,
+            serverId: item.serverId,
+            result: result
+          });
+        } catch (error) {
+          console.error(`Error executing MCP tool ${item.toolName}:`, error);
+          // Continue with other actions even if this one fails
+        }
       }
     }
   } catch (e) {