foliko 1.1.6 → 1.1.7

package/src/executors/mcp-executor.js

@@ -10,7 +10,7 @@ const path = require('path');
 const { z } = require('zod');
 const { createMCPClient } = require('@ai-sdk/mcp');
 const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio.js');
-const { zodSchemaToTable } = require('@chnak/zod-to-markdown');
+const { zodSchemaToMarkdown } = require('@chnak/zod-to-markdown');
 const { logger } = require('../utils/logger');
 
 const log = logger.child('MCPExecutor');
@@ -193,7 +193,7 @@ class MCPClientWrapper {
 class MCPExecutorPlugin extends Plugin {
   constructor(config = {}) {
     super();
-    this.name = 'mcp-executor';
+    this.name = 'mcp';
     this.version = '1.0.0';
     this.description = 'MCP (Model Context Protocol) 执行器';
     this.priority = 11;
@@ -203,6 +203,9 @@ class MCPExecutorPlugin extends Plugin {
     // serverName -> { client, tools: [{ name, description, inputSchema }], toolObjects: { toolName: actualTool } }
     this._clients = new Map();
     this._config = config;
+    // 注册的工具对象（extension-executor 会扫描这个）
+    // 格式: { 'server_toolname': { name, description, inputSchema, execute } }
+    this.tools = {};
   }
 
   install(framework) {
@@ -520,6 +523,8 @@ class MCPExecutorPlugin extends Plugin {
     if (!inputSchema) return {};
     // 处理 {jsonSchema: {...}} 格式
     if (inputSchema.jsonSchema) return inputSchema.jsonSchema;
+    // 处理 {inputSchema: {...}} 格式 (某些 MCP 服务器返回这种格式)
+    if (inputSchema.inputSchema) return inputSchema.inputSchema;
     // 处理直接是 schema 的格式
     return inputSchema;
   }
@@ -532,49 +537,71 @@ class MCPExecutorPlugin extends Plugin {
       return '';
     }
 
-    let desc = '【MCP Servers】 工具合集\n\n';
-    desc += '你可以通过 `mcp_call` 工具调用以下 MCP 服务器的工具。\n\n';
+    let desc = '## 【MCP Servers】 工具合集\n\n';
+    desc += 'MCP 服务器工具已注册为 `服务器_工具名` 格式（如 github_search）。\n';
+    desc += '通过 `ext_call` 调用：\n\n';
 
     for (const [serverName, info] of this._clients) {
       desc += `### ${serverName}\n\n`;
       for (const tool of info.tools) {
-        desc += `#### ${tool.name}\n`;
-        desc += `${tool.description || '无描述'}\n\n`;
+        const fullName = `${serverName}_${tool.name}`;
+        desc += `- **${fullName}**: ${tool.description || '无描述'}\n`;
 
         // 使用 zodSchemaToMarkdown 生成参数文档
-        const schema = tool.inputSchema;
+        const rawSchema = tool.inputSchema;
+        const schema = this._extractSchema(rawSchema);
         if (schema) {
           try {
-            if (typeof schema.toJSON === 'function') {
+            let schemaResult = null;
+            let zodSchemaForFallback = null; // 保存 Zod schema 供 fallback 使用
+            // 检查是否是 Zod schema (有 shape 方法或 _def 属性)
+            const isZodSchema =
+              typeof schema.shape === 'function' || (schema._def && schema._def.typeName);
+            if (isZodSchema) {
               // Zod schema 直接转换
-              desc += `**参数:**\n\n`;
-              desc += zodSchemaToTable(schema) + '\n\n';
+              schemaResult = zodSchemaToMarkdown(schema);
+              zodSchemaForFallback = schema;
             } else if (schema.jsonSchema) {
               // JSON Schema 格式，尝试转换为 Zod schema
               const zodSchema = this._jsonSchemaToZod(schema.jsonSchema || schema);
               if (zodSchema) {
-                desc += `**参数:**\n\n`;
-                desc += zodSchemaToTable(zodSchema) + '\n\n';
+                schemaResult = zodSchemaToMarkdown(zodSchema);
+                zodSchemaForFallback = zodSchema;
               }
             } else if (schema.properties) {
               // 已经是对象格式
               const zodSchema = this._jsonSchemaToZod(schema);
               if (zodSchema) {
+                schemaResult = zodSchemaToMarkdown(zodSchema);
+                zodSchemaForFallback = zodSchema;
+              }
+            }
+
+            // 检查是否包含未解析的原始 Zod 类型名或只有类型信息没有参数
+            if (schemaResult) {
+              const hasUnparsedTypes = /\|.*\bZod\w+\b.*\|/.test(schemaResult);
+              // 检查是否只有类型信息而没有实际参数（如 "Type: Object" 或 "Type: ZodAny"）
+              const hasOnlyType =
+                /^-\s+\w+:\s+.+\n?$/.test(schemaResult.trim()) && !schemaResult.includes('`');
+              if (hasUnparsedTypes || hasOnlyType) {
+                // zodSchemaToMarkdown 未正确解析，使用 fallback
+                desc += this._fallbackParamsDesc(zodSchemaForFallback || schema);
+              } else {
                 desc += `**参数:**\n\n`;
-                desc += zodSchemaToTable(zodSchema) + '\n\n';
+                desc += schemaResult + '\n\n';
               }
             }
           } catch (e) {
             // 如果转换失败，使用简化格式
-            desc += this._fallbackParamsDesc(schema);
+            desc += this._fallbackParamsDesc(zodSchemaForFallback || schema);
           }
         }
       }
-      desc += '---\n\n';
+      desc += '\n';
     }
 
     desc += '**调用格式:**\n';
-    desc += '```\nmcp_call({ server: "服务器", tool: "工具", args_json: \'{"参数": "值"}\' })\n';
+    desc += '```\next_call({ plugin: "mcp", tool: "服务器_工具名", args: {参数} })\n';
     desc += '```\n';
     return desc.trim();
   }
@@ -648,21 +675,126 @@ class MCPExecutorPlugin extends Plugin {
    * 回退的参数描述（当 zodSchemaToMarkdown 失败时）
    */
   _fallbackParamsDesc(schema) {
+    // 优先尝试 JSON Schema 格式
     const props = schema.properties || {};
     const required = schema.required || [];
 
-    if (Object.keys(props).length === 0) {
-      return '';
+    if (Object.keys(props).length > 0) {
+      let desc = '**参数:**\n\n';
+      for (const [key, prop] of Object.entries(props)) {
+        const isRequired = required.includes(key);
+        const type = prop.type || 'any';
+        const desc_text = prop.description || '';
+        desc += `- \`${key}\`${isRequired ? ' (必填)' : ''}: ${type} ${desc_text}\n`;
+      }
+      return desc + '\n';
     }
 
-    let desc = '**参数:**\n\n';
-    for (const [key, prop] of Object.entries(props)) {
-      const isRequired = required.includes(key);
-      const type = prop.type || 'any';
-      const desc_text = prop.description || '';
-      desc += `- \`${key}\`${isRequired ? ' (必填)' : ''}: ${type} ${desc_text}\n`;
+    // 尝试 Zod schema 格式
+    if (typeof schema.shape === 'function' || (schema._def && schema._def.shape)) {
+      const shape = typeof schema.shape === 'function' ? schema.shape() : schema._def.shape();
+      if (shape && typeof shape === 'object') {
+        let desc = '**参数:**\n\n';
+        for (const [key, field] of Object.entries(shape)) {
+          const typeInfo = this._extractZodFieldType(field);
+          const isOptional = typeInfo.isOptional ? ' (可选)' : ' (必填)';
+          desc += `- \`${key}\`${isOptional}: ${typeInfo.type}\n`;
+        }
+        return desc + '\n';
+      }
+    }
+
+    return '';
+  }
+
+  /**
+   * 从 Zod schema 字段提取类型信息
+   */
+  _extractZodFieldType(field) {
+    const typeName = field._def?.typeName || field.constructor?.name || '';
+    const description = field.description || field._def?.description || '';
+
+    switch (typeName) {
+      case 'ZodOptional': {
+        const inner = field._def.innerType;
+        return this._extractZodFieldType(inner);
+      }
+      case 'ZodArray': {
+        const innerInfo = this._extractZodFieldType(field._def.type);
+        return { type: `${innerInfo.type}[]`, isOptional: false, description };
+      }
+      case 'ZodObject': {
+        const shape = field._def.shape();
+        const props = Object.keys(shape).join(', ');
+        return { type: `object{${props}}`, isOptional: false, description };
+      }
+      case 'ZodString':
+        return { type: 'string', isOptional: false, description };
+      case 'ZodNumber':
+        return { type: 'number', isOptional: false, description };
+      case 'ZodBoolean':
+        return { type: 'boolean', isOptional: false, description };
+      case 'ZodEnum':
+        return {
+          type: field._def.values.map((v) => `"${v}"`).join(' | '),
+          isOptional: false,
+          description,
+        };
+      case 'ZodUnion': {
+        const types = field._def.options.map((opt) => this._extractZodFieldType(opt).type);
+        return { type: `union(${types.join(' | ')})`, isOptional: false, description };
+      }
+      case 'ZodLiteral':
+        return { type: JSON.stringify(field._def.value), isOptional: false, description };
+      case 'ZodRecord': {
+        const keyType = this._extractZodFieldType(field._def.keyType).type;
+        const valueType = this._extractZodFieldType(field._def.valueType).type;
+        return { type: `record<${keyType}, ${valueType}>`, isOptional: false, description };
+      }
+      case 'ZodMap': {
+        const keyType = this._extractZodFieldType(field._def.keyType).type;
+        const valueType = this._extractZodFieldType(field._def.valueType).type;
+        return { type: `map<${keyType}, ${valueType}>`, isOptional: false, description };
+      }
+      case 'ZodSet': {
+        const valueType = this._extractZodFieldType(field._def.valueType).type;
+        return { type: `set<${valueType}>`, isOptional: false, description };
+      }
+      case 'ZodAny':
+        return { type: 'any', isOptional: false, description };
+      case 'ZodUnknown':
+        return { type: 'unknown', isOptional: false, description };
+      case 'ZodNever':
+        return { type: 'never', isOptional: false, description };
+      case 'ZodNull':
+        return { type: 'null', isOptional: false, description };
+      case 'ZodUndefined':
+        return { type: 'undefined', isOptional: false, description };
+      case 'ZodDate':
+        return { type: 'date', isOptional: false, description };
+      case 'ZodBigInt':
+        return { type: 'bigint', isOptional: false, description };
+      case 'ZodFunction':
+        return { type: 'function', isOptional: false, description };
+      case 'ZodLazy':
+        return { type: 'lazy', isOptional: false, description };
+      case 'ZodNativeEnum':
+        return { type: 'nativeEnum', isOptional: false, description };
+      case 'ZodDefault': {
+        const innerInfo = this._extractZodFieldType(field._def.innerType);
+        return { type: innerInfo.type, isOptional: false, description };
+      }
+      case 'ZodEffects':
+        return { type: 'effects', isOptional: false, description };
+      case 'ZodPipeline':
+        return { type: 'pipeline', isOptional: false, description };
+      default:
+        return {
+          type: typeName.replace('Zod', '').toLowerCase() || 'any',
+          isOptional: false,
+          description,
+        };
     }
-    return desc + '\n';
   }
 
   _getParentAgent() {
@@ -765,6 +897,22 @@ class MCPExecutorPlugin extends Plugin {
           description: tool.description || '',
           inputSchema: tool.inputSchema || {},
         });
+
+        // 注册为 server_toolname 格式，供 ext_call 使用
+        const registeredName = `${name}_${toolName}`;
+        this.tools[registeredName] = {
+          name: registeredName,
+          description: `[${name}] ${tool.description || ''}`,
+          inputSchema: tool.inputSchema || {},
+          execute: async (args) => {
+            // 路由到 mcp_call
+            return await this._framework.executeTool('mcp_call', {
+              server: name,
+              tool: toolName,
+              args_json: JSON.stringify(args || {}),
+            });
+          },
+        };
       }
     }
 
@@ -775,7 +923,13 @@ class MCPExecutorPlugin extends Plugin {
       toolObjects, // 实际工具对象，供 mcp_call 直接调用
     });
 
-    log.info(` Added server '${name}' with ${toolsInfo.length} tools`);
+    log.info(
+      ` Added server '${name}' with ${toolsInfo.length} tools (ext_call names: ${Object.keys(
+        this.tools
+      )
+        .filter((k) => k.startsWith(name + '_'))
+        .join(', ')})`
+    );
   }
 
   /**
@@ -796,6 +950,14 @@ class MCPExecutorPlugin extends Plugin {
       } catch (e) {
         // ignore
       }
+
+      // 清理已注册的工具
+      for (const toolName of Object.keys(this.tools)) {
+        if (toolName.startsWith(name + '_')) {
+          delete this.tools[toolName];
+        }
+      }
+
       this._clients.delete(name);
     }
   }

package/src/utils/id.js

@@ -130,4 +130,9 @@ module.exports = {
   messageId,
   ruleId,
   resetSnowflake,
+  // 通用 ID 生成器（向后兼容）
+  generateId: () => {
+    const random = crypto.randomBytes(8).toString('base64url');
+    return `id_${Date.now()}_${random}`;
+  },
 };