Files
agent/app/server/engine.js
T
kicer 9002e471bb prompt dump 改为完整请求内容三部分,落盘 data/system-prompt.txt
- 路径按需求调整:workspace_root/system-prompt.txt(去点号,宿主机 <repo>/data/)
- 内容扩为模型实际收到的三部分(各带中文节标题注释):
  1. system 消息:模板 + 可用技能 + 语言指令
  2. tools 数组:内置 definitions.json + 启动时发现的 MCP 工具,与请求 tools 字段一致
  3. 会话上下文:首条 user 消息示例(占位会话 id + 首个启用模型渲染;实际每会话动态生成)
- engine.js 导出 sessionContextContent 供示例渲染;dump 失败仅警告不阻塞启动
2026-09-05 18:51:36 +08:00

1072 lines
51 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.
// 核心引擎:会话管理、模型池调度(FIFO)、Agent 主循环、任务目录。
// 单进程内存模型:JS 单线程 + better-sqlite3 同步 API,不存在跨进程竞争。
const fs = require('fs');
const path = require('path');
const { buildMessages, callModel, encodeBlocks } = require('./llm');
const { executeTool, resolveInTask } = require('./tools/executor');
const mcp = require('./mcp');
const log = require('./log');
const TOOL_DEFINITIONS = require('./tools/definitions.json');
const START_EXECUTION_MESSAGE =
'我说完了,你可以开始干活了。先把我上面说的需求整理成 task.md 文件写入任务目录,然后按照 task.md 开始执行。';
// 会话上下文消息标记:动态信息(日期/任务目录/模型显示名)不再拼入 system prompt,
// 而是作为首条 user 消息发给模型,跟着会话走;它不单独触发模型回合。
// 注入时机 = 模型绑定就绪:手动选择模型后立即注入;自动派发则在首次回复前注入,
// 避免未绑定模型时产生“尚未绑定/未知”占位(见 ensureSessionContext)。
const SESSION_CONTEXT_NAME = 'session_context';
let cfg, db, bus;
const runs = new Map(); // session_id -> {cancelled, procs:Set, abortController, looping:boolean}
// ---------- 小工具 ----------
const now = () => Date.now();
function genTaskId() {
const d = new Date();
const pad = n => String(n).padStart(2, '0');
const day = d.getUTCFullYear() + pad(d.getUTCMonth() + 1) + pad(d.getUTCDate());
const prefix = 'task-' + day + '-';
// 历史最大序号(防残留行碰撞)与持久计数器取大:会话删除后序号也不回退复用
let maxSeq = 0;
for (const r of db.prepare('SELECT id FROM sessions WHERE id LIKE ?').all(prefix + '%')) {
const n = parseInt(r.id.slice(prefix.length), 10);
if (n > maxSeq) maxSeq = n;
}
const key = 'task_seq:' + day;
const row = db.prepare('SELECT value FROM meta WHERE key = ?').get(key);
const stored = row ? Number(row.value) || 0 : 0;
let seq = Math.max(stored, maxSeq) + 1;
let id = prefix + String(seq).padStart(3, '0');
while (db.prepare('SELECT id FROM sessions WHERE id = ?').get(id)) {
seq++;
id = prefix + String(seq).padStart(3, '0');
}
db.prepare(
'INSERT INTO meta (key, value) VALUES (?,?) ON CONFLICT(key) DO UPDATE SET value = ?'
).run(key, String(seq), String(seq));
return id;
}
function taskDirOf(sessionId) {
return path.join(cfg.workspace_root, sessionId);
}
function getSession(sessionId) {
return db.prepare('SELECT * FROM sessions WHERE id = ?').get(sessionId);
}
function touch(sessionId, fields) {
const sets = ['updated_at = ?'];
const vals = [now()];
for (const [k, v] of Object.entries(fields || {})) {
sets.push(k + ' = ?');
vals.push(v);
}
vals.push(sessionId);
db.prepare('UPDATE sessions SET ' + sets.join(', ') + ' WHERE id = ?').run(...vals);
}
function loadHistory(sessionId) {
return db.prepare('SELECT * FROM messages WHERE session_id = ? ORDER BY id').all(sessionId);
}
function saveMessage(sessionId, msg) {
const info = db.prepare(
'INSERT INTO messages (session_id, role, content, reasoning, tool_calls, tool_call_id, name, type, is_error, created_at) VALUES (?,?,?,?,?,?,?,?,?,?)'
).run(sessionId, msg.role, msg.content || null, msg.reasoning || null,
msg.tool_calls ? JSON.stringify(msg.tool_calls) : null,
msg.tool_call_id || null, msg.name || null, msg.type || null, msg.is_error ? 1 : 0, now());
// 关键动作日志:AI 每轮回复落库(含纯工具调用轮)
if (msg.role === 'assistant') {
const calls = msg.tool_calls || [];
let toolDesc = '';
if (calls.length) {
// 按出现顺序去重,同名多次调用追加 ×N
const counts = new Map();
for (const c of calls) {
const name = (c && c.function && c.function.name) || '未知工具';
counts.set(name, (counts.get(name) || 0) + 1);
}
toolDesc = ',工具调用:' + [...counts].map(([name, n]) => (n > 1 ? name + '×' + n : name)).join('、');
}
log.info('msg', sessionId + ' AI 回复:文本 ' + String(msg.content || '').length + ' 字' + toolDesc);
}
return info.lastInsertRowid;
}
// 记录一次模型回合的 token 用量(上游未返回 usage 时跳过)。
// 写入 model_usage 表,不建会话外键:删会话后累计统计仍保留。
function recordModelUsage(sessionId, modelId, usage) {
if (!modelId || !usage) return;
const pt = usage.prompt_tokens || 0;
const ct = usage.completion_tokens || 0;
const tt = usage.total_tokens || (pt + ct);
if (!pt && !ct && !tt) return;
db.prepare(
'INSERT INTO model_usage (session_id, model_id, prompt_tokens, completion_tokens, total_tokens, created_at) VALUES (?,?,?,?,?,?)'
).run(sessionId, modelId, pt, ct, tt, now());
}
// 每模型 token 用量统计:今日(本地时区自然日起)+ 累计,输入/输出分开。
// 返回 { [model_id]: { today_prompt, today_completion, total_prompt, total_completion } },
// 配置内的模型保证有零值占位。
function modelUsageStats() {
const d = new Date();
const dayStart = new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
const stats = {};
const slot = function (id) {
if (!stats[id]) stats[id] = { today_prompt: 0, today_completion: 0, total_prompt: 0, total_completion: 0 };
return stats[id];
};
for (const m of cfg.models) slot(m.id);
const sumSql = 'SELECT model_id, SUM(prompt_tokens) AS p, SUM(completion_tokens) AS c FROM model_usage';
for (const r of db.prepare(sumSql + ' WHERE created_at >= ? GROUP BY model_id').all(dayStart)) {
slot(r.model_id).today_prompt = r.p || 0;
slot(r.model_id).today_completion = r.c || 0;
}
for (const r of db.prepare(sumSql + ' GROUP BY model_id').all()) {
slot(r.model_id).total_prompt = r.p || 0;
slot(r.model_id).total_completion = r.c || 0;
}
return stats;
}
function emitStatus(sessionId) {
const s = getSession(sessionId);
if (!s) return;
bus.emit(sessionId, 'status', {
session_id: sessionId,
status: s.status,
phase: s.phase,
model_id: s.model_id,
queue_pos: s.status === 'queued' ? queuePosition(sessionId) : null,
});
}
function queuePosition(sessionId) {
const row = db.prepare(
'SELECT queued_at FROM wait_queue WHERE session_id = ?'
).get(sessionId);
if (!row) return null;
const better = db.prepare('SELECT COUNT(*) AS c FROM wait_queue WHERE queued_at < ?').get(row.queued_at);
return better.c + 1;
}
// ---------- 模型池调度 ----------
function syncModelPool() {
const stmt = db.prepare(
'INSERT INTO model_pool (id, display_name, is_busy, current_session_id) VALUES (?,?,0,NULL) ON CONFLICT(id) DO UPDATE SET display_name=excluded.display_name'
);
// enable:false 的模型不进池:分配/绑定均按池取模型,天然跳过禁用项(与其他模型配置一致,重启生效)。
const enabled = cfg.models.filter(m => m.enable !== false);
for (const m of enabled) stmt.run(m.id, m.display_name);
// 清理配置中已删除/已禁用的模型
const ids = enabled.map(m => m.id);
for (const row of db.prepare('SELECT id FROM model_pool').all()) {
if (!ids.includes(row.id)) db.prepare('DELETE FROM model_pool WHERE id = ?').run(row.id);
}
// 进程重启后:释放所有绑定、把 active 会话退回队列;held 会话直接结版(释放)。
// 禁用模型同样走这里收尾:重启后池里已无它,绑过它的会话被退回队列/结版,后续重新分配启用中的模型。
db.prepare('UPDATE model_pool SET is_busy = 0, current_session_id = NULL').run();
db.prepare("UPDATE sessions SET status='completed', completed_at=?, held_at=NULL, model_id=NULL WHERE status='held'").run(now());
for (const s of db.prepare("SELECT id FROM sessions WHERE status = 'active'").all()) {
db.prepare("UPDATE sessions SET status='queued', model_id=NULL, updated_at=? WHERE id=?").run(now(), s.id);
enqueue(s.id);
}
// 兑底:queued 会话必须在队列中
for (const s of db.prepare("SELECT id FROM sessions WHERE status='queued'").all()) enqueue(s.id);
startHoldSweeper();
}
function freeModel() {
return db.prepare('SELECT * FROM model_pool WHERE is_busy = 0 ORDER BY id').get();
}
function modelDisplayName(modelId) {
const row = db.prepare('SELECT display_name FROM model_pool WHERE id = ?').get(modelId);
return row ? row.display_name : modelId;
}
// 会话绑定的模型是否支持 vision(图片回传);决定 read_file 读图行为(见 tools/executor.js)。
function modelVision(session) {
const m = session.model_id && (cfg.models || []).find(x => x.id === session.model_id);
return !!(m && m.vision);
}
function enqueue(sessionId) {
const exists = db.prepare('SELECT id FROM wait_queue WHERE session_id = ?').get(sessionId);
if (!exists) db.prepare('INSERT INTO wait_queue (session_id, queued_at) VALUES (?,?)').run(sessionId, now());
}
function dequeue(sessionId) {
db.prepare('DELETE FROM wait_queue WHERE session_id = ?').run(sessionId);
}
// status:绑定后的会话状态。
// - 'active'(默认):绑定即开跑(有待回应消息,紧随其后 runLoop);排队派发 dispatchQueued 用。
// - 'held':仅预留模型占位(手动选模/新建选模,尚无待回应消息),
// 用户发首条消息后由 postUserMessage 的 held 分支转 active 开跑。
function bindModel(session, model, status) {
const st = status === 'held' ? 'held' : 'active';
db.prepare('UPDATE model_pool SET is_busy = 1, current_session_id = ? WHERE id = ?').run(session.id, model.id);
// last_model_id 不随释放清除:会话再次需要模型时优先回绑(见 pickModelFor)
db.prepare("UPDATE sessions SET status=?, model_id=?, last_model_id=?, held_at=?, updated_at=? WHERE id=?")
.run(st, model.id, model.id, st === 'held' ? now() : null, now(), session.id);
}
function releaseModel(sessionId) {
db.prepare('UPDATE model_pool SET is_busy = 0, current_session_id = NULL WHERE current_session_id = ?').run(sessionId);
db.prepare('UPDATE sessions SET model_id = NULL, updated_at = ? WHERE id = ?').run(now(), sessionId);
}
// 手动为已结版/已终止的会话指定模型:选定的模型必须空闲。
// 绑上 ≠ 开跑:无待回应消息时进入 held(保持中,占用模型免排队),
// 用户发首条消息后才转 active 开跑;若有未回应消息(如终止时留下未回答的提问)
// 则直接 active 并立刻开跑。绑而不用同样受保持租约兑底(sweepHeld)。
function bindToSession(sessionId, modelId) {
const s = getSession(sessionId);
if (!s) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
if (s.status !== 'completed' && s.status !== 'cancelled') {
throw Object.assign(new Error('仅已完成/已终止的会话可手动选择模型'), { status_code: 409 });
}
const model = db.prepare('SELECT * FROM model_pool WHERE id = ? AND is_busy = 0').get(String(modelId || ''));
if (!model) throw Object.assign(new Error('模型不存在或正被占用'), { status_code: 409 });
touch(sessionId, { cancelled_at: null, completed_at: null, held_at: null });
const pending = hasPendingUser(sessionId);
bindModel(s, model, pending ? 'active' : 'held');
emitStatus(sessionId);
// 手动选好模型后立即注入/刷新会话上下文(换绑时更新为当前模型,避免陈旧信息)
ensureSessionContext(sessionId);
log.info('model', sessionId + ' 手动绑定模型 ' + model.id);
if (pending) runLoop(sessionId);
return { ok: true, model_id: model.id };
}
// 是否还有待回应的新用户消息(最后一条非 tool 消息是 user)。
// 会话上下文消息(role=user 但带 SESSION_CONTEXT_NAME 标记)不算待回应消息。
function hasPendingUser(sessionId) {
const rows = loadHistory(sessionId);
for (let i = rows.length - 1; i >= 0; i--) {
if (rows[i].role === 'tool' || rows[i].name === SESSION_CONTEXT_NAME) continue;
return rows[i].role === 'user';
}
return false;
}
// 为排队会话挑模型:上次用过的模型(last_model_id)恰好空闲则优先回绑;
// 被占用(或从未绑过/已从配置删除)则按 id 序取任意空闲模型。
function pickModelFor(session) {
if (session.last_model_id) {
const pref = db.prepare('SELECT * FROM model_pool WHERE id = ? AND is_busy = 0').get(session.last_model_id);
if (pref) return pref;
}
return freeModel();
}
// 有空闲模型就按 FIFO 派发排队会话(每会话优先回绑上次用过的模型)。
function dispatchQueued() {
for (;;) {
if (!freeModel()) return;
const head = db.prepare('SELECT session_id FROM wait_queue ORDER BY queued_at, id').get();
if (!head) return;
dequeue(head.session_id);
const session = getSession(head.session_id);
if (!session || session.status !== 'queued') continue;
// 上面已确认有空闲模型,pickModelFor 必能回退到 freeModel;
// 无待回应消息的会话(如新建后从未发言)只预留不占跑,绑成 held 等首条消息
const pending = hasPendingUser(session.id);
bindModel(session, pickModelFor(session), pending ? 'active' : 'held');
emitStatus(session.id);
if (pending) runLoop(session.id);
}
}
// ---------- 保持租约(held / active 闲置) ----------
// 回合结束后会话进入 held:继续占用模型(用户追问免排队),由 sweeper 按规则释放:
// - 页面无 SSE 观看者:超过 idle_release_ms 释放;
// - 有人观看:最长保持 active_max_ms(防止挂着页面霸占模型池)。
// 「绑定了模型但闲置」的会话(active 且无 run 在跑、无未回应消息,如新建后从未发言)
// 同样受租约管理,避免建了不用的会话无限占用模型。
function releaseHeld(sessionId) {
const s = getSession(sessionId);
if (!s || s.status !== 'held') return;
touch(sessionId, { status: 'completed', completed_at: now(), held_at: null });
releaseModel(sessionId);
bus.emit(sessionId, 'done', { status: 'completed' });
emitStatus(sessionId);
dispatchQueued();
}
// 用户主动「断开」: held 会话放弃保持租约,结版为 completed(区别于终止的 cancelled)
function releaseHold(sessionId) {
const s = getSession(sessionId);
if (!s) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
if (s.status !== 'held') throw Object.assign(new Error('会话不在保持中'), { status_code: 409 });
releaseHeld(sessionId);
return { ok: true };
}
// active 但闲置(从未发言/无未回应消息)→ 按租约释放,语义同 held 到期
function releaseIdleActive(sessionId) {
const s = getSession(sessionId);
if (!s || s.status !== 'active' || !s.model_id) return;
const run = runs.get(sessionId);
if (run && run.looping) return;
touch(sessionId, { status: 'completed', completed_at: now() });
releaseModel(sessionId);
bus.emit(sessionId, 'done', { status: 'completed' });
emitStatus(sessionId);
dispatchQueued();
}
function sweepHeld() {
const holdCfg = (cfg && cfg.model_hold) || {};
const idleMs = holdCfg.idle_release_ms || 180000;
const activeMs = holdCfg.active_max_ms || 1800000;
const t = now();
for (const s of db.prepare("SELECT * FROM sessions WHERE status='held'").all()) {
const heldSince = t - (s.held_at || s.updated_at || 0);
const present = bus.clientCount && bus.clientCount(s.id) > 0;
if (heldSince >= (present ? activeMs : idleMs)) releaseHeld(s.id);
}
// active 闲置:绑定了模型但无 run 在跑、无未回应消息(如新建后从未发言)→ 同租约释放
for (const s of db.prepare("SELECT * FROM sessions WHERE status='active' AND model_id IS NOT NULL").all()) {
const run = runs.get(s.id);
if (run && run.looping) continue;
if (hasPendingUser(s.id)) continue; // 有消息待回应,由 runLoop 处理,不动它
const idleSince = t - (s.updated_at || 0);
const present = bus.clientCount && bus.clientCount(s.id) > 0;
if (idleSince >= (present ? activeMs : idleMs)) releaseIdleActive(s.id);
}
}
let holdTimer = null;
function startHoldSweeper() {
if (holdTimer) return;
const ms = (cfg && cfg.model_hold && cfg.model_hold.sweep_ms) || 10000;
holdTimer = setInterval(sweepHeld, ms);
if (holdTimer.unref) holdTimer.unref(); // 不阻止进程退出
}
// ---------- 运行控制 ----------
function getRun(sessionId, create) {
let run = runs.get(sessionId);
if (!run && create) {
run = { cancelled: false, procs: new Set(), abortController: null, looping: false };
runs.set(sessionId, run);
}
return run;
}
// 正在执行 AI 回合(looping)的会话 id 列表:供重启保护判断。
// 注意只算「回合执行中」;active 但空闲(等用户输入)与 held 都不算,重启无损失。
function activeRuns() {
const out = [];
for (const [id, run] of runs) if (run && run.looping) out.push(id);
return out;
}
function killRunProcs(run) {
for (const proc of run.procs) {
try { process.kill(-proc.pid, 'SIGKILL'); } catch (_) {
try { proc.kill('SIGKILL'); } catch (__) {}
}
}
run.procs.clear();
}
// ---------- Agent 主循环 ----------
async function runLoop(sessionId) {
const run = getRun(sessionId, true);
if (run.looping) return; // 已有循环在跑(下一轮迭代会自动带上最新消息)
run.looping = true;
try {
await runLoopInner(sessionId, run);
} catch (err) {
log.error('engine', 'runLoop ' + sessionId + ' 异常:', err && err.stack || err);
bus.emit(sessionId, 'error', { message: String(err && err.message || err) });
} finally {
run.looping = false;
finalize(sessionId, run);
}
}
function finalize(sessionId, run) {
const s = getSession(sessionId);
if (!s || s.status !== 'active') { runs.delete(sessionId); return; }
const cancelled = run.cancelled;
if (cancelled) {
touch(sessionId, { status: 'cancelled', cancelled_at: now(), completed_at: null });
releaseModel(sessionId);
runs.delete(sessionId);
bus.emit(sessionId, 'done', { status: 'cancelled' });
emitStatus(sessionId);
dispatchQueued();
return;
}
// 正常结束:进入 held 保持租约,不释放模型,用户追问可直接复用
touch(sessionId, { status: 'held', held_at: now(), completed_at: null, cancelled_at: null });
runs.delete(sessionId);
bus.emit(sessionId, 'done', { status: 'held' });
emitStatus(sessionId);
}
async function runLoopInner(sessionId, run) {
// 能到这里说明模型已绑定:先注入/刷新会话上下文(内容随当前模型与当天日期更新)
ensureSessionContext(sessionId);
let iter = 0;
// 已纳入模型请求的最大消息 id;用于判断是否有尚未被回应的新 user 消息
// (不能用“最后一条非 tool 消息是 user”判断:流式输出期间到达的消息会排在 assistant 之前而被漏掉)
let lastIncludedId = 0;
const maxIter = cfg.agent.max_tool_iterations;
while (!run.cancelled && iter < maxIter) {
const session = getSession(sessionId);
if (!session || session.status !== 'active' || !session.model_id) break;
session.history = loadHistoryForModel(sessionId);
for (const m of session.history) if (m.id > lastIncludedId) lastIncludedId = m.id;
const messages = buildMessages(session, (cfg.agent || {}).language);
// 内置工具 + 启动时发现的 MCP 工具,一起随 system prompt 发给模型
const tools = TOOL_DEFINITIONS.concat(mcp.toolDefinitions());
let result = null;
let lastErr = null;
for (let attempt = 0; attempt <= cfg.agent.max_retries && !run.cancelled; attempt++) {
try {
result = await streamAssistant(sessionId, run, session, messages, tools);
break;
} catch (err) {
lastErr = err;
const retriable = !err.upstream_status || err.upstream_status === 429 || err.upstream_status >= 500;
if (!retriable || attempt === cfg.agent.max_retries) break;
await sleep(2000 * (attempt + 1));
}
}
if (run.cancelled) break;
if (!result) {
const text = '⚠️ 模型调用失败:' + (lastErr && lastErr.message || '未知错误');
saveMessage(sessionId, { role: 'assistant', content: text });
bus.emit(sessionId, 'assistant_message', { content: text, error: true });
break;
}
// 容错:部分模型把参数多包一层 arguments/function 外层,统一解包后再落库与执行。
// 写回历史的 tool_calls 也是解包后的干净形状,避免模型模仿自己上一轮的错误样本。
if (result.tool_calls) {
for (const tc of result.tool_calls) {
const fixed = unwrapToolArgs(tools, tc.name, tc.arguments);
if (fixed) {
log.debug('tool', sessionId + ' ' + tc.name + ' 参数包裹外层已自动解包');
tc.arguments = JSON.stringify(fixed);
}
}
}
// 保存 assistant 消息
const hasTools = result.tool_calls && result.tool_calls.length > 0;
// 参数校验预扫描:任一 tool call 结构性错误(JSON 非法/缺必填)→ 整条标 errAck。
// 该行仍入库(UI 可见可排查),但 buildMessages 发请求时连同关联 tool 回执整轮跳过,
// 改以一条 user 错误提示替代,防止模型模仿自己的坏样本反复出错死循环。
let isErrAck = false;
if (hasTools) {
for (const tc of result.tool_calls) {
if (checkToolArgs(tools, tc.name, tc.arguments).error) { isErrAck = true; break; }
}
}
const msgRow = {
role: 'assistant',
type: isErrAck ? 'errAck' : null,
content: result.content || '',
reasoning: result.reasoning || null,
tool_calls: hasTools ? result.tool_calls.map(tc => ({
// 缺 id 时补全,保证与 tool 回执落库用的 id 一致(buildMessages 按 id 配对丢弃)
id: tc.id || ('call_' + Math.random().toString(36).slice(2, 10)), type: 'function',
function: { name: tc.name, arguments: tc.arguments },
})) : null,
};
const assistantId = saveMessage(sessionId, msgRow);
if (isErrAck) log.info('msg', sessionId + ' 本轮 tool call 参数错误,assistant 标记 errAck(不再进入模型上下文)');
recordModelUsage(sessionId, session.model_id, result.usage);
// 「压缩」按钮触发的总结请求:只把压缩回合的「最终答复」(无 tool_calls 的收尾回复)标为
// is_summary;回合中间产生的 AI 回复(含工具调用轮)都是普通消息,前端照常渲染。
// 判别 = 「紧邻的上一条 user 消息是 summarize_request」,而不是「历史上出现过 summarize_request」:
// generate_only 会保留历史、指令行留在库里,旧写法会把之后每一轮的 assistant 都误标成总结。
// 该标志传到前端后,前端按用户在弹窗选的模式走后续。mode 从发起请求时记录在 run 上的 summaryMode 取(不入库)。
let isSummary = false;
if (!hasTools) {
const prevUser = db.prepare(
"SELECT type FROM messages WHERE session_id = ? AND role = 'user' AND id < ? ORDER BY id DESC LIMIT 1"
).get(sessionId, assistantId);
isSummary = !!(prevUser && prevUser.type === 'summarize_request');
}
bus.emit(sessionId, 'assistant_message', {
id: assistantId, content: msgRow.content, reasoning: msgRow.reasoning,
tool_calls: msgRow.tool_calls, type: msgRow.type,
is_summary: isSummary,
mode: isSummary ? (run.summaryMode || null) : null,
});
if (isSummary) {
// 摘要落地:不管哪种模式,这条收尾答复都在库里标成 type='summary'
//(前端重渲染成摘要卡片;也是模型上下文的起点),并把之前的消息存档:
// type='archived' 行 UI 照常展示,但 buildMessages 不再发给模型——
// 后续对话从这条摘要开始,旧历史不再烧 token。
// 两种模式的差别只在收尾:compress_and_clear 时前端另调 DELETE ?keep=summary
// 把存档行物理删除(仅留摘要);generate_only 则保留展示。
// session_context 行不存档:它是环境信息,始终随新回合发送(loadHistoryForModel 置顶)。
// 旧摘要行(多轮压缩)一并存档:被新摘要覆盖替代,不再进上下文。
run.summaryMode = null;
if ((msgRow.content || '').trim()) {
db.prepare("UPDATE messages SET type = 'summary' WHERE id = ?").run(assistantId);
const n = db.prepare(
"UPDATE messages SET type = 'archived' WHERE session_id = ? AND id < ?" +
" AND (type IS NULL OR type != 'archived') AND (name IS NULL OR name != 'session_context')"
).run(sessionId, assistantId).changes;
log.info('msg', sessionId + ' 压缩摘要 ' + assistantId + ' 落库,存档之前 ' + n + ' 条消息(不再发给模型)');
}
}
if (!hasTools) {
// 回合结束;但若期间用户又发了新消息(live 投递),继续下一轮而不是收尾
if (!hasUserSince(sessionId, lastIncludedId)) break;
continue;
}
// 执行工具
const vision = modelVision(session);
for (const tc of msgRow.tool_calls) {
if (run.cancelled) break;
const id = tc.id;
log.debug('tool', sessionId + ' 调用 ' + tc.function.name + ' 参数: ' + String(tc.function.arguments || ''));
bus.emit(sessionId, 'tool_call', { id, name: tc.function.name, arguments: tc.function.arguments });
let output;
let isError = false;
// 参数校验:解包后仍非法(JSON 不合法/缺必填)就直接挡下,绝不把 undefined 交给 shell 执行
const chk = checkToolArgs(tools, tc.function.name, tc.function.arguments);
if (chk.error) {
// 把正确形状告诉模型,替它纠正包装习惯
output = chk.error;
isError = true;
} else {
try {
output = await executeTool({ sessionId, taskDir: taskDirOf(sessionId), run, cfg, db, vision },
tc.function.name, chk.args);
} catch (err) {
output = 'Error: ' + (err && err.message || String(err));
isError = true;
}
}
// 工具可返回 {text, image_data_url}(read_file 读图且模型支持 vision):
// 落库时把图片以 image_url 内容块拼进 tool 消息(哨兵 JSON,见 llm.js encodeBlocks),
// buildMessages 发请求前还原为 OpenAI 内容块数组。
let outText;
let imageDataUrl = null;
if (output && typeof output === 'object' && output.image_data_url) {
outText = String(output.text || '');
imageDataUrl = String(output.image_data_url);
} else {
outText = String(output == null ? '' : output);
}
if (run.cancelled && !isError) outText = (outText ? outText + '\n' : '') + '(用户已终止任务)';
log.debug('tool', sessionId + ' ' + tc.function.name + (isError ? ' 失败: ' : ' 完成: ') + outText);
const toolContent = imageDataUrl
? encodeBlocks([
{ type: 'text', text: outText },
{ type: 'image_url', image_url: { url: imageDataUrl } },
])
: outText;
// 先落库再广播:回执带上消息行 id(msg_id),前端工具卡据此挂「删除本条」按钮
const toolMsgId = saveMessage(sessionId, { role: 'tool', tool_call_id: id, name: tc.function.name, content: toolContent, is_error: isError });
bus.emit(sessionId, 'tool_result', {
tool_call_id: id, name: tc.function.name, content: outText.slice(0, 20000),
is_error: isError, image_url: imageDataUrl || undefined, msg_id: toolMsgId,
});
}
iter++;
}
if (iter >= maxIter && !run.cancelled) {
const text = '⚠️ 已达到最大工具迭代次数(' + maxIter + '),自动停止。可继续输入让我接着干。';
saveMessage(sessionId, { role: 'assistant', content: text });
bus.emit(sessionId, 'assistant_message', { content: text });
}
}
// 解析单条 SSE meta 行(按第一个 ':' 切 k,v 分发),构造回调供 streamAssistant 使用。
// 状态 last_id / retry_time 跨多次调用保持(一次 streamAssistant 内),便于后续关联。
// 分发规则(来自 SSE 调试日志规范):
// id → last_id = v (静默)
// retry → retry_time = v (静默)
// event → log.debug event 名 (如 'event: error')
// k='' && v='ping' → 当作 event=ping,debug 打
// k='' 其他 → 注释行(如 :keep-alive),debug 打
// 其它 → 未知字段,debug 打原行
function makeSseMetaHandler(sessionId) {
let last_id = null;
let retry_time = null;
return function handleSseMeta(line) {
const t = line.trim();
const i = t.indexOf(':');
const k = i < 0 ? t : t.slice(0, i);
const v = i < 0 ? '' : t.slice(i + 1).trim();
if (k === 'id') {
last_id = v;
} else if (k === 'retry') {
retry_time = v;
} else if (k === 'event') {
log.debug('sse', sessionId + ' event: ' + v);
} else if (k === '' && v === 'ping') {
log.debug('sse', sessionId + ' event: ' + v);
} else if (k === '') {
log.debug('sse', sessionId + ' comment: ' + v);
} else {
log.debug('sse', sessionId + ' meta: ' + line);
}
};
}
// 流式接收 assistant 输出并转发 SSE。返回 callModel 结果。
async function streamAssistant(sessionId, run, session, messages, tools) {
run.abortController = new AbortController();
try {
const handleSseMeta = makeSseMetaHandler(sessionId);
const result = await callModel(cfg, session.model_id, messages, tools, {
signal: run.abortController.signal,
shouldCancel: () => run.cancelled,
onText: delta => bus.emit(sessionId, 'assistant_delta', { text: delta }),
onReasoning: delta => bus.emit(sessionId, 'reasoning_delta', { text: delta }),
// 本轮是否启用深度思考;由 postUserMessage 从消息 POST 参数写进 run
deepThink: !!run.deepThink,
onMeta: handleSseMeta,
onBadData: raw => log.warn('sse', sessionId + ' 坏帧:' + raw.slice(0, 200)),
// data 解析成功但没有 choices(如 event: error 帧):上游发了非正常响应,
// 之前会伪装成"0 字"沉默忽略,这里 warn 把原始 evt 打出来便于定位。
onBadEvent: evt => log.warn('sse', sessionId + ' 上游错误帧:' + JSON.stringify(evt).slice(0, 500)),
});
// 本轮上游响应总览:帧数 + 文本长度 + 工具调用 + finish + aborted。
// sseFrames=0 且 aborted=false 表示上游未发任何 data(疑似流异常);其他情况可快速区分
// “上游发了一堆帧但 content 为空” 与 “根本没调用成功”。
log.info('sse', sessionId + ' 本轮汇总:帧 ' + (result && result.sseFrames || 0) +
',finish=' + (result && result.finish_reason || '-') +
',aborted=' + (result && result.aborted || false));
return result;
} finally {
run.abortController = null;
}
}
function hasUserSince(sessionId, sinceId) {
const r = db.prepare(
"SELECT COUNT(*) AS c FROM messages WHERE session_id = ? AND role = 'user' AND id > ? AND (name IS NULL OR name <> ?)"
).get(sessionId, sinceId, SESSION_CONTEXT_NAME);
return r.c > 0;
}
// 校验工具调用参数,返回 { args, error }。error 非空 = 结构性错误(JSON 非法/缺必填):
// 执行挡下,且整条 assistant 标 errAck,发请求时整轮移出模型上下文(见 llm.buildMessages),
// 防止模型模仿自己的坏样本反复出错死循环。args 为空串视为空对象(无参工具正常执行)。
function checkToolArgs(tools, name, raw) {
const s = String(raw == null ? '' : raw).trim();
let args;
if (!s) args = {};
else {
try { args = JSON.parse(s); }
catch (_) {
return { args: null, error: 'Error: Invalid tool call arguments (not valid JSON).' };
}
}
const def = (tools || []).find(t => t && t.function && t.function.name === name);
const required = def && def.function.parameters && def.function.parameters.required;
const missing = required && required.length
? required.filter(k => args[k] === undefined || args[k] === '') : [];
if (missing.length) return { args: null, error: 'Error: ToolCall Missing Params: ' + missing.join('、') };
return { args, error: null };
}
function toolSchemaOf(tools, name) {
for (const t of tools || []) if (t && t.function && t.function.name === name) return t.function.parameters || null;
return null;
}
// 部分弱模型会把工具参数多包一层外层({"arguments":{...}} 甚至多层/信封形),
// 这里按工具 schema 剥回顶层载荷。返回解包后的对象;无包裹或解析失败返回 null(保留原样)。
function unwrapToolArgs(tools, name, raw) {
const schema = toolSchemaOf(tools, name);
let cur = raw;
let changed = false;
for (let i = 0; i < 5 && cur != null; i++) {
if (typeof cur === 'string') {
try { cur = JSON.parse(cur); changed = true; } catch (_) { return null; }
continue;
}
if (typeof cur !== 'object' || Array.isArray(cur)) return null;
const keys = Object.keys(cur);
const hasArgProp = !!(schema && schema.properties && schema.properties.arguments);
let inner = null;
// {"arguments": {...}} / {"parameters": {...}}:仅当该键不是工具自身的参数名
if (!hasArgProp && keys.length === 1 && (keys[0] === 'arguments' || keys[0] === 'parameters')
&& cur[keys[0]] && typeof cur[keys[0]] === 'object') {
inner = cur[keys[0]];
}
// {"function": {...}} 信封
if (!inner && keys.length === 1 && keys[0] === 'function' && cur.function && typeof cur.function === 'object') inner = cur.function;
// {"name": "...", "arguments": {...}} 信封
if (!inner && !hasArgProp && cur.arguments && typeof cur.arguments === 'object') inner = cur.arguments;
if (!inner) break;
cur = inner;
changed = true;
}
if (typeof cur === 'string') { try { cur = JSON.parse(cur); changed = true; } catch (_) { return null; } }
if (!changed || !cur || typeof cur !== 'object' || Array.isArray(cur)) return null;
return cur;
}
function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
// ---------- 对外 API ----------
// 会话上下文动态信息:作为首条 user 消息发给模型(同时展示在聊天里),跟会话走;
// 在模型绑定就绪后注入/刷新(ensureSessionContext),不随未绑定会话提前产生。
function sessionContextContent(session) {
const d = new Date();
const pad = n => String(n).padStart(2, '0');
const dateStr = d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate());
const model = session.model_id
? modelDisplayName(session.model_id)
: '尚未绑定(排队中,绑定后自动开始处理)';
// vision 能力随会话上下文告知 AI:支持时 read_file 读图会回传图片内容,不支持时只能拿到文件信息
const bound = session.model_id && cfg.models.find(m => m.id === session.model_id);
const visionLine = bound
? (bound.vision ? '支持(read_file 读图会返回压缩后的图片内容)' : '不支持(read_file 读图只能拿到文件信息)')
: '未知';
return [
'【会话上下文】由系统自动注入,无需回复本消息',
'- 当前日期:' + dateStr,
'- 任务目录:' + taskDirOf(session.id),
'- 当前模型:' + model,
'- 图片(vision):' + visionLine,
].join('\n');
}
// 让会话恰好保有一条反映「当前绑定模型/当天日期」的会话上下文消息:
// - 未绑定模型时不注入(避免产生“尚未绑定(排队中…)/未知”这类占位信息);
// - 已有则就地更新内容(换绑模型或跨天后保持准确,id 与位置不变);
// - 没有则补一条(存储位置无严格要求:发给模型前统一置顶,见 loadHistoryForModel)。
function ensureSessionContext(sessionId) {
const s = getSession(sessionId);
if (!s || !s.model_id) return;
const content = sessionContextContent(s);
const rows = loadHistory(sessionId);
let ctxIdx = -1;
for (let i = rows.length - 1; i >= 0; i--) {
if (rows[i].name === SESSION_CONTEXT_NAME) { ctxIdx = i; break; }
}
if (ctxIdx >= 0) {
const row = rows[ctxIdx];
if (row.content !== content) {
db.prepare('UPDATE messages SET content = ?, created_at = ? WHERE id = ?')
.run(content, now(), row.id);
}
return;
}
saveMessage(sessionId, { role: 'user', name: SESSION_CONTEXT_NAME, content });
}
// 加载给模型看的历史:会话上下文消息固定放最前(只保留最新一条),
// 避免它落在真实用户消息之后、或残留旧上下文时误导模型。
function loadHistoryForModel(sessionId) {
const rows = loadHistory(sessionId);
const ctxRows = rows.filter(r => r.name === SESSION_CONTEXT_NAME);
if (!ctxRows.length) return rows;
return [ctxRows[ctxRows.length - 1]]
.concat(rows.filter(r => r.name !== SESSION_CONTEXT_NAME));
}
function createSession(title, preferModelId, assistantType, user) {
const id = genTaskId();
const dir = taskDirOf(id);
fs.mkdirSync(dir, { recursive: true });
db.prepare(
"INSERT INTO sessions (id, title, status, phase, model_id, assistant_type, user, created_at, updated_at) VALUES (?,?,'queued','planning',NULL,?,?,?,?)"
).run(id, title || '', assistantType || 'secretary', user || '', now(), now());
// 指定了模型且它恰好空闲 → 直接绑定,跳过排队;否则回退到 FIFO 队列
const prefer = preferModelId
? db.prepare('SELECT * FROM model_pool WHERE id = ? AND is_busy = 0').get(preferModelId)
: null;
if (prefer) {
// 新建时指定模型 = 仅预留(此时还没有任何消息):先绑成 held 占住模型,
// 用户发首条消息后再转 active 开跑
bindModel(getSession(id), prefer, 'held');
emitStatus(id);
} else {
enqueue(id);
dispatchQueued();
}
// 已绑定模型(选中的空闲模型 / 自动派发立即拿到模型)才注入会话上下文;
// 仍在排队未绑定时不注入占位消息,等绑定后由 ensureSessionContext 补上。
const session = getSession(id);
ensureSessionContext(id);
return session;
}
// 用户消息(或“开始执行”的模板消息)入口。
// opts.deepThink: true 时启用深度思考;参数会记在会话 run 上,
// 正在跑的回合下一轮迭代会取到最新值。新建会话需在 runLoop 之前先预建 run 以携带该值。
function postUserMessage(sessionId, content, opts) {
const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
// opts.type: 落库时给该 user 消息带上 type 标记。
// 用于「压缩」按钮触发时给总结指令打 type='summarize_request':该指令只在压缩回合内发给模型
//(回合完成后 llm.buildMessages 不再携带,防旧指令污染后续轮次),
// 并让 runLoopInner 识别到后给对应的 assistant_message SSE 加 is_summary: true 标志。
const messageId = saveMessage(sessionId, { role: 'user', content, type: (opts && opts.type) || null });
if (!session.title) {
touch(sessionId, { title: content.slice(0, 24) });
}
// 预建/更新 run 记录,记下本轮的 deepThink(被 runLoop / callModel 读取)
const run = getRun(sessionId, true);
run.deepThink = !!(opts && opts.deepThink);
// opts.mode 仅用于「压缩」总结:runLoopInner 在 emit assistant_message 时带上 mode,
// 让前端在收到 AI 总结时知道该走 generate_only 还是 compress_and_clear 后续流程。
// mode 不入库 messages.type(它是 session 级别上下文,不属于某条消息的属性)。
run.summaryMode = (opts && opts.type === 'summarize_request') ? (opts.mode || null) : (run.summaryMode || null);
if (session.status === 'active' && run.looping) {
// 正在跑:下一轮迭代会从 DB 重新加载历史,自动带上这条消息
return { message_id: messageId, delivered: 'live' };
}
if (session.status === 'held') {
// 保持租约期内:直接复用当前绑定的模型,无需排队
touch(sessionId, { status: 'active', held_at: null });
emitStatus(sessionId);
runLoop(sessionId);
return { message_id: messageId, delivered: 'live' };
}
if (session.status === 'active' && !run.looping) {
runLoop(sessionId);
return { message_id: messageId, delivered: 'live' };
}
// 排队 / 已完成 / 已取消 → 重新入队;若派发后已立即拿到空闲模型,则算直接送达
touch(sessionId, { status: 'queued', cancelled_at: null, completed_at: null, held_at: null });
enqueue(sessionId);
dispatchQueued();
const after = getSession(sessionId);
emitStatus(sessionId);
return { message_id: messageId, delivered: after && after.status === 'active' ? 'live' : 'queued' };
}
function startExecution(sessionId) {
const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
touch(sessionId, { phase: 'execution' });
const ret = postUserMessage(sessionId, START_EXECUTION_MESSAGE);
bus.emit(sessionId, 'phase', { phase: 'execution' });
return ret;
}
function stop(sessionId) {
const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
const run = runs.get(sessionId);
if (run) {
run.cancelled = true;
killRunProcs(run);
if (run.abortController) { try { run.abortController.abort(); } catch (_) {} }
}
dequeue(sessionId);
if (session.status === 'active') {
// run 在循环退出处会 finalize;若无循环在跑则直接收尾
if (!run || !run.looping) {
touch(sessionId, { status: 'cancelled', cancelled_at: now(), held_at: null });
releaseModel(sessionId);
runs.delete(sessionId);
bus.emit(sessionId, 'done', { status: 'cancelled' });
}
} else {
touch(sessionId, { status: 'cancelled', cancelled_at: now(), model_id: null, held_at: null, completed_at: null });
releaseModel(sessionId); // held 会话同时释放模型保持租约
}
emitStatus(sessionId);
dispatchQueued();
return { ok: true };
}
// 重命名会话:标题必填,最长 100 字。
function renameSession(sessionId, title) {
const s = getSession(sessionId);
if (!s) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
const t = String(title || '').trim();
if (!t) throw Object.assign(new Error('名称不能为空'), { status_code: 400 });
if (t.length > 100) throw Object.assign(new Error('名称不能超过 100 字'), { status_code: 400 });
touch(sessionId, { title: t });
log.info('task', sessionId + ' 重命名为「' + t + '」');
return { ok: true, title: t };
}
function deleteSession(sessionId, deleteDir) {
const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
stop(sessionId);
db.prepare('DELETE FROM messages WHERE session_id = ?').run(sessionId);
db.prepare('DELETE FROM files WHERE session_id = ?').run(sessionId);
db.prepare('DELETE FROM wait_queue WHERE session_id = ?').run(sessionId);
db.prepare('DELETE FROM sessions WHERE id = ?').run(sessionId);
if (deleteDir) {
try { fs.rmSync(taskDirOf(sessionId), { recursive: true, force: true }); } catch (_) {}
}
bus.closeAll(sessionId);
return { ok: true };
}
// 上下文压缩:phase-bar「压缩」按钮触发。把 config.yml 的 compress.prompt 作为一条 type='summarize_request'
// 的 user 消息发出去,AI 收到后会基于历史生成总结并以 assistant 消息回复。
// llm.js 规则:type='summarize_request' 的指令只在压缩回合进行中发给模型(回合完成后跳过),
// 既保证 AI 拿得到总结指令,又不会在后续请求里反复污染上下文。
// 由 runLoopInner 在压缩回合的最终答复(无 tool_calls 且紧邻上一条 user 是 summarize_request)
// emit 时带 is_summary: true,并带上 mode 给前端,前端按用户选择的模式走完最后一步
//(compress_and_clear 时调 DELETE ?keep=summary 清空历史、仅留该摘要并标 type='summary')。
// 两种模式收尾都一样先落库:摘要行标 type='summary',它之前的全部消息标 type='archived'
//(UI 保留展示、不再发给模型,后续对话从摘要开始);区别只在 compress_and_clear 额外物理删除。
// 限制:与 clearSessionMessages 类似——会话执行中(active)禁止操作,避免和正在跑的回合抢上下文。
// mode: 'generate_only' 或 'compress_and_clear',由路由校验后传入。
// 响应回显 prompt:前端「开始压缩后直接把压缩指令渲染成一条普通用户消息气泡」,无需再拉配置。
function summarizeContext(sessionId, mode) {
const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
const run = runs.get(sessionId);
if (run && run.looping) {
throw Object.assign(new Error('任务正在执行,请先「终止」再压缩'), { status_code: 409 });
}
const prompt = cfg && cfg.compress && cfg.compress.prompt;
if (!prompt) throw Object.assign(new Error('配置缺少 compress.prompt,请检查 config.yml'), { status_code: 500 });
// 复用 postUserMessage:opts.type='summarize_request' 给该消息打标,
// opts.mode 用于 runLoopInner SSE 带 mode 返回给前端。
const r = postUserMessage(sessionId, prompt, { type: 'summarize_request', mode });
return Object.assign({ prompt }, r);
}
// 清空会话的对话内容:删除该会话的全部消息记录,但保留会话本身与任务目录文件。
// 状态收尾为 completed(释放模型占用、移出等待队列);此后再次发言从零开始,
// 不再携带旧历史。执行中的会话不允许清空,需先「终止」。
// 清空后不自动重建会话上下文:此时通常未绑定模型,预置只会产生“尚未绑定/未知”占位。
// 待用户选择模型(bindToSession)或再次发言并自动绑定模型(runLoop 入口)时,
// 由 ensureSessionContext 注入当时的有效信息。
// opts.keepSummary=true(「压缩总结」收尾用):不物理清空,只保留最后一条 assistant 总结消息,
// 并给它打 type='summary' 标记(前端重渲染成摘要卡片;buildMessages 正常携带它作为上下文起点)。
function clearSessionMessages(sessionId, opts) {
const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
const run = runs.get(sessionId);
if (run && run.looping) {
throw Object.assign(new Error('任务正在执行,请先「终止」再清空'), { status_code: 409 });
}
if (run) {
run.cancelled = true;
killRunProcs(run);
if (run.abortController) { try { run.abortController.abort(); } catch (_) {} }
}
runs.delete(sessionId);
dequeue(sessionId);
releaseModel(sessionId);
const lastSummary = opts && opts.keepSummary ? db.prepare(
"SELECT id FROM messages WHERE session_id = ? AND role = 'assistant' ORDER BY id DESC LIMIT 1"
).get(sessionId) : null;
if (lastSummary) {
// 保留总结行,其余(含 summarize_request 指令、中间工具轮)全部删除
db.prepare('DELETE FROM messages WHERE session_id = ? AND id != ?').run(sessionId, lastSummary.id);
db.prepare("UPDATE messages SET type = 'summary' WHERE id = ?").run(lastSummary.id);
} else {
db.prepare('DELETE FROM messages WHERE session_id = ?').run(sessionId);
}
touch(sessionId, { status: 'completed', completed_at: now(), cancelled_at: null, held_at: null });
bus.emit(sessionId, 'done', { status: 'completed' });
emitStatus(sessionId);
dispatchQueued();
return { ok: true };
}
// 删除单条消息(含工具/任务消息):消息行直接从库里消失,下次模型请求的历史里就没有它了(buildMessages 只看库)。
// assistant 带 tool_calls 时连带删掉该轮的 tool 回执:只删 assistant 会留下无 tool_call 配对的
// 孤儿 tool 行,上游会拒收整个请求。单删 tool 回执则反向配对:把它在父 assistant 的
// tool_calls 里同步摘除(见 deleteToolMessage),保证「调用↔回执」始终成对。
function deleteMessage(sessionId, messageId) {
const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
const row = db.prepare('SELECT * FROM messages WHERE id = ? AND session_id = ?').get(messageId, sessionId);
if (!row) throw Object.assign(new Error('消息不存在'), { status_code: 404 });
if (row.role === 'tool') return deleteToolMessage(sessionId, row);
let removed = 0;
if (row.tool_calls) {
let calls = [];
try { calls = JSON.parse(row.tool_calls) || []; } catch (_) {}
for (const c of calls) {
if (!c || !c.id) continue;
removed += db.prepare("DELETE FROM messages WHERE session_id = ? AND role = 'tool' AND tool_call_id = ?")
.run(sessionId, c.id).changes;
}
}
db.prepare('DELETE FROM messages WHERE id = ?').run(messageId);
return { ok: true, id: messageId, removed: removed + 1 };
}
// 删工具回执(任务执行卡片):同步把对应 tool_call 从父 assistant 的 tool_calls 里摘掉,
// 避免留下「有调用无结果」被严格上游拒收。父回合若是纯工具调用轮(无文本)且已无
// 其余调用,则整行一起删(空气泡没有意义);有文本则保留为普通文本回复。
// tool_call_id 全局唯一,LIKE 只是初筛,命中后按 JSON 精确确认。
function deleteToolMessage(sessionId, row) {
db.prepare('DELETE FROM messages WHERE id = ?').run(row.id);
let removed = 1;
const parents = db.prepare(
"SELECT id, content, tool_calls FROM messages WHERE session_id = ? AND role = 'assistant' AND tool_calls LIKE ? ORDER BY id DESC"
).all(sessionId, '%' + row.tool_call_id + '%');
for (const p of parents) {
let calls = [];
try { calls = JSON.parse(p.tool_calls) || []; } catch (_) { continue; }
const left = calls.filter(c => c && c.id !== row.tool_call_id);
if (left.length === calls.length) continue; // LIKE 误中,不是这条
if (!left.length && !(p.content || '').trim()) {
db.prepare('DELETE FROM messages WHERE id = ?').run(p.id);
removed++;
} else if (!left.length) {
db.prepare('UPDATE messages SET tool_calls = NULL WHERE id = ?').run(p.id);
} else {
db.prepare('UPDATE messages SET tool_calls = ? WHERE id = ?').run(JSON.stringify(left), p.id);
}
break; // id 唯一,命中即止
}
return { ok: true, id: row.id, removed };
}
function setModelPool(cfg_, db_, bus_) { cfg = cfg_; db = db_; bus = bus_; }
module.exports = {
setModelPool: setModelPool,
init: syncModelPool,
getDb: () => db,
getBus: () => bus,
getConfig: () => cfg,
activeRuns,
createSession,
postUserMessage,
startExecution,
stop,
releaseHold,
renameSession,
deleteSession,
clearSessionMessages,
summarizeContext,
deleteMessage,
getSession,
getRun,
taskDirOf,
loadHistory,
saveMessage,
queuePosition,
modelDisplayName,
sessionContextContent,
recordModelUsage,
modelUsageStats,
dispatchQueued,
bindToSession,
TOOL_DEFINITIONS,
START_EXECUTION_MESSAGE,
};