hono-mcp 1.4.6 → 1.4.8

package/dist/commands/agent.js

@@ -0,0 +1,148 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import OpenAI from "openai";
+import { z } from "zod";
+import { Command, Param } from "../decorators/command.js";
+// 有效的授权码列表（可从环境变量读取）
+const VALID_ACCESS_CODES = new Set((process.env.ACCESS_CODES || "test-fromsko").split(","));
+const TASK_PLANNER_PROMPT = `你是一个专业的任务规划助手。根据用户的需求，生成结构化的任务执行计划。
+
+## 输出要求
+必须返回严格的 JSON 格式，包含以下结构：
+{
+  "task": "需求的简短摘要",
+  "steps": [
+    {
+      "id": 1,
+      "action": "具体动作（动词开头）",
+      "description": "详细描述",
+      "deps": []
+    }
+  ]
+}
+
+## 规则
+1. 每个步骤必须有唯一的 id（从 1 开始递增）
+2. action 用简短的动词短语描述
+3. deps 数组包含依赖的步骤 id（无依赖则为空数组）
+4. 步骤要具体、可执行
+5. 只返回 JSON，不要其他内容`;
+let TaskPlannerCommand = class TaskPlannerCommand {
+    access_code;
+    api_key;
+    require;
+    async execute(params) {
+        const result = await this.plan(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: !result.success,
+        };
+    }
+    async plan(params) {
+        // 1. 验证授权码
+        if (!VALID_ACCESS_CODES.has(params.access_code)) {
+            return {
+                success: false,
+                error: {
+                    code: "INVALID_ACCESS_CODE",
+                    message: "授权码无效，请检查 access_code 参数",
+                },
+            };
+        }
+        // 2. 验证 API Key 格式
+        if (!params.api_key || params.api_key.length < 10) {
+            return {
+                success: false,
+                error: {
+                    code: "INVALID_API_KEY",
+                    message: "API Key 格式无效",
+                },
+            };
+        }
+        // 3. 验证需求不为空
+        if (!params.require.trim()) {
+            return {
+                success: false,
+                error: {
+                    code: "EMPTY_REQUIREMENT",
+                    message: "需求内容不能为空",
+                },
+            };
+        }
+        // 4. 调用 OpenAI API
+        try {
+            const client = new OpenAI({
+                apiKey: params.api_key,
+                baseURL: "https://andysama.work/v1",
+            });
+            const response = await client.chat.completions.create({
+                model: "LongCat-Flash-Chat",
+                messages: [
+                    { role: "system", content: TASK_PLANNER_PROMPT },
+                    { role: "user", content: params.require },
+                ],
+                temperature: 0.7,
+                response_format: { type: "json_object" },
+            });
+            const content = response.choices[0]?.message?.content;
+            if (!content) {
+                return {
+                    success: false,
+                    error: {
+                        code: "EMPTY_RESPONSE",
+                        message: "模型返回内容为空",
+                    },
+                };
+            }
+            const data = JSON.parse(content);
+            return {
+                success: true,
+                data,
+            };
+        }
+        catch (err) {
+            const error = err;
+            // 判断是否为 API Key 错误
+            if (error.message?.includes("401") ||
+                error.message?.includes("Unauthorized")) {
+                return {
+                    success: false,
+                    error: {
+                        code: "INVALID_API_KEY",
+                        message: "API Key 无效或已过期",
+                    },
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    code: "API_ERROR",
+                    message: error.message || "调用模型服务失败",
+                },
+            };
+        }
+    }
+};
+__decorate([
+    Param(z.string().describe("Access code for authorization")),
+    __metadata("design:type", String)
+], TaskPlannerCommand.prototype, "access_code", void 0);
+__decorate([
+    Param(z.string().describe("API key for model service")),
+    __metadata("design:type", String)
+], TaskPlannerCommand.prototype, "api_key", void 0);
+__decorate([
+    Param(z.string().describe("User requirement to plan")),
+    __metadata("design:type", String)
+], TaskPlannerCommand.prototype, "require", void 0);
+TaskPlannerCommand = __decorate([
+    Command("agent.task-planner", "AI-powered task planning assistant that generates structured execution plans")
+], TaskPlannerCommand);
+export { TaskPlannerCommand };

package/dist/index.js

@@ -3,6 +3,7 @@ import { createMcpHandler } from "mcp-handler";
 import 'reflect-metadata';
 import vscodeSettings from './data/vscode-settings.json' with { type: 'json' };
 import { executeCommandTool, helpTool } from "./tools/decorator-tools.js";
+import './commands/agent.js';
 import './commands/math.js';
 import './commands/prompt.js';
 const app = new Hono();

package/dist/stdio.js

