feat: update version to 0.1.1-beta.1; refactor code for improved readability and maintainability; add cleanup functionality for MCP clients

Author: yaonyan

packages/core/deno.json

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

packages/core/src/compose.ts

@@ -5,7 +5,7 @@ import {
   ListToolsRequestSchema,
   type Tool,
 } from "@modelcontextprotocol/sdk/types.js";
-import { jsonSchema, type Schema } from "ai";
+import type { Schema } from "ai";
 import type { McpSettingsSchema } from "./service/tools.ts";
 import {
   Server,
@@ -19,6 +19,10 @@ import type { JSONSchema, ToolCallback } from "./types.ts";
 import { registerAgenticTool } from "./workflow/agentic-tool-registrar.ts";
 import { registerAgenticWorkflowTool } from "./workflow/workflow-tool-registrar.ts";
 
+interface ComposedTool extends Tool {
+  execute: ToolCallback;
+}
+
 const ALL_TOOLS_PLACEHOLDER = "__ALL__";
 const ACTION_KEY = "action";
 
@@ -80,7 +84,7 @@ export class ComposableMCPServer extends Server {
     description: string,
     paramsSchema: Schema<T>,
     cb: (args: T, extra?: unknown) => unknown,
-    internal: boolean = false,
+    internal: boolean = false
   ) {
     if (!internal) {
       const newTool: Tool = {
@@ -144,7 +148,8 @@ export class ComposableMCPServer extends Server {
       throw new Error(`Tool ${name} not found`);
     }
 
-    const callback = this.nameToCb.get(resolvedName) ||
+    const callback =
+      this.nameToCb.get(resolvedName) ||
       this.internalTools.get(resolvedName)?.callback ||
       this.hiddenTools.get(resolvedName) ||
       this.composedTools.get(resolvedName);
@@ -154,8 +159,8 @@ export class ComposableMCPServer extends Server {
     }
 
     // Apply args transformation if override exists
-    const override = this.toolOverrides.get(name) ||
-      this.toolOverrides.get(resolvedName);
+    const override =
+      this.toolOverrides.get(name) || this.toolOverrides.get(resolvedName);
     const processedArgs = override?.args ? override.args(args) : args;
 
     return await callback(processedArgs);
@@ -166,7 +171,7 @@ export class ComposableMCPServer extends Server {
    */
   callInternalTool(name: string, args: unknown): Promise<unknown> {
     console.warn(
-      `callInternalTool() is deprecated. Use callTool() instead for: ${name}`,
+      `callInternalTool() is deprecated. Use callTool() instead for: ${name}`
     );
     return this.callTool(name, args);
   }
@@ -194,7 +199,7 @@ export class ComposableMCPServer extends Server {
    * Get internal tool schema by name
    */
   getInternalToolSchema(
-    name: string,
+    name: string
   ): { description: string; schema: JSONSchema } | undefined {
     const internalTool = this.internalTools.get(name);
     if (internalTool) {
@@ -221,7 +226,7 @@ export class ComposableMCPServer extends Server {
     name: string,
     description: string,
     depsConfig: z.infer<typeof McpSettingsSchema> = { mcpServers: {} },
-    options: ComposeDefinition["options"] = { mode: "agentic" },
+    options: ComposeDefinition["options"] = { mode: "agentic" }
   ) {
     const { tagToResults, $ } = parseTags(description, ["tool", "fn"]);
 
@@ -239,8 +244,8 @@ export class ComposableMCPServer extends Server {
       }
     });
 
-    // Filter tools and transform scoped tool names to valid action identifierss
-    const tools = await composeMcpDepTools(
+    // Filter tools and transform scoped tool names to valid action identifiers
+    const { tools, cleanupClients } = await composeMcpDepTools(
       depsConfig,
       ({ mcpName, toolNameWithScope, toolId }) => {
         const matchingStep = options.steps?.find((step) =>
@@ -261,7 +266,7 @@ export class ComposableMCPServer extends Server {
 
           description = description.replace(
             $(tool).prop("outerHTML")!,
-            `<action ${ACTION_KEY}="${toolId}"/>`,
+            `<action ${ACTION_KEY}="${toolId}"/>`
           );
           if (selectAll) {
             return true;
@@ -271,8 +276,21 @@ export class ComposableMCPServer extends Server {
             tool.attribs.name === toolId
           );
         });
-      },
-    );
+      }
+    ) as { tools: Record<string, ComposedTool>; cleanupClients: () => Promise<void> };
+
+    // Cleanup clients when server is closed
+    this.onclose = async () => {
+      await cleanupClients();
+      console.log(`[${name}] MCP server closed, cleaned up dependent clients.`);
+    };
+    this.onerror = async (error) => {
+      console.error(`[${name}] MCP server error:`, error);
+      await cleanupClients();
+      console.log(
+        `[${name}] MCP server error handled, cleaned up dependent clients.`
+      );
+    };
 
     // Apply tool overrides
     Object.entries(tools).forEach(([toolId, tool]) => {
@@ -281,12 +299,10 @@ export class ComposableMCPServer extends Server {
 
       // If no direct override found, check if we have an override for the dot notation equivalent
       if (!override) {
-        for (
-          const [
-            overrideName,
-            overrideOptions,
-          ] of this.toolOverrides.entries()
-        ) {
+        for (const [
+          overrideName,
+          overrideOptions,
+        ] of this.toolOverrides.entries()) {
           // Build the mapping during processing
           const dotNotationId = toolId.replace(/_/g, ".");
           const underscoreNotationId = overrideName.replace(/\./g, "_");
@@ -333,22 +349,18 @@ export class ComposableMCPServer extends Server {
     // For agentic interface: external tools (non-hidden) + internal tools
     const allToolNames = [...externalToolNames, ...internalToolNames];
     console.log(
-      `[${name}][composed tools] external: ${
-        externalToolNames.join(
-          ", ",
-        )
-      } | internal: ${internalToolNames.join(", ")}`,
+      `[${name}][composed tools] external: ${externalToolNames.join(
+        ", "
+      )} | internal: ${internalToolNames.join(", ")}`
     );
 
     const depGroups: Record<string, unknown> = {};
     toolNameToDetailList.forEach(([toolName, tool]) => {
       if (!tool) {
         throw new Error(
-          `Action ${toolName} not found, available action list: ${
-            allToolNames.join(
-              ", ",
-            )
-          }`,
+          `Action ${toolName} not found, available action list: ${allToolNames.join(
+            ", "
+          )}`
         );
       }
 
@@ -362,9 +374,10 @@ export class ComposableMCPServer extends Server {
         baseSchema.type === "object" && baseSchema.properties
           ? baseSchema.properties
           : {};
-      const baseRequired = baseSchema.type === "object" && baseSchema.required
-        ? baseSchema.required
-        : [];
+      const baseRequired =
+        baseSchema.type === "object" && Array.isArray(baseSchema.required)
+          ? baseSchema.required
+          : [];
 
       const updatedProperties = updateRefPaths(baseProperties, toolName);
 

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

@@ -15,11 +15,12 @@ import { cwd } from "node:process";
  * Helper type to extract variable names (inside {}) from a template string literal.
  * e.g., ExtractVariables<"Hello {name}! You are {age}."> -> "name" | "age"
  */
-type ExtractVariables<S extends string> = S extends
-  `${string}{${infer Var}}${infer Rest}` ? Var extends `${infer ActualVar}}` // Handle potential extra '}' if no Rest or adjacent braces
-    ? ActualVar | ExtractVariables<Rest>
-  : Var | ExtractVariables<Rest> // Standard case {var}
-  : never;
+type ExtractVariables<S extends string> =
+  S extends `${string}{${infer Var}}${infer Rest}`
+    ? Var extends `${infer ActualVar}}` // Handle potential extra '}' if no Rest or adjacent braces
+      ? ActualVar | ExtractVariables<Rest>
+      : Var | ExtractVariables<Rest> // Standard case {var}
+    : never;
 
 /**
  * Type for the input object required by the formatting function.
@@ -51,8 +52,8 @@ interface NativePromptOptions {
  */
 export const p = <T extends string>(
   template: T,
-  options: NativePromptOptions = {},
-): (input: PromptInput<T>) => string => {
+  options: NativePromptOptions = {}
+): ((input: PromptInput<T>) => string) => {
   const { missingVariableHandling = "warn" } = options;
 
   // Pre-compute variable names (at runtime) for the formatting function closure
@@ -64,7 +65,7 @@ export const p = <T extends string>(
     variableNames.add(match[1]);
   }
   const requiredVariables = Array.from(
-    variableNames,
+    variableNames
   ) as (keyof PromptInput<T>)[]; // Runtime list
 
   // Return the formatting function
@@ -85,11 +86,9 @@ export const p = <T extends string>(
         switch (missingVariableHandling) {
           case "error": {
             throw new Error(
-              `Missing variable "${
-                String(
-                  variableName,
-                )
-              }" in input for template.`,
+              `Missing variable "${String(
+                variableName
+              )}" in input for template.`
             );
           }
           case "warn": {
@@ -105,7 +104,7 @@ export const p = <T extends string>(
           case "empty": {
             const replaceRegex = new RegExp(
               `\\{${String(variableName)}\\}`,
-              "g",
+              "g"
             );
             result = result.replace(replaceRegex, "");
             break;
@@ -123,7 +122,7 @@ export const p = <T extends string>(
 };
 export function parseTags(
   htmlString: string,
-  tags: Array<string>,
+  tags: Array<string>
 ): { tagToResults: Record<string, any[]>; $: CheerioAPI } {
   const $ = load(htmlString, { xml: { decodeEntities: false } });
 
@@ -147,9 +146,10 @@ export async function composeMcpDepTools(
     toolNameWithScope: string;
     internalToolName: string;
     toolId: string;
-  }) => boolean,
+  }) => boolean
 ): Promise<Record<string, any>> {
   const allTools: Record<string, any> = {};
+  const allClients: Record<string, Client> = {};
 
   // Process each MCP definition sequentially
   for (const [name, definition] of Object.entries(mcpConfig.mcpServers)) {
@@ -188,6 +188,7 @@ export async function composeMcpDepTools(
     try {
       // Create the MCP client
       await client.connect(transport, { timeout: 60_000 * 10 });
+      allClients[serverId] = client;
 
       // Get the tools from the client
       const { tools } = await client.listTools();
@@ -221,5 +222,13 @@ export async function composeMcpDepTools(
     }
   }
 
-  return allTools;
+  const cleanupClients = async () => {
+    await Promise.all(
+      Object.values(allClients).map(async (client) => {
+        await client.close();
+      })
+    );
+  };
+
+  return { tools: allTools, clients: allClients, cleanupClients };
 }