Merge remote-tracking branch 'origin/main' into feature/sampling-agent

Author: yaonyan

packages/core/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcpc/core",
-  "version": "0.1.1-beta.1",
+  "version": "0.1.1-beta.2",
   "tasks": {
     "server:compile": "echo \"no need to compile\"",
     "test": "deno test --allow-env --allow-read tests/",

packages/core/src/service/tools.ts

@@ -1,13 +1,4 @@
-import { experimental_createMCPClient } from "ai";
-import { readFileSync } from "node:fs";
 import { z } from "zod";
-import { isProdEnv } from "../../mod.ts";
-
-export enum ServerName {
-  DIAGRAM = "diagram-thinker",
-  OAPI = "oapi-invoker",
-  CODE_RUNNER = "code-runner",
-}
 
 const AutoApproveSchema = z.array(z.string()).default([]);
 
@@ -51,45 +42,5 @@ export const McpSettingsSchema: z.ZodObject<{
   mcpServers: z.record(ServerConfigSchema),
 });
 
-const configStr = readFileSync(
-  new URL(
-    `../../../../${isProdEnv() ? "mcp.json" : "mcp.local.json"}`,
-    import.meta.url,
-  ),
-  "utf-8",
-);
-
 export type McpServerConfig = z.infer<typeof ServerConfigSchema>;
 export type MCPSetting = z.infer<typeof McpSettingsSchema>;
-
-const mcpSettings = McpSettingsSchema.parse(JSON.parse(configStr));
-const _mcpEnabledConfigs = Object.entries(mcpSettings.mcpServers).filter(
-  ([_name, config]) => {
-    if (config.disabled) {
-      return false;
-    }
-    return true;
-  },
-);
-
-export async function getMcpClient(
-  serverConfig: [string, z.infer<typeof ServerConfigSchema>],
-) {
-  const [_mcpName, mcpConfig] = serverConfig;
-  const transport: any = mcpConfig.transportType === "sse"
-    ? {
-      type: "sse",
-      url: mcpConfig.url,
-      headers: {},
-    }
-    : {
-      type: "stdio",
-      command: mcpConfig.command!,
-      args: mcpConfig.args || [],
-      env: mcpConfig.env || {},
-    };
-  const client = await experimental_createMCPClient({
-    transport,
-  });
-  return client;
-}

packages/core/src/utils/common/ai.ts

@@ -217,22 +217,57 @@ export async function composeMcpDepTools(
         ) {
           return;
         }
-        const execute = (args: any) =>
-          client.callTool({ name: internalToolName, arguments: args });
-        tool.execute = execute;
-        allTools[toolId] = tool;
+        // Store client reference in a way that can be cleaned up
+        const clientRef = { current: client as Client | null };
+
+        const execute = (args: Record<string, unknown>) => {
+          if (!clientRef.current) {
+            throw new Error(`Client for tool ${toolId} has been disposed`);
+          }
+          return clientRef.current.callTool({
+            name: internalToolName,
+            arguments: args,
+          });
+        };
+
+        // Create a new tool object to avoid modifying the original
+        const toolWithExecute = {
+          ...tool,
+          execute,
+          // Store cleanup function for this specific tool
+          _cleanup: () => {
+            clientRef.current = null;
+          },
+        };
+
+        allTools[toolId] = toolWithExecute;
       });
     } catch (error) {
       console.error(`Error creating MCP client for ${name}:`, error);
     }
   }
 
   const cleanupClients = async () => {
+    // Cleanup individual tool references
+    Object.values(allTools).forEach((tool: { _cleanup?: () => void }) => {
+      if (tool._cleanup && typeof tool._cleanup === "function") {
+        tool._cleanup();
+      }
+    });
+
     await Promise.all(
       Object.values(allClients).map(async (client) => {
-        await client.close();
+        try {
+          await client.close();
+        } catch (error) {
+          console.error("Error closing MCP client:", error);
+        }
       }),
     );
+
+    // Clear references to help GC
+    Object.keys(allTools).forEach((key) => delete allTools[key]);
+    Object.keys(allClients).forEach((key) => delete allClients[key]);
   };
 
   return { tools: allTools, clients: allClients, cleanupClients };