@@ -1,7 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import "reflect-metadata";
+import "./commands/agent.js";
 import "./commands/math.js";
+import "./commands/prompt.js";
 import { executeCommandTool, helpTool } from "./tools/decorator-tools.js";
 async function runStdioServer() {
     const server = new McpServer({

package/dist/tools/decorator-tools.js

@@ -7,6 +7,7 @@ export const executeCommandTool = (server) => {
             .describe("Command type (e.g., math.add, math.subtract, math.multiply, math.divide)"),
         params: z
             .record(z.unknown())
+            .optional()
             .describe("Command parameters (optional for commands without params)"),
     }, async ({ type, params = {}, }) => {
         console.log("executeCommand called with:", { type, params });
@@ -40,51 +41,73 @@ export const executeCommandTool = (server) => {
         return await command.handler(validationResult.data);
     });
 };
+// 从 Zod schema 提取类型名
+function getZodTypeName(schema) {
+    const def = schema._def;
+    if (def.typeName === "ZodOptional") {
+        return getZodTypeName(def.innerType) + "?";
+    }
+    if (def.typeName === "ZodDefault") {
+        return getZodTypeName(def.innerType);
+    }
+    if (def.typeName === "ZodString")
+        return "string";
+    if (def.typeName === "ZodNumber")
+        return "number";
+    if (def.typeName === "ZodBoolean")
+        return "boolean";
+    if (def.typeName === "ZodArray")
+        return "array";
+    if (def.typeName === "ZodObject")
+        return "object";
+    return "any";
+}
+// 生成示例值
+function getExampleValue(schema) {
+    const def = schema._def;
+    if (def.typeName === "ZodOptional" || def.typeName === "ZodDefault") {
+        return undefined; // optional 参数不生成示例
+    }
+    if (def.typeName === "ZodString")
+        return "example";
+    if (def.typeName === "ZodNumber")
+        return 1;
+    if (def.typeName === "ZodBoolean")
+        return true;
+    return null;
+}
 export const helpTool = (server) => {
-    server.tool("help", "Get help information about available commands", {
-        type: z
-            .string()
-            .optional()
-            .describe("Command type to get help for (optional)"),
-    }, async ({ type }) => {
-        if (type) {
-            const command = getCommandRegistry().get(type);
-            if (!command) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Unknown command type: ${type}\n\nAvailable commands:\n${Array.from(getCommandRegistry().keys())
-                                .map((t) => `- ${t}`)
-                                .join("\n")}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            const paramsInfo = Array.from(command.params.entries())
-                .map(([key, schema]) => {
-                const description = schema.description || "No description";
-                return `- ${key}: ${description}`;
-            })
-                .join("\n");
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Command: ${command.type}\nDescription: ${command.description}\n\nParameters:\n${paramsInfo}`,
-                    },
-                ],
-            };
-        }
-        const commandList = Array.from(getCommandRegistry().values())
-            .map((cmd) => `- ${cmd.type}: ${cmd.description}`)
-            .join("\n");
+    server.tool("help", "Get help information about available commands", {}, async () => {
+        const commands = Array.from(getCommandRegistry().values());
+        const sections = commands.map((cmd) => {
+            // 构建参数类型字符串
+            const paramEntries = Array.from(cmd.params.entries());
+            const paramsStr = paramEntries.length === 0
+                ? "{}"
+                : "{ " +
+                    paramEntries
+                        .map(([key, schema]) => `${key}: ${getZodTypeName(schema)}`)
+                        .join(", ") +
+                    " }";
+            // 构建示例 params
+            const exampleParams = {};
+            paramEntries.forEach(([key, schema]) => {
+                const val = getExampleValue(schema);
+                if (val !== undefined) {
+                    exampleParams[key] = val;
+                }
+            });
+            const example = JSON.stringify({
+                type: cmd.type,
+                params: exampleParams,
+            });
+            return `### ${cmd.type}\n${cmd.description}\nParams: ${paramsStr}\nExample: ${example}`;
+        });
         return {
             content: [
                 {
                     type: "text",
-                    text: `Available commands:\n${commandList}\n\nUse help with a specific command type for details.`,
+                    text: `## Commands\n\n${sections.join("\n\n")}`,
                 },
             ],
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono-mcp",
-  "version": "1.4.6",
+  "version": "1.4.8",
   "description": "MCP server built with Hono - supports both Vercel deployment and npx CLI usage",
   "main": "dist/index.js",
   "bin": {
@@ -41,6 +41,7 @@
     "@vercel/edge-config": "^1.4.3",
     "hono": "^4.9.2",
     "mcp-handler": "^1.0.1",
+    "openai": "^6.15.0",
     "reflect-metadata": "^0.2.2",
     "zod": "^3"
   },