Files
agent/app/server/config.js
T
kicer b0a8283406 占位裁剪新增 turns(真人回合)条件:回合内不裁,跨回合才裁
rounds 数的是 assistant 行,长回合里会把模型还要用的回执裁掉——实测有回合把同一文件
分段重读了 24 次(每次都在 rounds:2 生效的那一轮回来重读)。

- 规则新增 turns 字段:其后又来了几条真人消息(role=user 且 type 为空,注入行不算)
- rounds 与 turns 同时满足才裁(AND);两者都写 0 才算规则关闭
- 默认:fetch / read_file / web_search 用 rounds:2 + turns:1(回合内绝不裁),
  write_file 参数侧保持 rounds:1 + turns:0(只是写盘快照,照旧早裁)
- config.example.yml 补了带时间线的例子与「rounds=后面 AI 又说了几句话 /
  turns=后面又来了几条真人消息」的注释;AGENTS.md 与 tool-design.md 同步
- 启动日志改为打印 轮≥N,回合≥M,便于核对生效规则
2026-11-03 08:06:43 +08:00

618 lines
37 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 配置加载:AGENT_CONFIG 指向 config.yml(见 config.example.yml)
const fs = require('fs');
const path = require('path');
const YAML = require('yaml');
const log = require('./log');
// MCP 单次工具调用(tools/call)的缺省最大等待,与 mcp.js 的 CALL_TIMEOUT_MS 保持一致。
const MCP_CALL_TIMEOUT_MS = 60000;
// MCP 工具名单(tools_allow/tools_deny)归一化:只接受数组,项统一转字符串去空白、丢空项;
// 空数组/非数组视作未配置(返回 undefined),避免「allow: [] 是不是全禁」这种歧义。
function normToolNames(v) {
if (!Array.isArray(v)) return undefined;
const out = v.map(x => String(x).trim()).filter(Boolean);
return out.length ? out : undefined;
}
// profile 的 prompt 文件查找基准目录:与内置模板同处 server/templates/
// (compose 已 bind-mount ./app/server,宿主可直接编辑,无需重建镜像)。
const TEMPLATES_DIR = path.join(__dirname, 'templates');
// model_profiles 归一化:顶层 map {名称: {tools_allow?, tools_deny?, system_prompt_file?}},
// 供 platforms[].models[].profile 引用(同 id 模型跳平台复用时免重复配置)。
// - tools_allow 只按最终发给模型的工具名匹配(内置名 + MCP 名,含冲突时加的 server__ 前缀)。
// 语义与 MCP 的 tools_allow(空数组=未配)有意不同:这里空数组 [] 是有效配置 = 一个工具都不发
// (纯文本模式,给弱到不会调工具的小模型用);只有「没写/非数组」才是「不过滤、发全量」。
// - tools_deny:profile 级黑名单,在 allow 之后叠加生效(deny 赢,与 MCP 同构)。未配/非数组 =
// 继承全局 tools_deny(DEFAULTS 默认屏蔽 lab);[] = 显式清空(lab profile 靠它把元工具换回来);
// 非空 = 替换全局。同样只按最终名匹配。
// - system_prompt_file:相对 templates/(也接受绝对路径),配置加载时一次性读入常驻内存,
// 运行期切换零 IO;缺失/读不到/内容为空直接报校验错——拦在保存/重启预检,不留到运行期降级。
// - 三样都没配 = 不起任何作用,报错误防误配空壳。
function normalizeModelProfiles(rawProfiles) {
const out = {};
if (!rawProfiles || typeof rawProfiles !== 'object' || Array.isArray(rawProfiles)) return out;
for (const [name, p] of Object.entries(rawProfiles)) {
const key = String(name).trim();
if (!key) continue;
if (!p || typeof p !== 'object' || Array.isArray(p)) {
throw new Error('model_profiles.' + key + ' 必须是对象 {tools_allow, tools_deny, system_prompt_file}');
}
// 不用 normToolNames:那会把空数组吐成 undefined(丢抑「[] = 零工具」语义);这里只归一字符串项。
const tools_allow = Array.isArray(p.tools_allow)
? p.tools_allow.map(x => String(x).trim()).filter(Boolean)
: undefined;
// tools_deny 与 allow 同款手工归一:[] 是有效配置(显式清空全局黑名单),不能被当「未配」。
const tools_deny = Array.isArray(p.tools_deny)
? p.tools_deny.map(x => String(x).trim()).filter(Boolean)
: undefined;
const file = String(p.system_prompt_file || '').trim();
let prompt = '';
if (file) {
const abs = path.isAbsolute(file) ? file : path.join(TEMPLATES_DIR, file);
try { prompt = fs.readFileSync(abs, 'utf8'); } catch (_) {
throw new Error('model_profiles.' + key + '.system_prompt_file 读取失败:' + abs);
}
prompt = prompt.trim();
if (!prompt) throw new Error('model_profiles.' + key + '.system_prompt_file 内容为空:' + abs);
}
if (!tools_allow && !tools_deny && !prompt) {
throw new Error('model_profiles.' + key + ' 至少需配 tools_allow / tools_deny / system_prompt_file 之一');
}
out[key] = { name: key, tools_allow, tools_deny, system_prompt_file: file, prompt };
}
return out;
}
// 默认配置:与 app/config.example.yml 一一对应(改这里同时改示例,保持同步)。
const DEFAULTS = {
port: 8090,
// 任务工作区根目录:AI 的文件操作限制在此(容器内挂 ./tasks → /workspace/tasks)。
workspace_root: '/workspace/tasks',
// 数据根目录:SQLite(.agent.db)与启动 prompt dump 放这里(容器内挂 ./data → /workspace/data)。
data_root: '/workspace/data',
// 缺省 data_root/.agent.db。
db_path: '',
// executor / 微信接入(wxbot)均不占配置字段:两组件接线纯 env(compose 经根 .env 注入,见 parseAndValidate);
// 本配置文件内含密钥,只给 core 进程读,executor/wxbot 一律不挂不读。
terminal: { default_timeout_ms: 30000, max_output_chars: 10000 },
// fetch:timeout_ms 覆盖请求发出到 body 读完的全生命周期;max_bytes 为流式抓取字节上限(超限即断开)。
// 下载与返回两上限解耦:下载不进上下文可宽松,返回默认收紧(max_chars),模型显式传 max_chars 时
// 夹在 max_chars_hard 硬帽内;超窗尾部提示 offset,续读走 ctx.run 上的回合缓存不重抓。
// allow_private=false 开 SSRF 防护:目标主机名解析到回环/私有/链路本地地址即拒绝(重定向逐跳复查);
// 确需抓内网服务再显式开 true(注意 DNS 重绑定属残余风险)。
fetch: { timeout_ms: 30000, max_bytes: 1048576, max_chars: 12000, max_chars_hard: 64000, allow_private: false },
// auto_compress_tokens:本轮 In token 峰值 ≥ 此值时推送「自动压缩」提议(0=关)。
// auto_complete_ms:held(保持中)超过此时长自动收口为 completed(0=关)。key 非独占后 held 不占任何资源,
// 收口是纯视觉动作:历史/绑定不动,再发言照常由 completed 分支续跑(见 engine.sweepHeldTimeouts)。
// 历史重放占位裁剪(llm.buildMessages):trim.rules 逐条声明「哪个工具、参数侧还是回执侧、
// 距尾多远换单行占位」;只改发给上游的副本,DB/UI 不动。
// 两个距离条件**同时满足**才裁:
// rounds = 这一行之后又出现了几条 assistant 行(「后面 AI 又说了几句话」)
// turns = 这一行之后又来了几条真人消息(role=user 且 type 为空,「后面又来了几条真人消息」)
// 所以 turns:1 = 回合内绝不裁、跨过用户回合边界才裁(避免长回合里模型反复重读同一个文件)。
// 这里是默认策略的唯一来源:config.yml 写了 trim.rules 就整体替换(写 [] = 全关)。
agent: { temperature: 1.0, max_tool_iterations: 100, max_retries: 2, language: 'Simplified Chinese', auto_compress_tokens: 60000, auto_complete_ms: 1800000, trim: {
min_chars: 600,
rules: [
// 参数正文只是写盘时的快照:不带 turns,回合内也照裁(省的是每轮重发整个文件)
{ tool: 'write_file', side: 'args', fields: ['content'], rounds: 1 },
// 回执可再生(页面可重抓 / 文件可重读 / 可重搜):turns:1 保证同一回合内不裁,回合结束后按 rounds 兜底
{ tool: 'fetch', side: 'result', rounds: 2, turns: 1, status_regex: '^HTTP (\\d{3})' },
{ tool: 'read_file', side: 'result', rounds: 2, turns: 1 },
{ tool: 'web_search', side: 'result', rounds: 2, turns: 1 },
],
} },
// 大图上传预处理(浏览器端 canvas 压缩,参数经 /api/system/status 下发前端)。
// paste_to_file_threshold_chars:粘贴文本超过该字符数时前端转成 .txt 附件,0 = 关闭。
upload: { image_compress_threshold_kb: 1536, image_max_dim: 2000, image_quality: 0.85, confirm_size_mb: 10, paste_to_file_threshold_chars: 2000 },
// 技能根目录:留空取 workspace_root 同级 skills(/workspace/tasks → /workspace/skills)。
skills: { skills_root: '', timeout_ms: 120000 },
// 长期记忆(日记,memory.js):会话收口(下班)时一条几十字的第一人称碎片,一片一行入 memory_fragments,
// day=事件日(会话最后活跃日:人回忆问哪天干的活,不是哪天补记)。记忆分层:存储默认永久
//(虚拟人的过去不能到点就抹);注入只取最近几条当「嘴边的工记」(近几片足以接上旧话,多了是噪音);
// inject_max = 新会话开场注入上限(默认 3,硬帽 50);0 = 只记录不自动注入。
// retain_days = 存储裁剪窗:0 = 默认永不删;正数 = 超窗硬删(自动清理/隐私抹除场景才用)。
// wrap_idle_ms = 空闲收口阈值:held/completed 且超过此时长无更新 → 后台 LLM 摘要收口、
// 归档、微信通道解绑退位(下次消息自然新工作台);0 = 关。设定定时任务是显式收口,不受此开关影响。
memory: { inject_max: 3, retain_days: 0, wrap_idle_ms: 14400000 },
// 【已废弃】旧版模型保持租约(held 到期自动释放)。调度已改为「key 共享并发 + 优先级选择」(见 engine.chooseKey),
// 不再有任何到期逻辑;字段保留仅为旧 config.yml 兼容(解析不报错),运行期无人读取。
model_hold: { idle_release_ms: 180000, active_max_ms: 1800000, sweep_ms: 10000 },
// 日志等级:debug < info < warn < error < none(none=全部静默)。
log_level: 'info',
// 模型平台池(无默认值,结构见 config.example.yml)。
platforms: [],
// 全局工具黑名单:profile 未配 tools_deny 时继承它;allow 先、deny 后叠加(deny 赢,与 mcp_servers 同构)。
// 默认屏蔽元工具 lab:它只该出现在显式清空 deny 的 profile 里,不进常规请求的 tools 数组(lab → lab 组合)。
tools_deny: ['lab'],
// 模型 profile(prompt + tools 名单组合):platforms 里的模型用 profile: <名> 引用。
model_profiles: {
// lab:统一入口元工具自测组合——tools 收缩到 1 个,其余能力经 lab(help) 现场发现。
// tools_deny 必须显式清空:不配 = 继承全局 ['lab'],deny 后叠加会把 lab 自己禁掉 → 零工具。
lab: { tools_allow: ['lab'], tools_deny: [], system_prompt_file: 'profile-lab.txt' },
// 纯文本对话:一个工具都不发。
zero: { tools_allow: [], system_prompt_file: 'profile-zero.txt' },
},
// 登录认证:{users:[{user,password}], secret?, ttl_ms?};null / users 空 = 不启用。
auth: null,
// 外部 MCP 服务列表(无默认值):{name?, url, headers?, mode?(默认 advertise), timeout_ms?(默认 60s)}。
// mode 三态:advertise=工具下发给模型;skill=不下发,改为以技能形式暴露(get 返回原始
// input_schema,run 直接转发);disable=不加载。
mcp_servers: [],
// 公网临时链接:base_url 非空才启用 mint_public_link(config.yml 优先,其次 env PUBLIC_BASE_URL)。
public_link: { base_url: '', ttl_ms: 1800000 },
};
function deepMerge(base, extra) {
const out = Object.assign({}, base);
for (const [k, v] of Object.entries(extra || {})) {
if (v && typeof v === 'object' && !Array.isArray(v) && typeof base[k] === 'object' && base[k] !== null && !Array.isArray(base[k])) {
out[k] = deepMerge(base[k], v);
} else {
out[k] = v;
}
}
return out;
}
function hostnameOf(url) {
try { return new URL(url).hostname.split('.')[0]; } catch (_) { return ''; }
}
// 旧版扁平 models[](每模型自带 url/api_key)自动迁移为 platforms 层级:同 url+api_key 归为同一平台同一 key。
// 输出新格式:models 在平台层,keys 只含 api_key/concurrency。
function migrateLegacyModels(models) {
const groups = [];
const byKey = new Map();
for (const m of models) {
if (!m || !m.id) continue;
const url = String(m.url || '').replace(/\/+$/, '');
const apiKey = String(m.api_key || '');
const gk = url + '\n' + apiKey;
let p = byKey.get(gk);
if (!p) {
// 平台名 = 主机名首段;同名(如只 path 不同)自动加序号,避免「平台名/模型id」唯一键碰撞。
let name = hostnameOf(url) || ('p' + (groups.length + 1));
for (let n = 2; groups.some(g => g.name === name); n++) name = (hostnameOf(url) || 'p') + '-' + n;
p = { name, url, type: 'openai', models: [], keys: [{ api_key: apiKey, concurrency: 1 }] };
byKey.set(gk, p);
groups.push(p);
}
p.models.push({ id: m.id, display_name: m.display_name || m.id, vision: m.vision !== false });
}
return groups;
}
// 规范化并校验 platforms 层级:平台(name/url/type) → models(id/display_name/...) + keys(api_key/concurrency)。
// 新版结构:models 提到平台层(与 url/type 同级),所有 key 共用同一份 models;key 数组里只放
// {api_key, concurrency},不再挂 models。旧版 keys[j].models 写法直接报错,让用户改 YAML。
// 内部唯一键 = 平台名/模型id:不同平台允许同模型 id,同平台内必须唯一(会话/模型池/用量均按该键认模型)。
function normalizePlatforms(rawPlatforms, profileNames) {
const seen = new Set(); // 已用唯一键(平台名/模型id)
const out = [];
for (let pi = 0; pi < rawPlatforms.length; pi++) {
const p = rawPlatforms[pi] || {};
if (!p.url) throw new Error('platforms[' + pi + '] 缺少 url(OpenAI 兼容 /v1 地址)');
// 检测旧格式 keys[j].models:发现则报错,不兼容(改动 3)。
for (let ki = 0; ki < (p.keys || []).length; ki++) {
if (Array.isArray(p.keys[ki] && p.keys[ki].models)) {
throw new Error('platforms[' + pi + '].keys[' + ki + '].models 写法已废弃:' +
'models 应提到 platforms[' + pi + '].models(与 url/type 同级),所有 key 共用同一份 models。' +
'请改写 config.yml。');
}
}
const url = String(p.url).replace(/\/+$/, '');
const name = String(p.name || '').trim() || (hostnameOf(url) || ('p' + (pi + 1)));
// type 可完全自定义(不校验白名单);它决定余额查询适配器,由 routes/platforms.js 按类型分发。
// 缺省取平台 name:用户起名"bigmodel"时不显式配 type 也能命中 bigmodel 适配器;
// 自定义名(如"zhipu-prod")若不命中已接入 adapter,查询时返回 400(不静默回退)。
const type = String(p.type || name).trim();
// 平台层 models 解析
const models = [];
for (let mi = 0; mi < (p.models || []).length; mi++) {
const m = p.models[mi] || {};
if (!m || !m.id) throw new Error('平台「' + name + '」的 models[' + mi + '] 缺少 id');
const uid = name + '/' + String(m.id);
if (seen.has(uid)) throw new Error('模型重复:平台「' + name + '」下已有模型 id:' + m.id + '(不同平台可同名,同平台内必须唯一)');
seen.add(uid);
// 选填:引用顶层 model_profiles 的组合名(tools 白名单 + 自定义 system prompt);
// 不配 = 默认全量。引用了不存在的名字直接报错,不静默回退。
const profile = m.profile ? String(m.profile).trim() : '';
if (profile && !profileNames.has(profile)) {
throw new Error('平台「' + name + '」的模型「' + m.id + '」引用了不存在的 profile:' + profile + '(请核对顶层 model_profiles)');
}
models.push({
id: String(m.id),
display_name: m.display_name ? String(m.display_name) : String(m.id), // 缺省 = id
vision: m.vision !== false, // 缺省支持(现在模型基本都带视觉);不支持时配 vision: false 显式关——关后 read_file 读图不回传像素
enable: m.enable !== false, // 选填,默认启用;禁用后不进模型池,不参与分配/绑定(重启生效)
// 选填:模型特有的请求体参数对象。发往上游时整体合并进 body 顶层。
extra_params: (m.extra_params && typeof m.extra_params === 'object' && !Array.isArray(m.extra_params)) ? m.extra_params : {},
// 选填:前端启用「深度思考」时合并进 body。可覆盖 extra_params 的同名键。
thinking_params: (m.thinking_params && typeof m.thinking_params === 'object' && !Array.isArray(m.thinking_params)) ? m.thinking_params : {},
// 选填:思维链回传字段名(如 reasoning_content——DeepSeek 系平台要求历史轮把思考链喂回)。
// 非空时发请求前给历史 assistant 行挂该字段;空(缺省)= 不回传。纯发送侧旋钮,
// 与接收解析无关(接收早已兼容 reasoning/reasoning_content 双名)。
reasoning_ack_field: typeof m.reasoning_ack_field === 'string' ? m.reasoning_ack_field.trim() : '',
profile,
});
}
// keys 仅含 api_key/concurrency(不再挂 models)
const keys = [];
for (let ki = 0; ki < (p.keys || []).length; ki++) {
const k = p.keys[ki] || {};
const concurrency = Math.max(1, parseInt(k.concurrency, 10) || 1);
keys.push({ api_key: String(k.api_key || ''), concurrency });
}
out.push({ name, url, type, models, keys });
}
return out;
}
// ---------- 历史重放的重负载占位裁剪(agent.trim) ----------
// 语义:某条工具调用/回执距对话尾部 ≥rounds 个 assistant 轮、且 ≥turns 个真人回合后,
// 把其中「可再生的重负载」换成单行占位再发给上游(llm.buildMessages;DB/UI 不动)。
// rounds = 「后面 AI 又说了几句话」;turns = 「后面又来了几条真人消息」(type 为空的 user 行)。
// 两者同时满足才裁。只该给「内容可再生或只是当时快照」的工具开:read_file/fetch 能重读重抓、write_file 参数
// 只是快照;terminal 输出是一次性的,裁掉模型就永久看不到了。
const TRIM_RULE_KEYS = new Set(['tool', 'side', 'rounds', 'turns', 'fields', 'min_chars', 'status_regex']);
function toNonNegInt(v, d) {
const n = Math.floor(Number(v));
return Number.isFinite(n) ? Math.max(0, n) : d;
}
// 单条规则校验:未知字段直接报错(拼错静默忽略 = 以为省了 token 其实没省)。
function normalizeTrimRule(r, i, defMinChars) {
const at = 'agent.trim.rules[' + i + ']';
if (!r || typeof r !== 'object' || Array.isArray(r)) throw new Error(at + ' 必须是对象');
for (const k of Object.keys(r)) {
if (!TRIM_RULE_KEYS.has(k)) {
throw new Error(at + ' 含未知字段:' + k + '(可用:' + Array.from(TRIM_RULE_KEYS).join(' / ') + ')');
}
}
const tool = String(r.tool == null ? '' : r.tool).trim();
if (!tool) throw new Error(at + ' 缺少 tool(填模型看到的最终工具名,MCP 重名时含 server__ 前缀)');
const side = String(r.side == null ? '' : r.side).trim();
if (side !== 'args' && side !== 'result') {
throw new Error(at + '.side 只能是 args(裁调用参数)/ result(裁回执正文),收到:' + side);
}
// rounds / turns 都是「距尾多远」,同时满足才裁;两个都写 0(或不写)= 该条规则关闭,直接丢掉,不留空规则。
const rounds = toNonNegInt(r.rounds, 0);
const turns = toNonNegInt(r.turns, 0);
if (rounds <= 0 && turns <= 0) return null;
const out = { tool, side, rounds, turns, min_chars: toNonNegInt(r.min_chars, defMinChars) };
if (side === 'args') {
if (!Array.isArray(r.fields) || !r.fields.length) {
throw new Error(at + '(args 侧)必须配 fields 数组(要占位的顶层参数名,如 [content])');
}
out.fields = r.fields.map(x => String(x).trim()).filter(Boolean);
if (!out.fields.length) throw new Error(at + '(args 侧)fields 不能为空');
} else if (r.fields !== undefined) {
throw new Error(at + '.fields 只适用于 args 侧(result 侧整段正文替换,无需点名字段)');
}
if (r.status_regex !== undefined && r.status_regex !== null && String(r.status_regex).trim()) {
if (side !== 'result') throw new Error(at + '.status_regex 只适用于 result 侧');
const src = String(r.status_regex);
try { new RegExp(src); } catch (_) { throw new Error(at + '.status_regex 不是合法正则:' + src); }
out.status_regex = src;
}
return out;
}
// agent.trim 归一:默认值来自 DEFAULTS.agent.trim.rules(唯一来源),config.yml 写了 rules
// 就整体替换([] = 全关)。归一结果直接写回 cfg.agent.trim.rules,不再另造 trim_rules 键。
function normalizeAgentTrim(cfg) {
// 拷一份再改:无 agent 段时 cfg.agent 与 DEFAULTS.agent 是同一引用,直接写会污染默认值
// (配置页反复校验时上一份的 trim 会漏给下一份)。
const a = Object.assign({}, cfg.agent || {});
cfg.agent = a;
const trim = (a.trim && typeof a.trim === 'object' && !Array.isArray(a.trim)) ? a.trim : {};
const defMinChars = toNonNegInt(trim.min_chars, DEFAULTS.agent.trim.min_chars);
// undefined / null 都是「没配」,回落到 DEFAULTS(deepMerge 通常已把默认数组带进来,
// 这里兜住 agent.trim: null 这类显式空值);显式 [] 才是全关。
const rawRules = (trim.rules === undefined || trim.rules === null) ? DEFAULTS.agent.trim.rules : trim.rules;
if (!Array.isArray(rawRules)) throw new Error('agent.trim.rules 必须是数组');
const rules = rawRules.map((r, i) => normalizeTrimRule(r, i, defMinChars)).filter(Boolean);
const seen = new Set();
for (const r of rules) {
const k = r.side + '\u0000' + r.tool;
if (seen.has(k)) throw new Error('agent.trim.rules 重复声明同一工具同一侧:' + r.tool + '(' + r.side + ')');
seen.add(k);
}
a.trim = Object.assign({}, trim, { min_chars: defMinChars, rules });
}
// 校验原始配置文本(启动读文件与网页编辑共用)。configPath 仅记录来源,可为空。
function parseAndValidate(rawText, configPath) {
let raw = YAML.parse(rawText || '') || {};
const cfg = deepMerge(DEFAULTS, raw);
normalizeAgentTrim(cfg);
// ---------- 模型配置:platforms 层级(platforms[].models[] + platforms[].keys[])----------
// models 提到平台层(与 url/type 同级),多 key 共用同一份 models。
// cfg.models 为打平后的运行时视图:每个 key 都展开一份(key 数 × models 数),
// 内部唯一键 = 「平台名/模型id」(key_index 是副本下标,不参与 id 命名空间);
// 调用处(池/会话/路由/用量)按 id 认模型,key_index 仅用于按 key 拆余额展示。
if ((!Array.isArray(raw.platforms) || !raw.platforms.length) && Array.isArray(raw.models) && raw.models.length) {
raw = Object.assign({}, raw, { platforms: migrateLegacyModels(raw.models) });
log.info('config', '检测到旧配置 models[] 扁平格式,已自动迁移为 platforms 层级;建议改写 config.yml 为 platforms 格式');
}
// platforms 允许为空:可先起服务,再在前端设置页添加平台后重启(无模型时无会话可调度)。
const rawPlatforms = Array.isArray(raw.platforms) ? raw.platforms : [];
// 全局黑名单归一:非数组视作未配;deepMerge 对数组整体替换,config.yml 写了即覆盖 DEFAULTS。
cfg.tools_deny = Array.isArray(cfg.tools_deny)
? cfg.tools_deny.map(x => String(x).trim()).filter(Boolean)
: undefined;
// 用 deepMerge 后的 cfg.model_profiles(含内置 lab/zero),故 config.yml 不配也有默认组合。
cfg.model_profiles = normalizeModelProfiles(cfg.model_profiles);
cfg.platforms = normalizePlatforms(rawPlatforms, new Set(Object.keys(cfg.model_profiles)));
cfg.models = [];
cfg.platforms.forEach((p, pi) => p.keys.forEach((k, ki) => p.models.forEach((m, mi) => {
cfg.models.push({
// id = 内部唯一键「平台名/模型id」(池/会话/用量/前端均按它认模型,调用处无需区分);
// mid = 发给上游的原始模型名(请求体 body.model 用它)。
// key_index 是 key 副本下标:同 id 在 cfg.models 里会出现 N 次(N=key 数),便于按 key 拆余额。
id: p.name + '/' + m.id, mid: m.id,
display_name: m.display_name, vision: m.vision, enable: m.enable,
extra_params: m.extra_params, thinking_params: m.thinking_params,
reasoning_ack_field: m.reasoning_ack_field,
profile: m.profile,
url: p.url, api_key: k.api_key, platform: p.name, type: p.type, concurrency: k.concurrency,
platform_index: pi, key_index: ki, model_index: mi,
});
})));
if (!cfg.models.length) {
log.warn('config', '配置中没有可用模型(platforms 为空或其下模型全被禁用):可在设置页添加平台后重启。');
}
cfg.workspace_root = path.resolve(cfg.workspace_root);
cfg.data_root = path.resolve(cfg.data_root);
if (!cfg.db_path) cfg.db_path = path.join(cfg.data_root, '.agent.db');
// executor 远程执行:纯 env 接线(compose 注 EXECUTOR_URL/EXECUTOR_TOKEN;未注 = 本地 spawn,单机调试形态)。
// cfg.executor 仍作运行期访问器供 remote-exec 读取;url 去尾部斜杠(拼 /exec 用)。executor 进程不读本配置文件(防密钥外泄)。
cfg.executor = {
url: String(process.env.EXECUTOR_URL || '').trim().replace(/\/+$/, ''),
token: String(process.env.EXECUTOR_TOKEN || '').trim(),
};
// 微信接入(wechat.js):纯 env 接线(wxbot 为栈内组件,不再是 config.yml 字段;旧文件里的 wxbot: 段直接忽略)。
// WXBOT_URL 缺省 http://agent-wxbot:8093(compose 注同名 env,置空 = 微信入口整体静默关闭);
// WXBOT_TOKEN 未配 = 关闭(init.sh 生成,core ↔ wxbot 两侧同值)。cfg.wxbot 仍作为运行期访问器供 wechat/routes 读取。
cfg.wxbot = {
url: String(process.env.WXBOT_URL != null ? process.env.WXBOT_URL : 'http://agent-wxbot:8093').trim().replace(/\/+$/, ''),
token: String(process.env.WXBOT_TOKEN || '').trim(),
};
// 日志等级:只认 debug/info/warn/error/none(off 是 none 别名),非法值按 info(不影响启动)
cfg.log_level = String(cfg.log_level || 'info').trim().toLowerCase();
if (cfg.log_level === 'off') cfg.log_level = 'none';
if (['debug', 'info', 'warn', 'error', 'none'].indexOf(cfg.log_level) < 0) cfg.log_level = 'info';
// 技能根目录:显式配置优先;缺省取 workspace_root 的同级 skills 目录(容器内 /workspace/tasks → /workspace/skills)。
if (!cfg.skills || !cfg.skills.skills_root) {
cfg.skills_root = path.resolve(cfg.workspace_root, '..', 'skills');
} else {
cfg.skills_root = path.resolve(cfg.skills.skills_root);
}
if (cfg.skills) {
cfg.skills.timeout_ms = (cfg.skills.timeout_ms == null) ? 120000 : cfg.skills.timeout_ms;
}
// auth 规范化:多用户 auth.users: [{user, password, role?, model?}];兼容旧的单用户 auth.{user,password}
if (cfg.auth && !Array.isArray(cfg.auth.users)) {
cfg.auth.users = cfg.auth.user ? [{ user: cfg.auth.user, password: cfg.auth.password, role: cfg.auth.role, model: cfg.auth.model }] : [];
}
if (cfg.auth && Array.isArray(cfg.auth.users)) {
cfg.auth.users = cfg.auth.users
.filter(u => u && u.user)
.map(u => ({
user: String(u.user),
password: String(u.password == null ? '' : u.password),
// 角色:admin = 管理员(设置页全部功能 + 用户管理);缺省 user = 普通用户(设置只开账户页)。
role: u.role === 'admin' ? 'admin' : 'user',
// 选填:该用户新建会话时锁定的模型(内部唯一键「平台名/模型id」,如 qwen-tp/qwen3.8-flash)。
// 未配/空串 = 按原逻辑(前端预选或全局自动选择);配了但模型无效/被禁用时同样退回原逻辑。
model: u.model ? String(u.model).trim() : '',
}));
if (!cfg.auth.users.length) cfg.auth = null;
}
// 兼容旧配置:顶层 web_search.{url,authorization} 自动转为一条 mcp_servers(authorization 即一条 header)
if (raw.web_search && raw.web_search.url && !raw.mcp_servers) {
const ws = raw.web_search;
cfg.mcp_servers = [{
name: 'web-search',
url: ws.url,
headers: ws.authorization ? { Authorization: ws.authorization } : {},
}];
log.info('config', '检测到旧配置 web_search.*,已自动转为一条 mcp_servers;建议更新 config.yml 为 mcp_servers 格式');
}
// MCP 服务规范化:url 必填;name 缺省取主机名首段;headers 为普通键值对象(如 Authorization);
// mode 缺省 advertise,见下方三态校验(工具是否下发 / 是否加载,见 mcp.init);
// timeout_ms 为该服务单次 tools/call 的最大等待,缺省 60s(长任务服务如视频生成可调大)。
if (!Array.isArray(cfg.mcp_servers)) cfg.mcp_servers = [];
for (const s of cfg.mcp_servers) {
if (!s || !s.url) throw new Error('mcp_servers 每项必须有 url(MCP 服务的 JSON-RPC 端点)');
if (!s.name) {
try { s.name = String(new URL(s.url).hostname.split('.')[0]); } catch (_) { s.name = 'mcp'; }
}
// 旧字段 enable 已废弃且不静默忽略:未知键会被无声丢弃,那样「以为关了」的服务会照常连上、
// 照常烧额度。宁可启动即报错,把迁移动作逼到明面上。
if (s.enable !== undefined) {
throw new Error('mcp_servers 的 enable 已废弃,请改用 mode: advertise | skill | disable');
}
// 三态:advertise(默认,工具下发给模型)/ skill(不下发,改为以技能形式暴露)/
// disable(不连接、不发现)。拼错要报错而不是回落默认,否则又是一次静默降级。
const mode = String(s.mode == null ? '' : s.mode).trim().toLowerCase();
if (!mode) s.mode = 'advertise';
else if (mode === 'advertise' || mode === 'skill' || mode === 'disable') s.mode = mode;
else throw new Error('mcp_servers 的 mode 只能是 advertise / skill / disable,收到:' + mode);
const headers = {};
for (const [k, v] of Object.entries(s.headers || {})) headers[k] = String(v);
s.headers = headers;
// 单次工具调用的超时上限:缺省 60s,夹在 [1s, 10min](一次调用长期占着模型槽位,不允许无限等)。
// YAML 里写成字符串或写了非法值都回落到缺省。
s.timeout_ms = Math.min(Math.max(Number(s.timeout_ms) || MCP_CALL_TIMEOUT_MS, 1000), 600000);
// 工具名单(发现阶段生效,见 mcp.init):allow 为白名单,deny 在其后叠加生效(deny 优先)。
s.tools_allow = normToolNames(s.tools_allow);
s.tools_deny = normToolNames(s.tools_deny);
}
normalizePublicLink(cfg);
cfg.config_path = configPath || '';
return cfg;
}
// 公网临时链接(public_link)规范化:base_url 去尾斜杠;ttl_ms 夹在 [1min, 24h]——
// 公网链接宁可短不可长(“永久公开”正是这套机制要避免的东西)。
//
// 对外前缀的取值优先级:
// 1) config.yml 的 public_link.base_url(设置页「公网地址」手填的值,以它为准)。
// 2) env PUBLIC_BASE_URL(scripts/init.sh 探测公网 IP 后写进 .env 的部署地址)。
// 它只是默认值:页面里填过 1) 之后就归 1) 管,避免“重跑部署脚本”和“UI 手改”互相打架。
function normalizePublicLink(cfg) {
const pl = cfg.public_link || {};
const fromCfg = String(pl.base_url == null ? '' : pl.base_url).trim();
const fromEnv = String(process.env.PUBLIC_BASE_URL || '').trim();
const baseUrl = fromCfg || fromEnv;
cfg.public_link = {
base_url: String(baseUrl || '').trim().replace(/\/+$/, ''),
ttl_ms: Math.min(Math.max(Number(pl.ttl_ms) || 1800000, 60 * 1000), 24 * 3600 * 1000),
};
if (cfg.public_link.base_url && !/^https?:\/\//i.test(cfg.public_link.base_url)) {
log.warn('config', 'public_link.base_url 看起来不是 http(s) 地址:' + cfg.public_link.base_url);
}
return cfg;
}
function loadConfig(configPath) {
const p = configPath || process.env.AGENT_CONFIG || path.join(__dirname, '..', 'config.yml');
// 目录按“文件不存在”处理:Docker 在 bind mount 的源文件缺失时会建一个同名**空目录**,
// 直接 readFileSync 会 EISDIR 崩在启动阶段——那时用户看不到任何可操作的报错。
// 空文件/缺失都是合法状态:platforms 为空、auth 为空(= 未启用登录),全部配置可稍后在前端完成。
let text = '';
let isDir = false;
try {
const st = fs.statSync(p);
if (st.isFile()) text = fs.readFileSync(p, 'utf8');
else isDir = true;
} catch (_) { /* 不存在 */ }
if (isDir) {
log.warn('config', 'config.yml 是目录(Docker 在挂载源文件缺失时会自动建同名目录,容器内无法当文件写):' + p +
';请在宿主机上删掉该空目录后重跑 scripts/init.sh');
} else if (!text.trim()) {
log.warn('config', 'config.yml 缺失或为空(' + p + '):当前无模型、无登录鉴权;可在前端「设置」里补齐配置(保存后重启生效)');
}
return parseAndValidate(text, p);
}
// 从文本校验一份配置(页面编辑试运行 / 写盘前校验),返回完整生效 cfg。
function loadConfigFromText(text, configPath) {
return parseAndValidate(text, configPath || '');
}
// ---------- 配置读写(2.0:设置页管理 config.yml;无热重载,写盘后重启生效) ----------
// 读当前配置文件原文(保留注释);文件不存在返回 null。
function readConfigText(cfg) {
const p = cfg && cfg.config_path;
if (!p) return null;
// 目录(Docker 误建)与缺失一视同仁按“不存在”返回,交给调用方决定新建还是报错。
try { if (!fs.statSync(p).isFile()) return null; } catch (_) { return null; }
return fs.readFileSync(p, 'utf8');
}
// 单项编辑:[{path:[...], value}] 或 [{path:[...], delete:true}] 或 [{path:[...], value, append:true}]。
// 用 YAML Document 写回,保留注释与排版;路径段为纯数字时按数组下标处理(如 ["platforms",0,"keys",1,"models",0])。
// append:向目标数组追加一项(新增平台/Key/模型用);目标不存在时创建新数组。
//
// 写回时的版式处理(只作用于本次编辑写入的节点,文件其它部分原样保留):
// · 值带冒号(如模型 id "global:hy-image-3.5")强制双引号——裸写的 plain 标量换个解析器、
// 或落进 flow 集合里就容易被当成分隔符;纯 URL 例外(裸写无歧义)。
// · extra_params / thinking_params 这类小参数表用 flow 风格({k: v})写成一行,否则嵌套几层
// 展开成十几行,读起来又乱又占版面。
// · 追加整项时连同所在数组一起转 block:flow 数组里塞 block 映射会输出成残句(platforms: 后直接跟键)。
const FLOW_PARAM_KEYS = new Set(['extra_params', 'thinking_params']);
function needsQuoteStr(v) {
return typeof v === 'string' && v.includes(':') && !/^\w+:\/\/\S+$/.test(v);
}
function styleWrittenNode(node, forceBlock) {
if (!node || typeof node !== 'object') return;
if (YAML.isScalar(node)) {
if (needsQuoteStr(node.value)) node.type = 'QUOTE_DOUBLE';
return;
}
if (YAML.isMap(node)) {
if (forceBlock) node.flow = false;
for (const pair of node.items) {
const key = pair.key && pair.key.value;
const child = pair.value;
// 参数表保持 flow;内部值不再强制 block(不然 {k: {…}} 里的嵌套表会被抖开)
if (FLOW_PARAM_KEYS.has(String(key)) && child && typeof child === 'object' && !YAML.isScalar(child)) {
child.flow = true;
styleWrittenNode(child, false);
} else {
styleWrittenNode(child, forceBlock);
}
}
} else if (YAML.isSeq(node)) {
if (forceBlock) node.flow = false;
for (const item of node.items) styleWrittenNode(item, forceBlock);
}
}
function styledNode(doc, value, forceBlock) {
const node = doc.createNode(value);
if (forceBlock && node && typeof node === 'object' && !YAML.isScalar(node)) node.flow = false;
styleWrittenNode(node, forceBlock);
return node;
}
function applyEditsToText(text, edits) {
const doc = YAML.parseDocument(text || '');
for (const e of edits || []) {
if (!e || !Array.isArray(e.path) || !e.path.length) throw new Error('配置项 path 必须是非空数组');
const docPath = e.path.map(s => (typeof s === 'string' && /^\d+$/.test(s)) ? Number(s) : s);
if (e.delete) { doc.deleteIn(docPath); continue; }
if (e.append) {
const item = styledNode(doc, e.value, true);
const target = doc.getIn(docPath, true);
if (target && typeof target.add === 'function') {
target.flow = false; // 与 block 化的新项保持一致,否则父数组仍是 flow
target.add(item);
} else if (target === null || target === undefined) {
const seq = doc.createNode([]);
seq.flow = false;
seq.add(item);
doc.setIn(docPath, seq);
} else throw new Error('配置项 ' + docPath.join('.') + ' 不是数组,无法追加');
continue;
}
const node = styledNode(doc, e.value, false);
// 直接写参数键(整对象 set)时也要 flow
if (FLOW_PARAM_KEYS.has(String(docPath[docPath.length - 1])) &&
node && typeof node === 'object' && !YAML.isScalar(node)) node.flow = true;
doc.setIn(docPath, node);
}
return doc.toString();
}
// 校验通过才写盘(不合法直接抛错、不动文件)。
// 注意:不用「临时文件 + rename」原子写:容器里 config.yml 是单文件 bind mount,
// rename 替换该路径会 EBUSY;写坏风险已由“先校验后写”兑底。
function writeConfigText(cfg, text) {
const p = cfg && cfg.config_path;
if (!p) throw Object.assign(new Error('配置文件路径未知(config.yml 可能不存在),无法写入'), { status_code: 409 });
parseAndValidate(text, p);
fs.writeFileSync(p, text, 'utf8');
}
module.exports = { loadConfig, loadConfigFromText, readConfigText, applyEditsToText, writeConfigText };