mm_ai 1.0.0

package/common/tool/skill/batch_skill_checker/index.js

@@ -0,0 +1,443 @@
+/**
+ * batch_skill_checker - 批量技能提示词检测器
+ * 通过系统API获取技能列表和详情，对每个技能进行规范检测
+ * 输出汇总所有技能的检测结果，生成一份总报告（Markdown格式）
+ */
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 入口函数
+ */
+async function main(params) {
+  try {
+    const report = await batchCheckSkills();
+    return {
+      code: 0,
+      msg: '批量技能检查完成',
+      report
+    };
+  } catch (err) {
+    return { code: 500, msg: `批量技能检查失败: ${err.message}` };
+  }
+}
+
+/**
+ * 通过系统API获取所有技能列表
+ */
+async function findAllSkills() {
+  // 调用 get_skill_list() 获取所有技能名称
+  const listResult = await globalThis.callTool('get_skill_list', {});
+  if (!listResult || listResult.code !== 0 || !listResult.skills) {
+    return [];
+  }
+
+  const skills = [];
+  for (const skill of listResult.skills) {
+    try {
+      // 对每个技能调用 get_skill_detail(name) 获取 skill_dir
+      const detailResult = await globalThis.callTool('get_skill_detail', { name: skill.name });
+      if (detailResult && detailResult.code === 0 && detailResult.skill) {
+        const skillDetail = detailResult.skill;
+        const skillDir = skillDetail.skill_dir;
+        if (skillDir && fs.existsSync(skillDir)) {
+          // 从 skill_dir 路径中提取分类名（父目录名）
+          const category = path.basename(path.dirname(skillDir));
+          skills.push({
+            name: skill.name,
+            title: skillDetail.title || skill.name,
+            category: category,
+            path: skillDir
+          });
+        }
+      }
+    } catch (err) {
+      // 单个技能详情获取失败，跳过
+      console.error(`获取技能详情失败: ${skill.name}`, err.message);
+    }
+  }
+
+  return skills;
+}
+
+/**
+ * 检查 skill.md
+ */
+function checkSkillMd(skillDir) {
+  const results = [];
+  const mdPath = path.join(skillDir, 'skill.md');
+  
+  if (!fs.existsSync(mdPath)) {
+    results.push({ item: 'skill.md 文件存在性', status: '❌ 失败', detail: 'skill.md 文件不存在' });
+    return results;
+  }
+
+  const content = fs.readFileSync(mdPath, 'utf-8');
+  const wordCount = content.replace(/[#*\n\r\s`>|]/g, '').length;
+
+  // 1. 检查五要素是否齐全
+  const hasDescription = /描述|说明|功能/.test(content);
+  const hasSteps = /步骤/.test(content);
+  const hasOutput = /输出|产出|成果/.test(content);
+  const hasFailure = /失败|回退|异常/.test(content);
+  const hasForbidden = /禁止|不得|不能/.test(content);
+  
+  const elementsFound = [hasDescription, hasSteps, hasOutput, hasFailure, hasForbidden].filter(Boolean).length;
+  if (elementsFound >= 5) {
+    results.push({ item: '五要素完整性', status: '✅ 通过', detail: '包含描述、步骤、输出、失败处理、禁止行为五要素' });
+  } else {
+    const missing = [];
+    if (!hasDescription) missing.push('描述');
+    if (!hasSteps) missing.push('步骤');
+    if (!hasOutput) missing.push('输出');
+    if (!hasFailure) missing.push('失败处理');
+    if (!hasForbidden) missing.push('禁止行为');
+    results.push({ item: '五要素完整性', status: '⚠️ 警告', detail: `缺少要素: ${missing.join('、')}` });
+  }
+
+  // 2. 检查7种反模式
+  const antiPatterns = [];
+  
+  // 大纲步骤
+  const stepSections = content.match(/###\s*步骤[^：:]*[：:]/g);
+  if (stepSections) {
+    for (const step of stepSections) {
+      const idx = content.indexOf(step);
+      const afterStep = content.substring(idx, idx + 200);
+      if (!/1\.|\d+\.\s|操作|执行|使用/.test(afterStep)) {
+        antiPatterns.push('大纲步骤');
+        break;
+      }
+    }
+  } else {
+    antiPatterns.push('大纲步骤（无步骤格式）');
+  }
+
+  // 无名文件
+  if (/文件|文档/.test(content) && !/`[^`]+`/.test(content)) {
+    antiPatterns.push('无名文件');
+  }
+  
+  // 无路径文件
+  if (/\.\w+\s*文件|文件\s*\w+\.\w+/.test(content) && !/`[^`]*\.\w+`/.test(content)) {
+    antiPatterns.push('无路径文件');
+  }
+
+  // YAML Frontmatter
+  const hasYamlFrontmatter = /^---\s*/.test(content);
+  if (hasYamlFrontmatter) {
+    const endMatch = content.match(/^---\s*([\s\S]*?)---/);
+    if (endMatch) {
+      const frontmatter = endMatch[1];
+      const fields = frontmatter.match(/^(\w+)\s*[:=]/gm);
+      const fieldList = fields ? fields.map(f => f.replace(/\s*[:=].*$/, '').trim()).join('、') : '未知字段';
+      results.push({ item: 'YAML Frontmatter', status: '❌ 失败', detail: `不应包含 YAML Frontmatter（--- xxx --- 头部），元数据已在 skill.json 中管理。检测到字段: ${fieldList}` });
+    } else {
+      results.push({ item: 'YAML Frontmatter', status: '❌ 失败', detail: '不应包含 --- 分隔符，元数据已在 skill.json 中管理' });
+    }
+  } else {
+    results.push({ item: 'YAML Frontmatter', status: '✅ 通过', detail: '未包含 YAML Frontmatter（--- xxx --- 头部），符合规范' });
+  }
+  
+  // 模糊表述
+  const vaguePatterns = ['根据需要处理', '按实际情况调整', '适当处理', '视情况而定', '必要时'];
+  for (const vp of vaguePatterns) {
+    if (content.includes(vp)) {
+      antiPatterns.push(`模糊表述（"${vp}"）`);
+      break;
+    }
+  }
+  
+  // 占位示例
+  if (/例如.*[。，；]|比如.*[。，；]/.test(content) && /代码略|示例略|省略/.test(content)) {
+    antiPatterns.push('占位示例');
+  }
+  
+  // 套话回退
+  if (/如有问题|遇到困难|如果遇到|如有疑问/.test(content) && /联系|反馈|咨询/.test(content)) {
+    antiPatterns.push('套话回退');
+  }
+  
+  // 空话禁止
+  if (/禁止违规操作|禁止非法使用|禁止不当操作/.test(content)) {
+    antiPatterns.push('空话禁止');
+  }
+
+  if (antiPatterns.length === 0) {
+    results.push({ item: '反模式检测', status: '✅ 通过', detail: '未检测到7种反模式' });
+  } else {
+    results.push({ item: '反模式检测', status: '⚠️ 警告', detail: `检测到反模式: ${antiPatterns.join('、')}` });
+  }
+
+  // 3. 字数检查
+  if (wordCount >= 500 && wordCount <= 1000) {
+    results.push({ item: '字数范围', status: '✅ 通过', detail: `字数 ${wordCount}，在500-1000字范围内` });
+  } else {
+    results.push({ item: '字数范围', status: '⚠️ 警告', detail: `字数 ${wordCount}，${wordCount < 500 ? '不足500字' : '超过1000字'}` });
+  }
+
+  // 4. 检查是否包含"基本信息"章节
+  if (/##\s*基本信息/.test(content)) {
+    results.push({ item: '基本信息章节', status: '❌ 失败', detail: 'skill.md 中不应包含"基本信息"章节' });
+  } else {
+    results.push({ item: '基本信息章节', status: '✅ 通过', detail: '未包含"基本信息"章节' });
+  }
+
+  // 5. 检查 description 是否含触发关键词且50字以内
+  const descMatch = content.match(/\*\*描述\*\*[：:]\s*(.+?)(?:\n|$)/);
+  if (descMatch) {
+    const desc = descMatch[1].trim();
+    const hasKeywords = /触发关键词|触发词/.test(desc);
+    if (hasKeywords && desc.length <= 50) {
+      results.push({ item: 'description 规范', status: '✅ 通过', detail: `含触发关键词，字数 ${desc.length}（50字以内）` });
+    } else if (!hasKeywords) {
+      results.push({ item: 'description 规范', status: '⚠️ 警告', detail: `description 缺少触发关键词` });
+    } else {
+      results.push({ item: 'description 规范', status: '⚠️ 警告', detail: `description 字数 ${desc.length}，超过50字` });
+    }
+  } else {
+    results.push({ item: 'description 规范', status: '⚠️ 警告', detail: '未在 skill.md 中找到 description 字段' });
+  }
+
+  return results;
+}
+
+// 检查 skill.json
+function checkSkillJson(skillDir) {
+  const results = [];
+  const jsonPath = path.join(skillDir, 'skill.json');
+  
+  if (!fs.existsSync(jsonPath)) {
+    results.push({ item: 'skill.json 文件存在性', status: '❌ 失败', detail: 'skill.json 文件不存在' });
+    return results;
+  }
+
+  const content = fs.readFileSync(jsonPath, 'utf-8');
+
+  // 1. JSON.parse 校验
+  let jsonData;
+  try {
+    jsonData = JSON.parse(content);
+    results.push({ item: 'JSON 格式校验', status: '✅ 通过', detail: 'JSON.parse 校验通过' });
+  } catch (e) {
+    results.push({ item: 'JSON 格式校验', status: '❌ 失败', detail: `JSON.parse 校验失败: ${e.message}` });
+    return results;
+  }
+
+  // 2. tools 数组是否为空
+  if (jsonData.tools && Array.isArray(jsonData.tools) && jsonData.tools.length > 0) {
+    results.push({ item: 'tools 数组', status: '✅ 通过', detail: `tools 数组不为空，共 ${jsonData.tools.length} 个工具` });
+  } else if (jsonData.tools && Array.isArray(jsonData.tools) && jsonData.tools.length === 0) {
+    results.push({ item: 'tools 数组', status: '❌ 失败', detail: 'tools 数组为空，应填写依赖的工具名' });
+  } else {
+    results.push({ item: 'tools 数组', status: '⚠️ 警告', detail: '未找到 tools 字段或非数组格式' });
+  }
+
+  // 3. 必填字段检查
+  const requiredFields = ['name', 'title', 'description', 'version', 'prompt_file', 'tools'];
+  const missingFields = requiredFields.filter(f => !(f in jsonData));
+  if (missingFields.length === 0) {
+    results.push({ item: '必填字段', status: '✅ 通过', detail: '包含 name/title/description/version/prompt_file/tools 所有字段' });
+  } else {
+    results.push({ item: '必填字段', status: '❌ 失败', detail: `缺少字段: ${missingFields.join('、')}` });
+  }
+
+  // 4. 检查是否包含注释
+  const hasJSComment = /\/\//.test(content) || /\/\*/.test(content) || /\*\//.test(content);
+  if (hasJSComment) {
+    results.push({ item: '注释检测', status: '❌ 失败', detail: 'skill.json 中不应包含注释（// 或 /* */）' });
+  } else {
+    results.push({ item: '注释检测', status: '✅ 通过', detail: '未检测到注释' });
+  }
+
+  // 5. 检查 description 是否含触发关键词
+  if (jsonData.description) {
+    const hasKeywords = /触发关键词|触发词/.test(jsonData.description);
+    const descLen = jsonData.description.length;
+    if (hasKeywords && descLen <= 50) {
+      results.push({ item: 'description 字段（json）', status: '✅ 通过', detail: `含触发关键词，字数 ${descLen}（50字以内）` });
+    } else if (!hasKeywords) {
+      results.push({ item: 'description 字段（json）', status: '⚠️ 警告', detail: `description 缺少触发关键词: "${jsonData.description}"` });
+    } else {
+      results.push({ item: 'description 字段（json）', status: '⚠️ 警告', detail: `description 字数 ${descLen}，超过50字` });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * 批量检查所有技能
+ */
+async function batchCheckSkills() {
+  const skills = await findAllSkills();
+  
+  if (skills.length === 0) {
+    return '# 批量技能提示词检测报告\n\n**检测结果**: 未找到任何技能\n\n请确认系统中存在技能数据。';
+  }
+
+  // 逐个串行检测，避免资源竞争
+  const allReports = [];
+  for (const skill of skills) {
+    try {
+      const mdResults = checkSkillMd(skill.path);
+      const jsonResults = checkSkillJson(skill.path);
+      
+      const allResults = [...mdResults, ...jsonResults];
+      const passed = allResults.filter(r => r.status === '✅ 通过').length;
+      const warned = allResults.filter(r => r.status.includes('⚠️')).length;
+      const failed = allResults.filter(r => r.status.includes('❌')).length;
+      
+      allReports.push({
+        name: skill.name,
+        category: skill.category,
+        mdResults,
+        jsonResults,
+        summary: { total: allResults.length, passed, warned, failed }
+      });
+    } catch (err) {
+      allReports.push({
+        name: skill.name,
+        category: skill.category || '未知',
+        mdResults: [{ item: '检查异常', status: '❌ 失败', detail: `检查过程发生错误: ${err.message}` }],
+        jsonResults: [],
+        summary: { total: 1, passed: 0, warned: 0, failed: 1 }
+      });
+    }
+  }
+
+  return generateBatchReport(allReports);
+}
+
+/**
+ * 生成批量 Markdown 报告
+ */
+function generateBatchReport(allReports) {
+  // 计算总览统计
+  let totalSkills = allReports.length;
+  let totalPassed = 0, totalWarned = 0, totalFailed = 0;
+  let totalItems = 0;
+  let allPassedSkills = 0, hasWarningSkills = 0, hasFailedSkills = 0;
+
+  for (const r of allReports) {
+    totalItems += r.summary.total;
+    totalPassed += r.summary.passed;
+    totalWarned += r.summary.warned;
+    totalFailed += r.summary.failed;
+    
+    if (r.summary.failed > 0) hasFailedSkills++;
+    else if (r.summary.warned > 0) hasWarningSkills++;
+    else allPassedSkills++;
+  }
+
+  let report = `# 📊 批量技能提示词规范检测报告\n\n`;
+  report += `**检测时间**: ${new Date().toLocaleString()}\n\n`;
+  report += `**检测范围**: 系统中所有技能\n\n`;
+  report += `---\n\n`;
+
+  // ===== 总览统计 =====
+  report += `## 📈 总览统计\n\n`;
+  report += `| 项目 | 数量 |\n`;
+  report += `|:----|:----|\n`;
+  report += `| 技能总数 | ${totalSkills} |\n`;
+  report += `| 总检测项 | ${totalItems} |\n`;
+  report += `| ✅ 通过 | ${totalPassed} |\n`;
+  report += `| ⚠️ 警告 | ${totalWarned} |\n`;
+  report += `| ❌ 失败 | ${totalFailed} |\n\n`;
+
+  report += `**技能健康度**:\n\n`;
+  report += `| 状态 | 数量 |\n`;
+  report += `|:----|:----|\n`;
+  report += `| ✅ 全部通过 | ${allPassedSkills} |\n`;
+  report += `| ⚠️ 存在警告 | ${hasWarningSkills} |\n`;
+  report += `| ❌ 存在失败 | ${hasFailedSkills} |\n\n`;
+
+  if (hasFailedSkills > 0) {
+    report += `> ⚠️ 共有 ${hasFailedSkills} 个技能存在失败项，需要修复后才能通过规范检查。\n\n`;
+  }
+
+  report += `---\n\n`;
+
+  // ===== 按分类分组展示详细结果 =====
+  const grouped = {};
+  for (const r of allReports) {
+    if (!grouped[r.category]) grouped[r.category] = [];
+    grouped[r.category].push(r);
+  }
+
+  report += `## 📋 详细检测结果\n\n`;
+
+  for (const [category, categoryReports] of Object.entries(grouped)) {
+    report += `### 📁 分类: \`${category}\`\n\n`;
+    
+    for (const sr of categoryReports) {
+      const statusIcon = sr.summary.failed > 0 ? '❌' : (sr.summary.warned > 0 ? '⚠️' : '✅');
+      report += `#### ${statusIcon} 技能: \`${sr.name}\`\n\n`;
+      report += `**状态**: `;
+      if (sr.summary.failed > 0) report += '❌ 存在失败项';
+      else if (sr.summary.warned > 0) report += '⚠️ 存在警告';
+      else report += '✅ 全部通过';
+      report += `（通过 ${sr.summary.passed}/${sr.summary.total}，警告 ${sr.summary.warned}，失败 ${sr.summary.failed}）\n\n`;
+
+      // skill.md 检查
+      report += `**📄 skill.md 检查**:\n\n`;
+      report += `| 检查项 | 结果 | 说明 |\n`;
+      report += `|:-----|:----|:----|\n`;
+      if (sr.mdResults && sr.mdResults.length > 0) {
+        for (const r of sr.mdResults) {
+          report += `| ${r.item} | ${r.status} | ${r.detail} |\n`;
+        }
+      }
+      report += `\n`;
+
+      // skill.json 检查
+      report += `**📋 skill.json 检查**:\n\n`;
+      report += `| 检查项 | 结果 | 说明 |\n`;
+      report += `|:-----|:----|:----|\n`;
+      if (sr.jsonResults && sr.jsonResults.length > 0) {
+        for (const r of sr.jsonResults) {
+          report += `| ${r.item} | ${r.status} | ${r.detail} |\n`;
+        }
+      }
+      report += `\n`;
+    }
+  }
+
+  // ===== 汇总建议 =====
+  report += `---\n\n`;
+  report += `## 💡 汇总建议\n\n`;
+
+  const suggestions = [];
+  for (const sr of allReports) {
+    const allItems = [...(sr.mdResults || []), ...(sr.jsonResults || [])];
+    for (const item of allItems) {
+      if (item.status.includes('❌')) {
+        suggestions.push(`- **\`${sr.name}\`**（${sr.category}）- ❌ ${item.item}：${item.detail}`);
+      }
+    }
+  }
+  for (const sr of allReports) {
+    const allItems = [...(sr.mdResults || []), ...(sr.jsonResults || [])];
+    for (const item of allItems) {
+      if (item.status.includes('⚠️') && !item.status.includes('❌')) {
+        suggestions.push(`- **\`${sr.name}\`**（${sr.category}）- ⚠️ ${item.item}：${item.detail}`);
+      }
+    }
+  }
+
+  if (suggestions.length > 0) {
+    report += `以下是需要关注的问题：\n\n`;
+    for (const s of suggestions) {
+      report += `${s}\n`;
+    }
+  } else {
+    report += `所有技能均通过规范检查，无需处理。\n`;
+  }
+
+  report += `\n---\n\n`;
+  report += `*报告由 batch_skill_checker 自动生成*\n`;
+
+  return report;
+}
+
+module.exports = { main };

package/common/tool/skill/batch_skill_checker/tool.json

@@ -0,0 +1,32 @@
+{
+  // 工具名称
+  "name": "batch_skill_checker",
+  // 工具标题(显示的中文名)
+  "title": "批量技能提示词检测器",
+  // 工具描述
+  "description": "通过系统API获取所有技能列表和详情，对每个技能进行规范检测，生成汇总报告。触发关键词：批量技能检查、全部技能检测",
+  // 工具分组
+  "category": "技能管理",
+  // 工具分组
+  "group": "skill",
+  // 工具类型, 默认为"function"
+  "type": "function",
+  // 工具主文件路径
+  "main": "./index.js",
+  // 工具是否严格模式参数校验
+  "strict": true,
+  // 工具参数是否允许额外字段
+  "add_params": false,
+  // 工具参数
+  "params": [],
+  // 工具返回值
+  "returns": [],
+  // 工具排序
+  "sort": 10,
+  // 工具状态, 0表示未启用, 1表示启用
+  "state": 1,
+  // 工具显示, 0表示不显示, 1表示显示
+  "show": 0,
+  // 是否结束
+  "end": false
+}

package/common/tool/skill/create_skill/index.js

@@ -0,0 +1,55 @@
+module.exports = {
+  /**
+   * 获取技能管理器
+   * @returns {object} - 技能管理器
+   */
+  getManager: function () {
+    // 获取技能管理器
+    let manager = this.getServer().manager;
+    return manager['skill'];
+  },
+  /**
+   * 创建技能
+   * @param {object} config - 技能配置
+   * @returns {Promise} - 技能对象
+   */
+  createSkill: function (config) {
+    let prompt = config.prompt;
+    delete config.prompt;
+    // 创建技能
+    let manager = this.getManager();
+    if (!manager) {
+      throw new Error('技能管理器不存在');
+    }
+    let skill = manager.create(config);
+    if (prompt) {
+      skill.setPrompt(prompt);
+    }
+    return skill;
+  },
+  /**
+  * 主要逻辑
+  * @param {object} params 参数
+  * @param {string} params.name 技能名称(由英文+数字+下划线组成)
+  * @param {string} params.title 技能标题(显示用的中文名称)
+  * @param {string} params.description 技能描述
+  * @param {string} params.prompt 技能提示词
+  * @param {array} params.tools 技能依赖的工具列表
+  */
+  async main(params) {
+    try {
+      // 主要代码写在这
+      let skill = await this.createSkill(params);
+      return {
+        code: 0,
+        msg: '技能创建成功',
+        skill: skill.getDetail()
+      };
+    } catch (error) {
+      return {
+        code: 10000,
+        msg: '技能创建失败，原因：' + error.message
+      };
+    }
+  }
+};

package/common/tool/skill/create_skill/tool.json

@@ -0,0 +1,72 @@
+{
+  // 工具名称
+  "name": "create_skill",
+  // 工具标题(显示的中文名)
+  "title": "创建技能",
+  // 工具描述
+  "description": "实现创建新的技能。当技能不存在时可创建一个新的技能。仅限技能导师可用。",
+  // 工具分类
+  "category": "技能管理",
+  // 工具分组
+  "group": "skill",
+  // 工具类型, 默认为"function"
+  "type": "function",
+  // 工具主文件路径
+  "main": "./index.js",
+  // 工具参数，必要配置，让AI知道需要哪些参数
+  "params": [
+    {
+      "name": "name",
+      "description": "技能名称",
+      "type": "string",
+      "required": true
+    },
+    {
+      "name": "title",
+      "type": "string",
+      "description": "技能标题(中文名)",
+      "required": true
+    },
+    {
+      "name": "description",
+      "type": "string",
+      "description": "技能描述。50个字符以内，包含用于什么场景和触发关键词。例如：用于编写js代码时。触发关键词：编写js、编写nodejs",
+      "required": true
+    },
+    {
+      "name": "prompt",
+      "type": "string",
+      "description": "提示词markdown，将保存为技能提示词文件。开头包含name、description、allowed-tools。正文包含触发条件、输入假设、执行步骤、中间检查点、输出格式、失败回退、禁止行为。",
+      "required": true
+    },
+    {
+      "name": "tools",
+      "description": "技能依赖的工具列表。调用该技能的时候会预加载的工具。",
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  ],
+  // 工具返回值，非必要配置
+  "returns": [
+    {
+      "name": "skill",
+      "type": "object",
+      "description": "技能对象",
+      "required": true
+    },
+    {
+      "name": "code",
+      "type": "number",
+      "description": "操作状态代码，0表示成功，其他值表示失败",
+      "default": 0
+    },
+    {
+      "name": "msg",
+      "type": "string",
+      "description": "操作反馈消息，成功时返回成功提示，失败时返回错误信息",
+      "default": ""
+    }
+  ]
+}

package/common/tool/skill/endow_skills/index.js

@@ -0,0 +1,88 @@
+module.exports = {
+  /**
+   * 获取智能体
+   * @returns {object} - 智能体管理器
+   */
+  getAgent(agent_name) {
+    // 获取智能体的代码
+    return this.getServer().agent[agent_name];
+  },
+  getSkill(skill_name) {
+    return this.getServer().skill[skill_name];
+  },
+  /**
+   * 获取智能体
+   * @param {object} agent - 智能体对象
+   * @param {string} skill_name - 技能名称
+   * @returns {Promise} - 技能对象
+   */
+  async endowSkill(agent, skill_name) {
+    if (!skill_name) {
+      throw new TypeError('技能名称(skill_name)不能为空。');
+    }
+    let skill = this.getSkill(skill_name);
+    if (!skill) {
+      throw new Error(`技能(${skill_name}) 不存在。`);
+    }
+    let skills = agent.config.skills;
+    if (!skills) {
+      skills = [];
+    }
+    if (!skills.includes(skill_name)) {
+      skills.push(skill_name);
+      agent.config.skills = skills;
+    }
+    return {
+      name: skill.config.name,
+      title: skill.config.title,
+      description: skill.config.description
+    };
+  },
+  /**
+   * 赋予智能体技能
+   * @param {Object} params - 智能体配置
+   * @param {string} params.agent_name - 智能体名称
+   * @param {array} params.skills - 技能名称列表
+   * @returns {array} - 技能对象列表
+   */
+  async endowSkills(params) {
+    let { agent_name, skills } = params;
+    if (!agent_name) {
+      throw new TypeError('智能体名称(agent_name)不能为空。');
+    }
+    if (!skills || skills.length === 0) {
+      throw new TypeError('技能名称列表(skills)不能为空。');
+    }
+    let agent = this.getAgent(agent_name);
+    if (!agent) {
+      throw new Error(`智能体(${agent_name}) 不存在。`);
+    }
+    let list = [];
+    for (let skill_name of skills) {
+      let skill = await this.endowSkill(agent, skill_name);
+      list.push(skill);
+    }
+    return list;
+  },
+  /**
+   * 主函数
+   * @param {Object} params - 智能体配置
+   * @returns {Promise} - 智能体对象
+   */
+  async main(params) {
+    try {
+      let skills = await this.endowSkills(params);
+      return {
+        code: 0,
+        msg: '赋予技能成功',
+        agent_name: params.agent_name,
+        skills: skills
+      };
+    } catch (error) {
+      return {
+        code: 10000,
+        msg: '赋予技能失败，原因：' + error.message
+      };
+    }
+  }
+};