hono-mcp 1.4.1 → 1.4.2

package/dist/commands/math.js

@@ -7,99 +7,107 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { z } from 'zod';
-import { Command, Param } from '../decorators/command.js';
+import { z } from "zod";
+import { Command, Param } from "../decorators/command.js";
 let AddCommand = class AddCommand {
     a;
     b;
-    async execute() {
-        const result = this.a + this.b;
+    async execute(params) {
+        const result = params.a + params.b;
         return {
-            content: [{ type: 'text', text: `${this.a} + ${this.b} = ${result}` }],
+            content: [
+                { type: "text", text: `${params.a} + ${params.b} = ${result}` },
+            ],
         };
     }
 };
 __decorate([
-    Param(z.number().describe('First number')),
+    Param(z.number().describe("First number")),
     __metadata("design:type", Number)
 ], AddCommand.prototype, "a", void 0);
 __decorate([
-    Param(z.number().describe('Second number')),
+    Param(z.number().describe("Second number")),
     __metadata("design:type", Number)
 ], AddCommand.prototype, "b", void 0);
 AddCommand = __decorate([
-    Command('math.add', 'Add two numbers')
+    Command("math.add", "Add two numbers")
 ], AddCommand);
 export { AddCommand };
 let SubtractCommand = class SubtractCommand {
     a;
     b;
-    async execute() {
-        const result = this.a - this.b;
+    async execute(params) {
+        const result = params.a - params.b;
         return {
-            content: [{ type: 'text', text: `${this.a} - ${this.b} = ${result}` }],
+            content: [
+                { type: "text", text: `${params.a} - ${params.b} = ${result}` },
+            ],
         };
     }
 };
 __decorate([
-    Param(z.number().describe('First number')),
+    Param(z.number().describe("First number")),
     __metadata("design:type", Number)
 ], SubtractCommand.prototype, "a", void 0);
 __decorate([
-    Param(z.number().describe('Second number')),
+    Param(z.number().describe("Second number")),
     __metadata("design:type", Number)
 ], SubtractCommand.prototype, "b", void 0);
 SubtractCommand = __decorate([
-    Command('math.subtract', 'Subtract two numbers')
+    Command("math.subtract", "Subtract two numbers")
 ], SubtractCommand);
 export { SubtractCommand };
 let MultiplyCommand = class MultiplyCommand {
     a;
     b;
-    async execute() {
-        const result = this.a * this.b;
+    async execute(params) {
+        const result = params.a * params.b;
         return {
-            content: [{ type: 'text', text: `${this.a} × ${this.b} = ${result}` }],
+            content: [
+                { type: "text", text: `${params.a} × ${params.b} = ${result}` },
+            ],
         };
     }
 };
 __decorate([
-    Param(z.number().describe('First number')),
+    Param(z.number().describe("First number")),
     __metadata("design:type", Number)
 ], MultiplyCommand.prototype, "a", void 0);
 __decorate([
-    Param(z.number().describe('Second number')),
+    Param(z.number().describe("Second number")),
     __metadata("design:type", Number)
 ], MultiplyCommand.prototype, "b", void 0);
 MultiplyCommand = __decorate([
-    Command('math.multiply', 'Multiply two numbers')
+    Command("math.multiply", "Multiply two numbers")
 ], MultiplyCommand);
 export { MultiplyCommand };
 let DivideCommand = class DivideCommand {
     a;
     b;
-    async execute() {
-        if (this.b === 0) {
+    async execute(params) {
+        if (params.b === 0) {
             return {
-                content: [{ type: 'text', text: 'Error: Division by zero' }],
+                content: [{ type: "text", text: "Error: Division by zero" }],
                 isError: true,
             };
         }
-        const result = this.a / this.b;
+        const result = params.a / params.b;
         return {
-            content: [{ type: 'text', text: `${this.a} ÷ ${this.b} = ${result}` }],
+            content: [
+                { type: "text", text: `${params.a} ÷ ${params.b} = ${result}` },
+            ],
         };
     }
 };
 __decorate([
-    Param(z.number().describe('First number')),
+    Param(z.number().describe("First number")),
     __metadata("design:type", Number)
 ], DivideCommand.prototype, "a", void 0);
 __decorate([
-    Param(z.number().describe('Second number')),
+    Param(z.number().describe("Second number")),
     __metadata("design:type", Number)
 ], DivideCommand.prototype, "b", void 0);
 DivideCommand = __decorate([
-    Command('math.divide', 'Divide two numbers')
+    Command("math.divide", "Divide two numbers")
 ], DivideCommand);
 export { DivideCommand };

package/dist/tools/decorator-tools.js

@@ -2,15 +2,12 @@ import { z } from "zod";
 import { getCommandRegistry } from "../decorators/command.js";
 export const executeCommandTool = (server) => {
     server.tool("executeCommand", "Execute any command by specifying its type and parameters", {
-        type: {
-            type: "string",
-            description: "Command type (e.g., math.add, math.subtract, math.multiply, math.divide)",
-        },
-        params: {
-            type: "object",
-            description: "Command parameters",
-        },
+        type: z
+            .string()
+            .describe("Command type (e.g., math.add, math.subtract, math.multiply, math.divide)"),
+        params: z.record(z.any()).describe("Command parameters"),
     }, async ({ type, params }) => {
+        console.log("executeCommand called with:", { type, params });
         const command = getCommandRegistry().get(type);
         if (!command) {
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono-mcp",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "MCP server built with Hono - supports both Vercel deployment and npx CLI usage",
   "main": "dist/index.js",
   "bin": {