@agimon-ai/mcp-proxy 0.7.1 → 0.7.3

package/dist/{src-DyWwAp8e.cjs → src-Dp2m9_I_.cjs}

@@ -25,13 +25,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
+let __agimon_ai_foundation_validator = require("@agimon-ai/foundation-validator");
 let __modelcontextprotocol_sdk_server_index_js = require("@modelcontextprotocol/sdk/server/index.js");
 let __modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
+let zod = require("zod");
 let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 let js_yaml = require("js-yaml");
 js_yaml = __toESM(js_yaml);
-let zod = require("zod");
 let node_crypto = require("node:crypto");
 let node_os = require("node:os");
 let node_path = require("node:path");
@@ -52,7 +53,7 @@ let __modelcontextprotocol_sdk_server_sse_js = require("@modelcontextprotocol/sd
 let __modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 //#region package.json
-var version = "0.7.0";
+var version = "0.7.2";
 
 //#endregion
 //#region src/utils/mcpConfigSchema.ts
@@ -1365,6 +1366,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);
 	}
@@ -1810,7 +1814,7 @@ var McpClientManagerService = class {
 	async createConnection(serverName, config) {
 		const timeoutMs = config.timeout ?? DEFAULT_CONNECTION_TIMEOUT_MS;
 		const client = new __modelcontextprotocol_sdk_client_index_js.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, {
@@ -2994,7 +2998,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
@@ -3010,6 +3014,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 = zod.z.object({ toolNames: zod.z.array(zod.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
@@ -3266,25 +3275,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: zod.z.toJSONSchema(DescribeToolsToolInputSchema, { reused: "inline" })
 		};
 	}
 	/**
@@ -3298,9 +3297,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: [{
@@ -3474,6 +3473,10 @@ function getUniqueSortedCapabilities(tools) {
 
 //#endregion
 //#region src/tools/SearchListToolsTool.ts
+const SearchListToolsToolInputSchema = zod.z.object({
+	capability: zod.z.string().optional().describe("Optional capability filter. Matches explicit capability tags first, then server summaries, server names, tool names, and tool descriptions."),
+	serverName: zod.z.string().optional().describe("Optional server name filter.")
+});
 var SearchListToolsTool = class SearchListToolsTool {
 	static TOOL_NAME = "list_tools";
 	constructor(_clientManager, definitionsCacheService) {
@@ -3483,6 +3486,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) => {
@@ -3493,23 +3499,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: zod.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();
@@ -3552,6 +3546,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 = zod.z.object({
+	toolName: zod.z.string().min(1).describe("Name of the tool to execute"),
+	toolArgs: zod.z.record(zod.z.string(), zod.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:
@@ -3591,6 +3618,9 @@ var UseToolTool = class UseToolTool {
 	*
 	* @returns The tool definition conforming to MCP spec
 	*/
+	getInputSchema() {
+		return UseToolToolInputSchema;
+	}
 	getDefinition() {
 		return {
 			name: UseToolTool.TOOL_NAME,
@@ -3600,22 +3630,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: zod.z.toJSONSchema(UseToolToolInputSchema, { reused: "inline" })
 		};
 	}
 	/**
@@ -3628,6 +3643,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 (0, __agimon_ai_foundation_validator.coerceArgs)(toolArgs, (0, __agimon_ai_foundation_validator.jsonSchemaToZod)(jsonSchema));
+	}
 	executeSkill(skill) {
 		return { content: [{
 			type: "text",
@@ -3673,9 +3698,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) {
@@ -3704,7 +3729,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: [{
@@ -3741,7 +3767,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: [{
@@ -4422,19 +4449,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;
@@ -4442,24 +4488,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 __modelcontextprotocol_sdk_client_streamableHttp_js.StreamableHTTPClientTransport(this.endpoint);
-			const client = new __modelcontextprotocol_sdk_client_index_js.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(__modelcontextprotocol_sdk_types_js.ElicitRequestSchema, async (request) => {
-				return await proxyServer.elicitInput(request.params);
-			});
+			this.stdioProxyServer = this.createProxyServer();
+			this.registerElicitationHandler(client);
 			this.stdioTransport = new __modelcontextprotocol_sdk_server_stdio_js.StdioServerTransport();
 			await this.stdioProxyServer.connect(this.stdioTransport);
 			this.logger.info(`@agimon-ai/mcp-proxy MCP stdio proxy connected to ${this.endpoint.toString()}`);
@@ -4501,7 +4542,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 __modelcontextprotocol_sdk_client_streamableHttp_js.StreamableHTTPClientTransport(this.endpoint);
+		const client = new __modelcontextprotocol_sdk_client_index_js.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(__modelcontextprotocol_sdk_types_js.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$2) => setTimeout(resolve$2, 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 __modelcontextprotocol_sdk_server_index_js.Server({
 			name: "@agimon-ai/mcp-proxy-stdio-http-proxy",
 			version: "0.1.0"
@@ -4512,48 +4598,48 @@ var StdioHttpTransportHandler = class {
 		} });
 		proxyServer.setRequestHandler(__modelcontextprotocol_sdk_types_js.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(__modelcontextprotocol_sdk_types_js.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(__modelcontextprotocol_sdk_types_js.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(__modelcontextprotocol_sdk_types_js.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(__modelcontextprotocol_sdk_types_js.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(__modelcontextprotocol_sdk_types_js.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)}`);
 			}
@@ -4916,21 +5002,27 @@ async function createSessionServer(shared) {
 	})() : [await describeTools.getDefinition(), useToolWithCache.getDefinition()] }));
 	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.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 = (0, __agimon_ai_foundation_validator.coerceArgs)(args ?? {}, tool.getInputSchema());
+			try {
+				return await tool.execute(coerced);
+			} catch (error) {
+				if (error instanceof zod.z.ZodError) return {
+					content: [{
+						type: "text",
+						text: (0, __agimon_ai_foundation_validator.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 || {}