mm_ai 1.0.0

package/core/agent/index.js

@@ -0,0 +1,977 @@
+const { Manager, Drive } = require('mm_machine');
+const { User } = require('../user/index.js');
+const { Contact } = require('../contact/index.js');
+const { Record } = require('../record/index.js');
+const { Tpl } = require('mm_tpl');
+
+/**
+ * 智能体类
+ */
+class Agent extends Drive {
+  /**
+   * 默认加载的工具
+   * 智能体默认加载的工具，这些工具是所有智能体的基本功能，是智能体运行的基础。
+   * 1. 先用get_agent_status获取工作状态，了解当前是否存在未完成的工作状态。
+   * 2. 如果不存在未完成的工作，用set_todos更新代办事项列表。
+   * 3. 如果存在未完成的工作，继续完成代办事项。
+   * 4. 根据代办事项分析用户需求，存在模糊需求时用ask_user向用户确认。
+   * 5. 根据用户需求分析需要使用的技能。
+   * 6. 用read_skill读取技能，根据技能使用说明执行任务，调用对应的工具。
+   * 7. 完成某个代办事项后，用set_todo_status更新代办事项状态。
+   * 8. 用notify_user向用户汇报完成情况和告知接下来需要完成的代办事项。
+   * 9. 重复以上步骤，直到所有代办事项完成。
+   * 10. 所有代办事项完成后，用notify_user向用户汇报完成情况。
+   * 11. 判断当前是否完成的是某个任务，如果是，用set_task_status更新任务状态。
+   * 12. 用notify_user向用户汇报任务完成情况。
+   * 13. 重复以上步骤，直到所有任务完成。
+   */
+  static default_tools = ['get_agent_status', 'set_todos', 'ask_user', 'get_agent_skills', 'read_skill', 'get_agent_tools', 'get_agent_tasks', 'get_task_detail', 'set_todo_status', 'set_task_status', 'notify_user', 'call_agent', 'read_prompt', 'set_agent_stage', 'read_work', 'read_knowledge'];
+  /**
+   * 配置项
+   */
+  static config = {
+    // 智能体标识名称
+    name: '',
+    // 智能体标题(显示用的中文名称)
+    title: '默认智能体',
+    // 智能体描述
+    description: '默认智能体',
+    // 分组 管理|创作|服务|研发|其他
+    group: '管理',
+    // 使用的大模型
+    llm: 'deepseek-chat',
+    // 所属团队
+    team: 'default',
+    // 技能配置，不直接加载工具，而是通过技能类加载工具
+    skills: [],
+    // 工具配置，不直接加载工具，而是通过工具类加载工具
+    tools: [],
+    // 附加提示词配置，不直接加载提示词，而是通过提示词类加载提示词
+    prompts: [],
+    // 是否流式输出
+    stream: false,
+    // 是否固定提示词
+    fixed_prompt: true,
+    // 是否动态变更系统提示词
+    dynamic_prompt: false,
+    // 智能体提示词配置
+    prompt_files: {
+      // 角色提示词（智能体的角色身份和职责）
+      role: './prompt/role.md',
+      // 灵魂提示词(智能体的个人特征和行为规范)
+      soul: './prompt/soul.md',
+      // 会做的事情
+      can: './prompt/can.md',
+      // 职责权限提示词(智能体的职责权限和行为规范)
+      should: './prompt/should.md',
+      // 能力提示词(智能体所需掌握的技能和工具)
+      ability: './prompt/ability.md',
+      // 干系人提示词(智能体的干系人和互助关系)
+      stakeholder: './prompt/stakeholder.md',
+      // 工作流程提示词(智能体的工作流程和操作规范)
+      workflow: './prompt/workflow.md'
+    },
+    // 主程序文件路径
+    main: ''
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置项
+   * @param {object} parent 父对象
+   */
+  constructor(config, parent) {
+    super({ ...Agent.config, ...config }, parent);
+    // 操作记录
+    this.record = {};
+    // 用户
+    this.user = {};
+    // 联系人
+    this.contact = {};
+    // 管理器
+    this.manager = {};
+  }
+}
+
+/**
+ * 预置智能体
+ */
+Agent.prototype._preset = function () {
+  // 取消控制器集合，key为user_name，用于中断智能体的回复
+  this.aborts = {};
+};
+
+/**
+ * 取消指定用户的回复
+ * @param {string} user_name - 用户名称
+ * @returns {boolean} 是否成功取消
+ */
+Agent.prototype.cancelReply = function (user_name) {
+  if (this.aborts && this.aborts[user_name]) {
+    this.aborts[user_name].abort();
+    return true;
+  }
+  // 如果没有控制器，创建一个已取消的用于状态检查
+  this.aborts[user_name] = new AbortController();
+  this.aborts[user_name].abort();
+  return true;
+};
+
+/**
+ * 检查指定用户的回复是否已取消
+ * @param {string} user_name - 用户名称
+ * @returns {boolean} 是否已取消
+ */
+Agent.prototype._isAborted = function (user_name) {
+  return !!(this.aborts && this.aborts[user_name] && this.aborts[user_name].signal.aborted);
+};
+
+/**
+ * 初始化核心智能体
+ * @param {object} llm - 大模型名称
+ * @param {object} skill - 技能配置
+ * @param {object} tool - 工具配置
+ * @param {object} prompt - 提示词配置
+ * @param {object} eventer - 事件触发器
+ * @param {object} logger - 日志记录器
+ */
+Agent.prototype._initCore = function (llm, skill, tool, prompt, eventer, logger) {
+  if (logger) { this.getLogger = function () { return logger; }; }
+  if (eventer) { this.getEventer = function () { return eventer; }; }
+  if (llm) { this.getLLM = function () { return llm[this.config.llm]; }; }
+  if (skill) { this.getSkill = function (name) { return !name ? skill : skill[name]; }; }
+  if (tool) { this.getTool = function (name) { return !name ? tool : tool[name]; }; }
+  if (prompt) { this.getOtherPrompt = function (name) { return !name ? prompt : prompt[name]; }; }
+  this._checkDep();
+  this._initManager();
+  this._loadSources();
+  this._initSources();
+};
+
+/**
+ * 检测依赖
+ */
+Agent.prototype._checkDep = function () {
+  let { llm, skills, tools, prompts } = this.config;
+  if (!this.getLLM()) { new TypeError(`智能体 ${this.name} 缺少大模型 ${llm}`); }
+  let skill = this.getSkill();
+  for (let name of skills) { if (!skill[name]) { new TypeError(`智能体 ${this.name} 缺少技能 ${name}`); } }
+  let tool = this.getTool();
+  for (let name of tools) { if (!tool[name]) { new TypeError(`智能体 ${this.name} 缺少工具 ${name}`); } }
+  let prompt = this.getOtherPrompt();
+  for (let name of prompts) { if (!prompt[name]) { new TypeError(`智能体 ${this.name} 缺少提示词 ${name}`); } }
+};
+
+/**
+ * 创建管理器实例
+ * @param {string} name 管理器名称
+ * @param {string} title 管理器标题
+ * @param {Function} cls 管理器类
+ * @returns {object} 管理器实例
+ */
+Agent.prototype._createManager = function (name, title, cls) {
+  let dir = this.getDir();
+  var manager = new Manager({ name, title, filename: name + '.json', tpl_dir: `../${name}/`.fullname(__dirname), base_dir: '', dir: `./${name}/`.fullname(dir) }, this, this[name], cls);
+  this.manager[name] = manager;
+  return manager;
+};
+
+/**
+ * 初始化管理
+ */
+Agent.prototype._initManager = async function () {
+  var mgrConfigs = [{ name: 'user', title: '用户管理器', Module: User }, { name: 'contact', title: '联系人管理器', Module: Contact }, { name: 'record', title: '操作记录管理器', Module: Record }];
+  var managers = mgrConfigs.map(c => this._createManager(c.name, c.title, c.Module));
+  await Promise.all(managers.map(m => m.do('init')));
+};
+
+/**
+ * 初始化资源
+ */
+Agent.prototype._initSources = async function () {
+  await Promise.all([this.manager.user.runAll('init', this.getEventer(), this.getLogger()), this.manager.contact.runAll('init', this.getEventer(), this.getLogger()), this.manager.record.runAll('init', this.getEventer(), this.getLogger())]);
+};
+
+/**
+ * 加载资源
+ */
+Agent.prototype._loadSources = async function () {
+  await Promise.all([this.manager.user.runAll('load'), this.manager.contact.runAll('load'), this.manager.record.runAll('load')]);
+};
+
+/**
+ * 启动资源
+ */
+Agent.prototype._startSources = async function () {
+  await Promise.all([this.manager.user.runAll('start'), this.manager.contact.runAll('start'), this.manager.record.runAll('start')]);
+};
+
+/**
+ * 调用工具函数
+ * @param {string} name - 函数名称
+ * @param {Array} params - 函数参数
+ * @returns {object} 函数调用结果
+ */
+Agent.prototype.functionCall = async function (name, params) {
+  let tool = this.getTool(name);
+  if (!tool) { throw new Error(`工具 ${name} 不存在`); }
+  if (!tool.isLoaded()) { await tool.do('load'); await tool.do('init', this.getParent()); }
+  return await tool.run(params);
+};
+
+/**
+ * 对话智能体
+ * @param {string} user_name - 面向用户名称
+ * @param {string} session_id - 会话ID
+ * @param {Array} content - 对话内容
+ * @param {string} sender - 发送人名称
+ * @returns {object} 对话结果
+ */
+Agent.prototype.send = async function (user_name, session_id, content, sender = '') {
+  let message = await this._send(user_name, sender, session_id, { role: 'user', content });
+  return { session_id, user_name, sender: this.config.name, receiver: sender, type: 'text', ...message };
+};
+
+/**
+ * 处理消息
+ * @param {string} user_name - 面向用户名称
+ * @param {string} session_id - 会话ID
+ * @param {object} message - 消息
+ */
+Agent.prototype.addMessage = function (user_name, session_id, message) {
+  this.getUser(user_name).addMessage(session_id, message);
+};
+
+/**
+ * 获取消息记录
+ * @param {string} user_name - 面向用户名称
+ * @param {string} contact_name - 联系人名称
+ * @param {string} session_id - 会话ID
+ * @returns {Array} 消息记录
+ */
+Agent.prototype._getMessages = async function (user_name, contact_name, session_id) {
+  let user = this.getUser(user_name);
+  if (!user) { throw new Error(`用户 ${user_name} 不存在`); }
+  let messages = user.getMessages(session_id) || [];
+  messages = await this._addSystemPrompt(user_name, contact_name, session_id, messages);
+  return messages;
+};
+
+/**
+ * 获取工具清单
+ * @returns {Array} 工具清单
+ */
+Agent.prototype.getToolList = function () {
+  let tool = this.getTool();
+  let list = [];
+  let has_tools = {};
+  let not_tools = {};
+  let tools = Agent.default_tools || [];
+  for (let name of tools) {
+    if (!has_tools[name]) {
+      if (tool[name]) { list.push(tool[name].toFunctionCall()); has_tools[name] = true; }
+      else { not_tools[name] = true; }
+    }
+  }
+  tools = this.config.tools || [];
+  for (let name of tools) {
+    if (!has_tools[name]) {
+      if (tool[name]) { list.push(tool[name].toFunctionCall()); has_tools[name] = true; }
+      else { not_tools[name] = true; }
+    }
+  }
+  if (Object.keys(not_tools).length > 0) { this.log('warn', `未找到工具 ${Object.keys(not_tools).join(', ')}`); }
+  return list;
+};
+
+/**
+ * 处理工具调用
+ * @param {object} function_call - 工具调用对象
+ * @returns {object} 工具调用结果
+ */
+Agent.prototype._handleToolCall = async function (function_call) {
+  let ret, json;
+  try {
+    json = JSON.parse(function_call.arguments);
+  } catch (error) {
+    ret = { code: 10000, msg: `工具调用失败！原因：参数序列化失败，${error.message}` };
+  }
+  if (json) {
+    try {
+      ret = await this.functionCall(function_call.name, json);
+    } catch (error) {
+      ret = {
+        code: 10000, msg: `工具调用失败！原因：${error.message}`
+      };
+    }
+  }
+  if (typeof ret !== 'object') {
+    ret = {
+      code: 0,
+      msg: '调用成功',
+      data: ret
+    }
+  }
+  return JSON.stringify(ret);
+};
+
+/**
+ * 处理多个工具调用
+ * @param {string} user_name - 面向用户名称
+ * @param {string} contact_name - 联系人名称
+ * @param {string} session_id - 会话ID
+ * @param {object} message - 包含工具调用的消息
+ * @returns {object} 最终响应消息
+ */
+Agent.prototype._handleToolCalls = async function (user_name, contact_name, session_id, message) {
+  this.addMessage(user_name, session_id, message);
+  let results = [];
+  for (let tool_call of message.tool_calls) {
+    // 每次工具调用前检查是否被取消
+    if (this._isAborted(user_name)) {
+      return { type: 'cancelled', content: '回复已取消' };
+    }
+    // 确保每个 tool_call 都有对应的 tool 消息，防止 tool_call_id 配对不完整导致 API 400 错误
+    let toolCallId = tool_call.id || '';
+    let toolName = (tool_call.function && tool_call.function.name) || 'unknown';
+    if (tool_call.function) {
+      let ret = await this._handleToolCall(tool_call.function);
+      results.push({ role: 'tool', tool_call_id: toolCallId, name: toolName, content: ret });
+    } else {
+      // tool_call 缺少 function 字段（如流式组装异常等），生成一个默认的 tool 结果
+      let ret = JSON.stringify({ code: 10000, msg: `工具调用失败！原因：tool_call 缺少 function 字段` });
+      results.push({ role: 'tool', tool_call_id: toolCallId, name: toolName, content: ret });
+    }
+  }
+  if (results.length === 0) {
+    return { type: 'cancelled', content: '回复已取消' };
+  }
+  // 如果有多个 tool 结果，将前 N-1 个先存入消息历史，最后一个通过 _send 发送
+  if (results.length > 1) {
+    for (let i = 0; i < results.length - 1; i++) { this.addMessage(user_name, session_id, results[i]); }
+  }
+  return await this._send(user_name, contact_name, session_id, results[results.length - 1]);
+};
+
+/**
+ * 处理单个函数调用（兼容旧格式）
+ * @param {string} user_name - 面向用户名称
+ * @param {string} contact_name - 联系人名称
+ * @param {string} session_id - 会话ID
+ * @param {object} message - 包含函数调用的消息
+ * @returns {object} 最终响应消息
+ */
+Agent.prototype._handleFunctionCall = async function (user_name, contact_name, session_id, message) {
+  this.addMessage(user_name, session_id, message);
+  let func_call = message.function_call;
+  let ret, json;
+  try { json = JSON.parse(func_call.arguments); } catch (error) { ret = { code: 10000, msg: `工具调用失败！原因：参数序列化失败，${error.message}` }; }
+  if (json) {
+    try { ret = await this.functionCall(func_call.name, json); } catch (error) { ret = { code: 10000, msg: `工具调用失败！原因：${error.message}` }; }
+  }
+  return await this._send(user_name, contact_name, session_id, { role: 'function', name: func_call.name, content: typeof ret === 'object' ? JSON.stringify(ret) : ret });
+};
+
+/**
+ * 校验并修复消息历史中的 tool_calls 与 tool 消息配对
+ * 防止因 tool_call_id 配对不完整导致 API 返回 400 错误
+ * @param {Array} messages - 消息历史
+ * @returns {Array} 修复后的消息历史
+ */
+Agent.prototype._repairToolCallPairs = function (messages) {
+  let repaired = [];
+  let pendingToolCallIds = []; // 待配对的 tool_call_id 列表
+
+  for (let msg of messages) {
+    repaired.push(msg);
+
+    // 如果是 assistant 消息且包含 tool_calls，记录所有待配对的 tool_call_id
+    if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
+      for (let tc of msg.tool_calls) {
+        if (tc.id) {
+          pendingToolCallIds.push(tc.id);
+        }
+      }
+    }
+    // 如果是 tool 消息，从待配对列表中移除已配对的 tool_call_id
+    else if (msg.role === 'tool' && msg.tool_call_id) {
+      let idx = pendingToolCallIds.indexOf(msg.tool_call_id);
+      if (idx !== -1) {
+        pendingToolCallIds.splice(idx, 1);
+      }
+    }
+  }
+
+  // 如果有未配对的 tool_call_id，补充默认的 tool 消息
+  for (let id of pendingToolCallIds) {
+    repaired.push({
+      role: 'tool',
+      tool_call_id: id,
+      name: 'unknown',
+      content: JSON.stringify({ code: 10000, msg: `工具调用失败！原因：tool_call(${id}) 缺少对应的 tool 响应消息，已自动补充` })
+    });
+  }
+
+  return repaired;
+};
+
+/**
+ * 发送消息
+ * @param {string} user_name - 面向用户名称
+ * @param {string} contact_name - 联系人名称
+ * @param {string} session_id - 会话ID
+ * @param {object} message - 消息
+ * @returns {object} 响应消息
+ */
+Agent.prototype._send = async function (user_name, contact_name, session_id, message) {
+  // 检查是否已取消
+  if (this._isAborted(user_name)) {
+    return { type: 'cancelled', content: '回复已取消' };
+  }
+  this.addMessage(user_name, session_id, message);
+  let messages = await this._getMessages(user_name, contact_name, session_id);
+  // 校验并修复消息历史中的 tool_calls 与 tool 消息配对，防止 API 400 错误
+  messages = this._repairToolCallPairs(messages);
+  // 创建或获取当前用户的取消控制器
+  if (!this.aborts[user_name] || this.aborts[user_name].signal.aborted) {
+    this.aborts[user_name] = new AbortController();
+  }
+  let signal = this.aborts[user_name].signal;
+  let res = await this._post(messages, this.getToolList(), this.config.stream ? async (msg) => {
+    if (msg.type === 'stream_chunk' || msg.type === 'stream_end') {
+      return await this.pushChat(user_name, contact_name, session_id, msg);
+    }
+    else { return await this._handleMessage(user_name, contact_name, session_id, msg); }
+  } : null, signal);
+  // LLM调用完成后检查是否被取消
+  // 使用本地 signal 引用而非 _isAborted()，防止后续 chat() 调用
+  // 覆盖了 this.aborts[user_name] 导致误判
+  if (signal.aborted) {
+    return { type: 'cancelled', content: '回复已取消' };
+  }
+  return await this._handleMessage(user_name, contact_name, session_id, res);
+};
+
+/**
+ * 处理消息
+ * @param {string} user_name - 面向用户名称
+ * @param {string} contact_name - 联系人名称
+ * @param {string} session_id - 会话ID
+ * @param {object} message - 消息
+ * @returns {object} 响应消息
+ */
+Agent.prototype._handleMessage = async function (user_name, contact_name, session_id, message) {
+  if (message.type === 'error' || message.type === 'cancelled') { return message; }
+  if (message.tool_calls && message.tool_calls.length > 0) { return await this._handleToolCalls(user_name, contact_name, session_id, message); }
+  if (message.function_call) { return await this._handleFunctionCall(user_name, contact_name, session_id, message); }
+  this.addMessage(user_name, session_id, message);
+  return message;
+};
+
+/**
+ * 发送消息到模型
+ * @param {Array} messages 消息列表
+ * @param {Array} tools 工具列表
+ * @param {function} callback - 回调函数，用于处理流式数据
+ * @param {object} signal - AbortSignal 取消信号
+ * @returns {object} 响应消息
+ */
+Agent.prototype._post = async function (messages, tools, callback, signal) {
+  let llm = this.getLLM();
+  if (!llm) { return $.ret.error(10000, `缺少大模型 ${this.config.llm}`); }
+  return await llm.run(messages, tools, callback, signal);
+};
+
+/**
+ * 获取当前会话ID
+ * @param {string} user_name - 面向用户名称
+ * @returns {string} 当前会话ID
+ */
+Agent.prototype.getSessionId = function (user_name) { return this.getUser(user_name).getSessionId(); };
+
+/**
+ * 设置当前会话ID
+ * @param {string} user_name - 面向用户名称
+ * @param {string} session_id - 会话ID
+ */
+Agent.prototype.setSessionId = function (user_name, session_id) { this.getUser(user_name).setSessionId(session_id); };
+
+/**
+ * 新建一个会话
+ * @param {string} user_name - 面向用户名称
+ * @param {string} title - 会话标题
+ * @returns {object} 会话信息对象
+ */
+Agent.prototype.newSession = function (user_name, title) { return this.getUser(user_name).newSession(title); };
+
+/**
+ * 对话
+ * @param {string} user_name - 面向用户名称
+ * @param {string} session_id - 会话ID
+ * @param {string} content - 消息内容
+ * @param {string} sender - 发送人名称
+ * @returns {object} 响应消息
+ */
+Agent.prototype.chat = async function (user_name, session_id, content, sender = '') {
+  if (!session_id) { session_id = this.getSessionId(user_name); }
+  else { this.setSessionId(user_name, session_id); }
+  // 清除之前可能的取消状态，为新的对话做准备
+  if (this.aborts && this.aborts[user_name]) {
+    delete this.aborts[user_name];
+  }
+  return await this.send(user_name, session_id, content, sender);
+};
+
+/**
+ * 推送对话
+ * @param {string} user_name - 面向用户名称
+ * @param {string} sender - 发送人名称
+ * @param {string} session_id - 会话ID
+ * @param {object} message - 消息
+ * @returns {object} 响应消息
+ */
+Agent.prototype.pushChat = async function (user_name, sender, session_id, message) {
+  return await this.emitEvent('chat:out', { user_name, sender: this.config.name, receiver: sender, session_id, ...message });
+};
+
+/**
+ * 获取通用提示词（think.md）
+ */
+Agent.prototype._getCommonPrompt = function () {
+  let prompt = this.getPrompt('think');
+  if (prompt) { return prompt; }
+  let file;
+  if (this.config.dynamic_prompt) {
+    file = "./common_prompt/dynamic_think.md".fullname(__dirname);
+  }
+  else {
+    file = "./common_prompt/static_think.md".fullname(__dirname);
+  }
+  return file.loadText();
+};
+
+/**
+ * 获取静态提示词（精简版 + 按需自动加载）
+ * 默认只加载 role.md + 公共提示词 think.md
+ * @returns {string} 静态提示词
+ */
+Agent.prototype._getStaticPrompt = function () {
+  let static_prompt = '';
+  let prompt_files = this.config.prompt_files;
+  if (prompt_files) {
+    let role_file = prompt_files['role'];
+    if (role_file) {
+      let text = role_file.fullname(this.getDir()).loadText();
+      if (text) { static_prompt += text + '\r\n'; }
+    }
+  }
+  let common_prompt = this._getCommonPrompt();
+  if (common_prompt) { static_prompt += common_prompt + '\r\n'; }
+  return static_prompt.trim();
+};
+
+/**
+ * 获取总结提示词
+ */
+Agent.prototype.getSummaryPrompt = function () {
+  let prompt = this.getPrompt('reflection');
+  if (prompt) { return prompt; }
+  let file = "./common_prompt/reflection.md".fullname(__dirname);
+  return file.loadText();
+};
+
+/**
+ * 获取当前会话的阶段提示词
+ * @param {string} user_name - 面向用户名称
+ * @param {string} session_id - 会话ID
+ * @returns {string} 阶段提示词
+ */
+Agent.prototype.getStagePrompt = function (user_name, session_id) {
+  let prompt = '';
+  let user = this.getUser(user_name);
+  let stage = user.getStage();
+  let prompt_files = this.config.prompt_files;
+
+  if (stage === 1) {
+    let f = prompt_files['soul'];
+    if (f) { let t = f.fullname(this.getDir()).loadText(); if (t) { prompt += '\r\n' + t; } }
+    f = prompt_files['should'];
+    if (f) { let t = f.fullname(this.getDir()).loadText(); if (t) { prompt += '\r\n' + t; } }
+  } else if (stage === 2) {
+    f = prompt_files['stakeholder'];
+    if (f) { let t = f.fullname(this.getDir()).loadText(); if (t) { prompt += '\r\n' + t; } }
+    f = prompt_files['can'];
+    if (f) { let t = f.fullname(this.getDir()).loadText(); if (t) { prompt += '\r\n' + t; } }
+  } else if (stage === 3) {
+    let f = prompt_files['ability'];
+    if (f) { let t = f.fullname(this.getDir()).loadText(); if (t) { prompt += '\r\n' + t; } }
+    f = prompt_files['workflow'];
+    if (f) { let t = f.fullname(this.getDir()).loadText(); if (t) { prompt += '\r\n' + t; } }
+  }
+  else if (stage === 4) {
+    let f = this.getSummaryPrompt();
+    if (f) { prompt += '\r\n' + f; }
+  }
+  // if (user_name && session_id) {
+  //   let stages = user.loaded_stages && user.loaded_stages[session_id];
+  //   if (stages && stages.length > 0) {
+  //     let prompt_files = this.config.prompt_files;
+  //     for (let stage of stages) {
+
+  //     }
+  //   }
+  // }
+  return prompt.trim();
+};
+
+/**
+ * 获取其他提示词
+ * @returns {string} 其他提示词
+ */
+Agent.prototype._getOtherPrompt = function () {
+  let prompt = this.getOtherPrompt();
+  let system_prompt = '';
+  for (let name of this.config.prompts) {
+    if (prompt[name]) { system_prompt += prompt[name].getOtherPrompt() + '\r\n'; }
+  }
+  return system_prompt.trim();
+};
+
+/**
+ * 获取用户提示词
+ * @param {string} user_name - 面向用户名称
+ * @returns {string} 用户提示词
+ */
+Agent.prototype.getUserPrompt = async function (user_name) {
+  return await this.getUser(user_name).getPrompt();
+};
+
+/**
+ * 获取联系人
+ * @param {string} contact_name - 联系人名称
+ * @returns {object} 联系人对象
+ */
+Agent.prototype._getContact = function (contact_name) { return this.contact[contact_name]; };
+
+/**
+ * 获取联系人提示词
+ * @param {string} contact_name - 联系人名称
+ * @returns {string} 联系人提示词
+ */
+Agent.prototype._getContactPrompt = async function (contact_name) {
+  let contact = this._getContact(contact_name);
+  return contact ? await contact.getPrompt() : '';
+};
+
+/**
+ * 获取动态提示词
+ * @param {string} user_name - 面向用户名称
+ * @param {string} contact_name - 联系人名称
+ * @param {string} session_id - 会话ID
+ * @returns {string} 动态提示词
+ */
+Agent.prototype._getDynamicPrompt = async function (user_name, contact_name, session_id) {
+  let prompt = '';
+  if (this.config.dynamic_prompt) {
+    let stage_prompt = this.getStagePrompt(user_name, session_id);
+    if (stage_prompt) { prompt += '\r\n' + stage_prompt; }
+  }
+  let contact_prompt = await this._getContactPrompt(contact_name);
+  if (contact_prompt) { prompt += '\r\n' + contact_prompt; }
+  let user_prompt = await this.getUserPrompt(user_name);
+  if (user_prompt) { prompt += '\r\n' + user_prompt; }
+  let status_prompt = this._getStatusPrompt(user_name, session_id);
+  if (status_prompt) { prompt += '\r\n' + status_prompt; }
+  return prompt.trim();
+};
+
+/**
+ * 获取基础提示词
+ * @returns {string} 基础提示词
+ */
+Agent.prototype._getBasePrompt = function () {
+  return `你的英文名称是${this.config.name}，中文名称是${this.config.title}。`;
+};
+
+/**
+ * 获取状态提示词
+ * @param {string} user_name - 面向用户名称
+ * @param {string} session_id - 会话ID
+ * @returns {string} 状态提示词
+ */
+Agent.prototype._getStatusPrompt = function (user_name, session_id) {
+  return `当前会话ID(session_id)是${session_id}。`;
+};
+
+/**
+ * 获取系统提示词
+ * @param {string} user_name - 面向用户名称
+ * @param {string} contact_name - 联系人名称
+ * @param {string} session_id - 会话ID
+ * @returns {string} 系统提示词
+ */
+Agent.prototype._getSystemPrompt = async function (user_name, contact_name, session_id) {
+  let prompt = '';
+  if (this.config.fixed_prompt) {
+    prompt = this.getFixedPrompt();
+  }
+  else {
+    prompt = this._getBasePrompt();
+    let static_prompt = this._getStaticPrompt(user_name, session_id);
+    if (static_prompt) { prompt += '\r\n' + static_prompt; }
+  }
+
+  let other_prompt = this._getOtherPrompt();
+  if (other_prompt) { prompt += '\r\n' + other_prompt; }
+  let dynamic_prompt = await this._getDynamicPrompt(user_name, contact_name, session_id);
+  if (dynamic_prompt) { prompt += '\r\n' + dynamic_prompt; }
+  return prompt.trim();
+};
+
+/**
+ * 创建用户
+ * @param {object} config - 用户配置
+ * @returns {object} 用户对象
+ */
+Agent.prototype.createUser = function (config) {
+  let cg = { ...config };
+  let expression_md = cg.expression_md || '';
+  let impression_md = cg.impression_md || '';
+  delete cg.expression_md;
+  delete cg.impression_md;
+  let user = this.manager.user.create({
+    ...cg,
+    name: config.name,
+    title: config.title || `未命名用户（${config.name}）`,
+    description: config.description || `智能体（${this.config.name}）动态创建的用户，未明确指定身份`
+  });
+  if (expression_md) { user.setPrompt('expression', expression_md); }
+  if (impression_md) { user.setPrompt('impression', impression_md); }
+  return user;
+};
+
+/**
+ * 获取用户
+ * @param {string} user_name - 用户名称
+ * @returns {object} 用户对象
+ */
+Agent.prototype.getUser = function (user_name) {
+  if (!this.user[user_name]) {
+    this.user[user_name] = this.createUser({ name: user_name });
+  }
+  return this.user[user_name];
+};
+
+/**
+ * 获取身份提示词
+ * @param {string} user_name - 用户名称
+ * @returns {string} 用户提示词
+ */
+Agent.prototype.getUserPrompt = function (user_name) { return this.getUser(user_name).getPrompt(); };
+
+/**
+ * 获取角色文件
+ * @returns {string} 角色文件路径
+ */
+Agent.prototype.getRoleFile = function () { return this.getPromptFile('role'); };
+
+/**
+ * 获取灵魂文件
+ * @returns {string} 灵魂文件路径
+ */
+Agent.prototype.getSoulFile = function () { return this.getPromptFile('soul'); };
+
+/**
+ * 获取能力文件
+ * @returns {string} 能力文件路径
+ */
+Agent.prototype.getAbilityFile = function () { return this.getPromptFile('ability'); };
+
+/**
+ * 获取提示词文件
+ * @param {string} type - 提示词类型
+ * @returns {string} 提示词文件路径
+ */
+Agent.prototype.getPromptFile = function (type) {
+  let file = this.config.prompt_files[type];
+  if (!file) {
+    return '';
+  }
+  return file.fullname(this.getDir());
+};
+
+/**
+ * 设置提示词
+ * @param {string} type - 提示词类型
+ * @param {string} prompt - 提示词内容
+ * @returns {string} 提示词文件路径
+ */
+Agent.prototype.setPrompt = function (type, prompt) {
+  let file = this.getPromptFile(type);
+  file.addDir();
+  file.saveText(prompt);
+  return file;
+};
+
+/**
+ * 获取对话上下文
+ * @param {string} user_name - 面向用户名称
+ * @param {string} contact_name - 联系人名称
+ * @param {string} session_id - 会话ID
+ * @param {Array} messages - 对话上下文数组
+ * @returns {Array} 对话上下文
+ */
+Agent.prototype._addSystemPrompt = async function (user_name, contact_name, session_id, messages) {
+  if (!messages) { messages = []; }
+  let system_prompt = await this._getSystemPrompt(user_name, contact_name, session_id);
+  if (system_prompt) {
+    if (messages.length > 0) {
+      if (messages[0].role !== 'system') {
+        messages.unshift({ role: 'system', content: system_prompt });
+      } else {
+        messages[0] = { role: 'system', content: system_prompt };
+      }
+    } else {
+      messages.push({ role: 'system', content: system_prompt });
+    }
+  }
+  return messages;
+};
+
+/**
+ * 获取提示词
+ * @param {string} type - 提示词类型
+ * @returns {string} 提示词内容
+ */
+Agent.prototype.getPrompt = function (type) {
+  let file = this.getPromptFile(type);
+  if (!file) { return ''; }
+  return file.loadText();
+};
+
+/**
+ * 获取智能体的提示词文件路径列表
+ * @returns {Array} 提示词文件路径列表
+ */
+Agent.prototype.getPromptFiles = function () {
+  let prompts = this.config.prompt_files || [];
+  let files = [];
+  let dir = this.getDir();
+  for (let name in prompts) { files.push({ name, file: prompts[name].fullname(dir) }); }
+  return files;
+};
+
+/**
+ * 获取智能体详情
+ * @returns {object} 智能体详情
+ */
+Agent.prototype.getDetail = function () {
+  return { ...this.config, agent_dir: this.getDir(), config_file: this.config_file, script_file: this.script_file, prompt_files: this.getPromptFiles() };
+};
+
+/**
+ * 设置提示词
+ * @param {string} type - 提示词类型
+ * @param {Object} model - 数据模型
+ * @returns {string} 提示词文件路径
+ */
+Agent.prototype.setPromptByModel = function (type, model) {
+  let tpl = new Tpl();
+  return this.setPrompt(type, tpl.view(`./prompt_tpl/${type}.md`.fullname(this.getDir()), model));
+};
+
+/**
+ * 获取固定提示词
+ * @returns {string} 固定提示词
+ */
+Agent.prototype.getFixedPrompt = function () {
+  let { description } = this.config;
+  let prompt = '';
+  // 先添加角色提示词，亮明身份
+  prompt += this._getBasePrompt();
+  if (description) {
+    prompt += '\r\n' + description;
+  }
+  // 添加职责范围提示词
+  let should_prompt = this._getShouldPrompt();
+  if (should_prompt) {
+    prompt += '\r\n' + should_prompt;
+  }
+  // 添加技能列表提示词
+  let skill_prompt = this.getSkillListPrompt();
+  if (skill_prompt) {
+    prompt += '\r\n' + skill_prompt;
+  }
+  // 添加干系人提示词
+  let contact_prompt = this._getStakeholderPrompt();
+  if (contact_prompt) {
+    prompt += '\r\n' + contact_prompt;
+  }
+  // 添加工作流程提示词
+  let work_prompt = this._getWorkFlowPrompt();
+  if (work_prompt) {
+    prompt += '\r\n' + work_prompt;
+  }
+  return prompt.trim();
+};
+
+/**
+ * 获取职责范围提示词
+ * @returns {string} 职责范围提示词
+ */
+Agent.prototype._getShouldPrompt = function () {
+  let prompt = this.getPrompt('should');
+  return prompt.trim();
+};
+
+/**
+ * 获取干系人提示词
+ * @returns {string} 干系人提示词
+ */
+Agent.prototype._getStakeholderPrompt = function () {
+  let prompt = this.getPrompt('stakeholder');
+  if (prompt) {
+    prompt += '\r\n如果有人能帮你完成用户的需求，你可以优先让他们帮你完成，否则才自己完成。';
+  }
+  return prompt.trim();
+};
+
+/**
+ * 获取工作流程提示词
+ * @returns {string} 工作流程提示词
+ */
+Agent.prototype._getWorkFlowPrompt = function () {
+  let prompt = this.getPrompt('workflow');
+  return prompt.trim();
+};
+
+/**
+ * 获取技能列表提示词
+ * @returns {string} 技能列表提示词
+ */
+Agent.prototype.getSkillListPrompt = function () {
+  let skill = this.getSkill();
+  let skills = this.config.skills || [];
+  let prompt = '## 掌握的技能\r\n';
+  let not_prompt = '';
+  for (let i = 0; i < skills.length; i++) {
+    let name = skills[i];
+    let o = skill[name];
+    if (o) {
+      let { name, title, description } = o.config;
+      prompt += `${title}(${name}): ${description}\n`;
+      break;
+    }
+    else {
+      not_prompt += name + '\r\n';
+    }
+  }
+  if (not_prompt) {
+    prompt += '## 未掌握的技能\r\n';
+    prompt += not_prompt;
+    prompt += '\r\n先找技能导师帮你补全未掌握的技能。如果技能导师不能帮你补全，你则直接尝试工作看看。';
+  }
+  return prompt.trim();
+};
+
+module.exports = { Agent };