@agimon-ai/mcp-proxy 0.7.1 → 0.7.3

package/dist/{src-NOWQwaRe.mjs → src-Y-cyyxaw.mjs}

@@ -1,9 +1,10 @@
+import { coerceArgs, formatZodError, jsonSchemaToZod } from "@agimon-ai/foundation-validator";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ElicitRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
 import { existsSync } from "node:fs";
 import { access, mkdir, readFile, readdir, rm, stat, unlink, watch, writeFile } from "node:fs/promises";
 import yaml from "js-yaml";
-import { z } from "zod";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { homedir, tmpdir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
@@ -24,7 +25,7 @@ import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 //#region package.json
-var version = "0.7.0";
+var version = "0.7.2";
 
 //#endregion
 //#region src/utils/mcpConfigSchema.ts
@@ -1337,6 +1338,9 @@ var DefinitionsCacheService = class {
 	async getServersForTool(toolName) {
 		return (await this.getServerDefinitions()).filter((serverDefinition) => serverDefinition.tools.some((tool) => tool.name === toolName)).map((serverDefinition) => serverDefinition.serverName);
 	}
+	async getToolSchema(serverName, toolName) {
+		return (await this.getDefinitions()).servers[serverName]?.tools.find((t) => t.name === toolName)?.inputSchema;
+	}
 	async getServersForResource(uri) {
 		return (await this.getServerDefinitions()).filter((serverDefinition) => serverDefinition.resources.some((resource) => resource.uri === uri)).map((serverDefinition) => serverDefinition.serverName);
 	}
@@ -1782,7 +1786,7 @@ var McpClientManagerService = class {
 	async createConnection(serverName, config) {
 		const timeoutMs = config.timeout ?? DEFAULT_CONNECTION_TIMEOUT_MS;
 		const client = new Client({
-			name: `@agimon-ai/mcp-proxy-client`,
+			name: "@agimon-ai/mcp-proxy-client",
 			version: "0.1.0"
 		}, { capabilities: {} });
 		const mcpClient = new McpClient(serverName, config.transport, client, this.logger, {
@@ -2966,7 +2970,7 @@ var PrefetchService = class {
 
 //#endregion
 //#region src/templates/toolkit-description.liquid?raw
-var toolkit_description_default = "<toolkit id=\"{{ serverId }}\">\n<instruction>\nBefore you use any capabilities below, you MUST call this tool with a list of names to learn how to use them properly; this includes:\n- For tools: Arguments schema needed to pass to use_tool\n- For skills: Detailed instructions that will expand when invoked (Prefer to be explored first when relevant)\n\nThis tool is optimized for batch queries - you can request multiple capabilities at once for better performance.\n\nHow to invoke:\n- For MCP tools: Use use_tool with toolName and toolArgs based on the schema\n- For skills: Use this tool with the skill name to get expanded instructions\n</instruction>\n\n<available_capabilities>\n{% for server in servers -%}\n<group name=\"{{ server.name }}\">\n{% if server.instruction -%}\n<group_instruction>{{ server.instruction }}</group_instruction>\n{% endif -%}\n{% if server.omitToolDescription -%}\n{% for toolName in server.toolNames -%}\n<item name=\"{{ toolName }}\"></item>\n{% endfor -%}\n{% else -%}\n{% for tool in server.tools -%}\n<item name=\"{{ tool.displayName }}\"><description>{{ tool.description | default: \"No description\" }}</description></item>\n{% endfor -%}\n{% endif -%}\n</group>\n{% endfor -%}\n{% if skills.size > 0 -%}\n<group name=\"skills\">\n{% for skill in skills -%}\n<item name=\"{{ skill.displayName }}\"><description>{{ skill.description }}</description></item>\n{% endfor -%}\n</group>\n{% endif -%}\n</available_capabilities>\n</toolkit>\n";
+var toolkit_description_default = "<toolkit id=\"{{ serverId }}\">\n<instruction>\nBefore you use any capabilities below, you MUST call this tool with a list of names to learn how to use them properly; this includes:\n- For tools: Arguments schema needed to pass to use_tool\n- For skills: Detailed instructions that will expand when invoked (Prefer to be explored first when relevant)\n\nThis tool is optimized for batch queries - you can request multiple capabilities at once for better performance.\n\nHow to invoke:\n- For MCP tools: Use use_tool with toolName and toolArgs based on the schema\n- For skills: Use this tool with the skill name to get expanded instructions\n</instruction>\n\n<available_capabilities>\n{% for server in servers -%}\n<group original-mcp-server=\"{{ server.name }}\">\n{% if server.instruction -%}\n<group_instruction>{{ server.instruction }}</group_instruction>\n{% endif -%}\n{% if server.omitToolDescription -%}\n{% for toolName in server.toolNames -%}\n<item name=\"{{ toolName }}\"></item>\n{% endfor -%}\n{% else -%}\n{% for tool in server.tools -%}\n<item name=\"{{ tool.displayName }}\"><description>{{ tool.description | default: \"No description\" }}</description></item>\n{% endfor -%}\n{% endif -%}\n</group>\n{% endfor -%}\n{% if skills.size > 0 -%}\n<group name=\"skills\">\n{% for skill in skills -%}\n<item name=\"{{ skill.displayName }}\"><description>{{ skill.description }}</description></item>\n{% endfor -%}\n</group>\n{% endif -%}\n</available_capabilities>\n</toolkit>\n";
 
 //#endregion
 //#region src/tools/DescribeToolsTool.ts
@@ -2982,6 +2986,11 @@ function formatSkillInstructions(name, instructions) {
 	return `<command-message>The "${name}" skill is loading</command-message>\n${instructions}`;
 }
 /**
+* Input schema for the DescribeToolsTool
+* @property toolNames - Array of tool names to get detailed information about
+*/
+const DescribeToolsToolInputSchema = z.object({ toolNames: z.array(z.string().min(1)).min(1).describe("List of tool names to get detailed information about") });
+/**
 * DescribeToolsTool provides progressive disclosure of MCP tools and skills.
 *
 * This tool lists available tools from all connected MCP servers and skills
@@ -3238,25 +3247,15 @@ var DescribeToolsTool = class DescribeToolsTool {
 	*
 	* @returns Tool definition with description and input schema
 	*/
+	getInputSchema() {
+		return DescribeToolsToolInputSchema;
+	}
 	async getDefinition() {
 		const { content } = await this.buildToolkitDescription();
 		return {
 			name: DescribeToolsTool.TOOL_NAME,
 			description: content,
-			inputSchema: {
-				type: "object",
-				properties: { toolNames: {
-					type: "array",
-					items: {
-						type: "string",
-						minLength: 1
-					},
-					description: "List of tool names to get detailed information about",
-					minItems: 1
-				} },
-				required: ["toolNames"],
-				additionalProperties: false
-			}
+			inputSchema: z.toJSONSchema(DescribeToolsToolInputSchema, { reused: "inline" })
 		};
 	}
 	/**
@@ -3270,9 +3269,9 @@ var DescribeToolsTool = class DescribeToolsTool {
 	* @param input - Object containing toolNames array
 	* @returns CallToolResult with tool/skill descriptions or error
 	*/
-	async execute(input) {
+	async execute(rawInput) {
 		try {
-			const { toolNames } = input;
+			const { toolNames } = DescribeToolsToolInputSchema.parse(rawInput);
 			const serverDefinitions = await this.definitionsCacheService.getServerDefinitions();
 			if (!toolNames || toolNames.length === 0) return {
 				content: [{
@@ -3446,6 +3445,10 @@ function getUniqueSortedCapabilities(tools) {
 
 //#endregion
 //#region src/tools/SearchListToolsTool.ts
+const SearchListToolsToolInputSchema = z.object({
+	capability: z.string().optional().describe("Optional capability filter. Matches explicit capability tags first, then server summaries, server names, tool names, and tool descriptions."),
+	serverName: z.string().optional().describe("Optional server name filter.")
+});
 var SearchListToolsTool = class SearchListToolsTool {
 	static TOOL_NAME = "list_tools";
 	constructor(_clientManager, definitionsCacheService) {
@@ -3455,6 +3458,9 @@ var SearchListToolsTool = class SearchListToolsTool {
 	formatToolName(toolName, serverName, toolToServers) {
 		return (toolToServers.get(toolName) || []).length > 1 ? `${serverName}__${toolName}` : toolName;
 	}
+	getInputSchema() {
+		return SearchListToolsToolInputSchema;
+	}
 	async getDefinition() {
 		const serverDefinitions = await this.definitionsCacheService.getServerDefinitions();
 		const capabilitySummary = serverDefinitions.length > 0 ? serverDefinitions.map((server) => {
@@ -3465,23 +3471,11 @@ var SearchListToolsTool = class SearchListToolsTool {
 		return {
 			name: SearchListToolsTool.TOOL_NAME,
 			description: `Search proxied MCP tools by server capability summary.\n\nAvailable capabilities:\n${capabilitySummary}`,
-			inputSchema: {
-				type: "object",
-				properties: {
-					capability: {
-						type: "string",
-						description: "Optional capability filter. Matches explicit capability tags first, then server summaries, server names, tool names, and tool descriptions."
-					},
-					serverName: {
-						type: "string",
-						description: "Optional server name filter."
-					}
-				},
-				additionalProperties: false
-			}
+			inputSchema: z.toJSONSchema(SearchListToolsToolInputSchema, { reused: "inline" })
 		};
 	}
-	async execute(input) {
+	async execute(rawInput) {
+		const input = SearchListToolsToolInputSchema.parse(rawInput);
 		const serverDefinitions = await this.definitionsCacheService.getServerDefinitions();
 		const capabilityFilter = input.capability?.trim().toLowerCase();
 		const serverNameFilter = input.serverName?.trim().toLowerCase();
@@ -3524,6 +3518,39 @@ var SearchListToolsTool = class SearchListToolsTool {
 //#endregion
 //#region src/tools/UseToolTool.ts
 /**
+* UseToolTool - Progressive disclosure tool for calling MCP tools and skills
+*
+* DESIGN PATTERNS:
+* - Tool pattern with getDefinition() and execute() methods
+* - Dependency injection for client manager and skill service
+* - Progressive disclosure pattern
+* - Proxy pattern for forwarding tool calls
+*
+* CODING STANDARDS:
+* - Implement Tool interface from ../types
+* - Use TOOL_NAME constant with snake_case
+* - Return CallToolResult with content array
+* - Handle errors with isError flag
+*
+* AVOID:
+* - Complex business logic in execute method
+* - Unhandled promise rejections
+* - Missing error handling
+*
+* NAMING CONVENTIONS:
+* - Tools from MCP servers use serverName__toolName format when clashing
+* - Skills use skill__skillName format (skill__ prefix)
+*/
+/**
+* Input schema for UseToolTool
+* @property toolName - Name of the tool or skill to execute
+* @property toolArgs - Arguments to pass to the tool (from describe_tools schema)
+*/
+const UseToolToolInputSchema = z.object({
+	toolName: z.string().min(1).describe("Name of the tool to execute"),
+	toolArgs: z.record(z.string(), z.unknown()).optional().describe("Arguments to pass to the tool, as discovered from describe_tools")
+});
+/**
 * UseToolTool executes MCP tools and skills with proper error handling.
 *
 * This tool supports three invocation patterns:
@@ -3563,6 +3590,9 @@ var UseToolTool = class UseToolTool {
 	*
 	* @returns The tool definition conforming to MCP spec
 	*/
+	getInputSchema() {
+		return UseToolToolInputSchema;
+	}
 	getDefinition() {
 		return {
 			name: UseToolTool.TOOL_NAME,
@@ -3572,22 +3602,7 @@ var UseToolTool = class UseToolTool {
 
 IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverId}".
 `,
-			inputSchema: {
-				type: "object",
-				properties: {
-					toolName: {
-						type: "string",
-						description: "Name of the tool to execute",
-						minLength: 1
-					},
-					toolArgs: {
-						type: "object",
-						description: "Arguments to pass to the tool, as discovered from describe_tools"
-					}
-				},
-				required: ["toolName"],
-				additionalProperties: false
-			}
+			inputSchema: z.toJSONSchema(UseToolToolInputSchema, { reused: "inline" })
 		};
 	}
 	/**
@@ -3600,6 +3615,16 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 	* @param skill - The skill that was requested
 	* @returns CallToolResult with guidance message
 	*/
+	/**
+	* Coerce toolArgs using the downstream tool's cached JSON Schema.
+	* Converts the schema to Zod and runs coerceArgs so that string-encoded
+	* objects/arrays are parsed before being forwarded to the downstream server.
+	*/
+	async coerceToolArgs(serverName, toolName, toolArgs) {
+		const jsonSchema = await this.definitionsCacheService.getToolSchema(serverName, toolName);
+		if (!jsonSchema) return toolArgs;
+		return coerceArgs(toolArgs, jsonSchemaToZod(jsonSchema));
+	}
 	executeSkill(skill) {
 		return { content: [{
 			type: "text",
@@ -3645,9 +3670,9 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 	* @param input - The tool/skill name and optional arguments
 	* @returns CallToolResult with execution output or error
 	*/
-	async execute(input) {
+	async execute(rawInput) {
 		try {
-			const { toolName: inputToolName, toolArgs = {} } = input;
+			const { toolName: inputToolName, toolArgs = {} } = UseToolToolInputSchema.parse(rawInput);
 			if (inputToolName.startsWith(SKILL_PREFIX)) {
 				const skillName = inputToolName.slice(SKILL_PREFIX.length);
 				if (this.skillService) {
@@ -3676,7 +3701,8 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 					isError: true
 				};
 				const reqTimeout = this.clientManager.getServerRequestTimeout(serverName);
-				return await client.callTool(actualToolName, toolArgs, reqTimeout ? { timeout: reqTimeout } : void 0);
+				const coercedArgs = await this.coerceToolArgs(serverName, actualToolName, toolArgs);
+				return await client.callTool(actualToolName, coercedArgs, reqTimeout ? { timeout: reqTimeout } : void 0);
 			} catch (error) {
 				return {
 					content: [{
@@ -3713,7 +3739,8 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 				const targetServerName = matchingServers[0];
 				const client = await this.clientManager.ensureConnected(targetServerName);
 				const targetReqTimeout = this.clientManager.getServerRequestTimeout(targetServerName);
-				return await client.callTool(actualToolName, toolArgs, targetReqTimeout ? { timeout: targetReqTimeout } : void 0);
+				const coercedArgs = await this.coerceToolArgs(targetServerName, actualToolName, toolArgs);
+				return await client.callTool(actualToolName, coercedArgs, targetReqTimeout ? { timeout: targetReqTimeout } : void 0);
 			} catch (error) {
 				return {
 					content: [{
@@ -4394,19 +4421,38 @@ var StdioTransportHandler = class {
 * - Transport handler pattern implementing TransportHandler interface
 * - STDIO transport with MCP request forwarding to HTTP backend
 * - Graceful cleanup with error isolation
+* - Reconnection with exponential backoff on connection loss
 *
 * CODING STANDARDS:
 * - Use StdioServerTransport for stdio communication
 * - Reuse a single StreamableHTTP client connection
 * - Wrap async operations with try-catch and descriptive errors
+* - Reconnect transparently on connection reset
 *
 * AVOID:
 * - Starting HTTP server lifecycle in this transport entry point
 * - Recreating HTTP client per request
 * - Swallowing cleanup failures silently
 */
+const CONNECTION_ERROR_PATTERNS = [
+	"econnrefused",
+	"econnreset",
+	"enotfound",
+	"connection refused",
+	"fetch failed",
+	"socket hang up",
+	"network error",
+	"failed to fetch"
+];
+function isConnectionError(error) {
+	if (!(error instanceof Error)) return false;
+	const message = error.message.toLowerCase();
+	return CONNECTION_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
+}
 /**
 * Transport that serves MCP over stdio and forwards MCP requests to an HTTP endpoint.
+* Automatically reconnects to the HTTP backend with exponential backoff when the
+* connection is lost (e.g. backend crash + restart).
 */
 var StdioHttpTransportHandler = class {
 	endpoint;
@@ -4414,24 +4460,19 @@ var StdioHttpTransportHandler = class {
 	stdioTransport = null;
 	httpClient = null;
 	logger;
+	MAX_RECONNECT_ATTEMPTS = 5;
+	RECONNECT_BASE_MS = 1e3;
+	RECONNECT_MAX_MS = 3e4;
 	constructor(config, logger = console) {
 		this.endpoint = config.endpoint;
 		this.logger = logger;
 	}
 	async start() {
 		try {
-			const httpClientTransport = new StreamableHTTPClientTransport(this.endpoint);
-			const client = new Client({
-				name: "@agimon-ai/mcp-proxy-stdio-http-proxy",
-				version: "0.1.0"
-			}, { capabilities: { elicitation: {} } });
-			await client.connect(httpClientTransport);
+			const client = await this.createAndConnectClient();
 			this.httpClient = client;
-			this.stdioProxyServer = this.createProxyServer(client);
-			const proxyServer = this.stdioProxyServer;
-			client.setRequestHandler(ElicitRequestSchema, async (request) => {
-				return await proxyServer.elicitInput(request.params);
-			});
+			this.stdioProxyServer = this.createProxyServer();
+			this.registerElicitationHandler(client);
 			this.stdioTransport = new StdioServerTransport();
 			await this.stdioProxyServer.connect(this.stdioTransport);
 			this.logger.info(`@agimon-ai/mcp-proxy MCP stdio proxy connected to ${this.endpoint.toString()}`);
@@ -4473,7 +4514,52 @@ var StdioHttpTransportHandler = class {
 		]);
 		if (cleanupErrors.length > 0) throw new Error(`Failed to stop stdio-http proxy transport: ${cleanupErrors.join("; ")}`);
 	}
-	createProxyServer(client) {
+	async createAndConnectClient() {
+		const httpClientTransport = new StreamableHTTPClientTransport(this.endpoint);
+		const client = new Client({
+			name: "@agimon-ai/mcp-proxy-stdio-http-proxy",
+			version: "0.1.0"
+		}, { capabilities: { elicitation: {} } });
+		await client.connect(httpClientTransport);
+		return client;
+	}
+	registerElicitationHandler(client) {
+		const proxyServer = this.stdioProxyServer;
+		if (!proxyServer) return;
+		client.setRequestHandler(ElicitRequestSchema, async (request) => {
+			return await proxyServer.elicitInput(request.params);
+		});
+	}
+	async reconnectWithBackoff() {
+		for (let attempt = 0; attempt < this.MAX_RECONNECT_ATTEMPTS; attempt++) {
+			const delay = Math.min(this.RECONNECT_BASE_MS * 2 ** attempt, this.RECONNECT_MAX_MS);
+			await new Promise((resolve$1) => setTimeout(resolve$1, delay));
+			try {
+				await this.httpClient?.close().catch(() => void 0);
+				const client = await this.createAndConnectClient();
+				this.httpClient = client;
+				this.registerElicitationHandler(client);
+				this.logger.info(`Reconnected to HTTP backend at ${this.endpoint.toString()} (attempt ${attempt + 1})`);
+				return;
+			} catch {
+				this.logger.info(`Reconnect attempt ${attempt + 1}/${this.MAX_RECONNECT_ATTEMPTS} to ${this.endpoint.toString()} failed`);
+			}
+		}
+		throw new Error(`Failed to reconnect to HTTP backend at ${this.endpoint.toString()} after ${this.MAX_RECONNECT_ATTEMPTS} attempts`);
+	}
+	async withReconnect(fn) {
+		if (!this.httpClient) throw new Error("HTTP client not connected");
+		try {
+			return await fn();
+		} catch (error) {
+			if (isConnectionError(error)) {
+				await this.reconnectWithBackoff();
+				return await fn();
+			}
+			throw error;
+		}
+	}
+	createProxyServer() {
 		const proxyServer = new Server({
 			name: "@agimon-ai/mcp-proxy-stdio-http-proxy",
 			version: "0.1.0"
@@ -4484,48 +4570,48 @@ var StdioHttpTransportHandler = class {
 		} });
 		proxyServer.setRequestHandler(ListToolsRequestSchema, async () => {
 			try {
-				return await client.listTools();
+				return await this.withReconnect(() => this.httpClient.listTools());
 			} catch (error) {
 				throw new Error(`Failed forwarding tools/list to HTTP backend: ${error instanceof Error ? error.message : String(error)}`);
 			}
 		});
 		proxyServer.setRequestHandler(CallToolRequestSchema, async (request) => {
 			try {
-				return await client.callTool({
+				return await this.withReconnect(() => this.httpClient.callTool({
 					name: request.params.name,
 					arguments: request.params.arguments
-				});
+				}));
 			} catch (error) {
 				throw new Error(`Failed forwarding tools/call (${request.params.name}) to HTTP backend: ${error instanceof Error ? error.message : String(error)}`);
 			}
 		});
 		proxyServer.setRequestHandler(ListResourcesRequestSchema, async () => {
 			try {
-				return await client.listResources();
+				return await this.withReconnect(() => this.httpClient.listResources());
 			} catch (error) {
 				throw new Error(`Failed forwarding resources/list to HTTP backend: ${error instanceof Error ? error.message : String(error)}`);
 			}
 		});
 		proxyServer.setRequestHandler(ReadResourceRequestSchema, async (request) => {
 			try {
-				return await client.readResource({ uri: request.params.uri });
+				return await this.withReconnect(() => this.httpClient.readResource({ uri: request.params.uri }));
 			} catch (error) {
 				throw new Error(`Failed forwarding resources/read (${request.params.uri}) to HTTP backend: ${error instanceof Error ? error.message : String(error)}`);
 			}
 		});
 		proxyServer.setRequestHandler(ListPromptsRequestSchema, async () => {
 			try {
-				return await client.listPrompts();
+				return await this.withReconnect(() => this.httpClient.listPrompts());
 			} catch (error) {
 				throw new Error(`Failed forwarding prompts/list to HTTP backend: ${error instanceof Error ? error.message : String(error)}`);
 			}
 		});
 		proxyServer.setRequestHandler(GetPromptRequestSchema, async (request) => {
 			try {
-				return await client.getPrompt({
+				return await this.withReconnect(() => this.httpClient.getPrompt({
 					name: request.params.name,
 					arguments: request.params.arguments
-				});
+				}));
 			} catch (error) {
 				throw new Error(`Failed forwarding prompts/get (${request.params.name}) to HTTP backend: ${error instanceof Error ? error.message : String(error)}`);
 			}
@@ -4888,21 +4974,27 @@ async function createSessionServer(shared) {
 	})() : [await describeTools.getDefinition(), useToolWithCache.getDefinition()] }));
 	server.setRequestHandler(CallToolRequestSchema, async (request) => {
 		const { name, arguments: args } = request.params;
-		if (name === DescribeToolsTool.TOOL_NAME) try {
-			return await describeTools.execute(args);
-		} catch (error) {
-			throw new Error(`Failed to execute ${name}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		if (name === UseToolTool.TOOL_NAME) try {
-			return await useToolWithCache.execute(args);
-		} catch (error) {
-			throw new Error(`Failed to execute ${name}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		if (name === SearchListToolsTool.TOOL_NAME && proxyMode === "search") try {
-			return await searchListTools.execute(args);
-		} catch (error) {
-			throw new Error(`Failed to execute ${name}: ${error instanceof Error ? error.message : String(error)}`);
-		}
+		const executeWithCoercion = async (tool, toolName) => {
+			const coerced = coerceArgs(args ?? {}, tool.getInputSchema());
+			try {
+				return await tool.execute(coerced);
+			} catch (error) {
+				if (error instanceof z.ZodError) return {
+					content: [{
+						type: "text",
+						text: formatZodError(error, {
+							schemaName: toolName,
+							schema: tool.getInputSchema()
+						})
+					}],
+					isError: true
+				};
+				throw new Error(`Failed to execute ${toolName}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		};
+		if (name === DescribeToolsTool.TOOL_NAME) return await executeWithCoercion(describeTools, name);
+		if (name === UseToolTool.TOOL_NAME) return await executeWithCoercion(useToolWithCache, name);
+		if (name === SearchListToolsTool.TOOL_NAME && proxyMode === "search") return await executeWithCoercion(searchListTools, name);
 		if (proxyMode === "flat") return await useToolWithCache.execute({
 			toolName: name,
 			toolArgs: args || {}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agimon-ai/mcp-proxy",
   "description": "MCP proxy server package",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "license": "AGPL-3.0",
   "keywords": [
     "mcp",
@@ -27,10 +27,11 @@
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
     "liquidjs": "^10.21.0",
-    "zod": "^3.24.1",
-    "@agimon-ai/foundation-process-registry": "0.5.1",
-    "@agimon-ai/foundation-port-registry": "0.5.1",
-    "@agimon-ai/log-sink-mcp": "0.5.1"
+    "zod": "4.3.6",
+    "@agimon-ai/foundation-process-registry": "0.5.2",
+    "@agimon-ai/foundation-port-registry": "0.5.2",
+    "@agimon-ai/log-sink-mcp": "0.5.3",
+    "@agimon-ai/foundation-validator": "0.2.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",