From 2e220d0a220a10f32ec489b1c78dd4237b712d1a Mon Sep 17 00:00:00 2001 From: kicer Date: Sun, 25 Oct 2026 22:44:02 +0800 Subject: [PATCH] =?UTF-8?q?=E8=BF=90=E8=A1=8C=E4=B8=AD=E5=8F=91=E9=80=81?= =?UTF-8?q?=E6=94=B9=E4=B8=BA=E5=BE=85=E5=8F=91=E9=80=81=E6=9D=A1=E5=B9=85?= =?UTF-8?q?=EF=BC=9A=E6=8E=92=E9=98=9F=20/=20=E5=B9=B2=E9=A2=84=20/=20?= =?UTF-8?q?=E7=AB=8B=E5=8D=B3=E5=8F=91=E9=80=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 运行中点发送不再立即插话,改为进服务端队列(engine.pendings,内存态), 输入框上方一行条幅:默认本轮结束后发出,队首可「干预」(当前工具跑完就插话) 或「立即发送」(终止本轮工具调用并立刻发)。队列在服务端,关页面/重连不丢。 - 新增 closeToolBatch():给未闭合批次里缺回执的 tool_call 补合成回执, 取消/干预/finalize 兜底三处调用;顺带修掉「中途停止后库里留孤儿 tool_calls、 下一轮请求被上游拒收」的存量 bug。 - llm.buildMessages 加读侧配对过滤(pairedByAssistant / emittedCallIds): 只下发本批确有回执的调用,孤儿回执也不下发,兜历史脏数据,DB/UI 不动。 - HTTP:POST /messages 支持 delivery:'queue';新增 POST/DELETE /pending/:qid; 会话详情与 status 事件带 pending。 - 前端:条幅渲染与动作、pending_added/pending_removed/user_message 事件、 硬中断后工具卡标「已取消」;发送始终交服务端判定,避免过期状态把 user 行 插进工具批次中间。 - 文档:app/AGENTS.md 补生命周期、SSE 事件清单与待投递队列语义。 --- AGENTS.md | 2 +- README.md | 1 + app/AGENTS.md | 34 ++++- app/server/engine.js | 248 +++++++++++++++++++++++++++++-- app/server/llm.js | 46 +++++- app/server/public/css/style.css | 21 +++ app/server/public/index.html | 5 +- app/server/public/js/chat.js | 2 + app/server/public/js/core.js | 1 + app/server/public/js/sessions.js | 10 +- app/server/public/js/stream.js | 112 +++++++++++++- app/server/routes/messages.js | 29 ++++ app/server/routes/sessions.js | 2 + 13 files changed, 488 insertions(+), 25 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 3ecfead..4e81594 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -111,7 +111,7 @@ flowchart TD ## 全局约束(改之前先读) -1. **单实例、单进程内存态**。`engine.js` 的 `runs`/`titling`、`wechat.js` 的回合投递状态与实例缓存、 +1. **单实例、单进程内存态**。`engine.js` 的 `runs`/`titling`/`pendings`(待投递消息队列)、`wechat.js` 的回合投递状态与实例缓存、 `publicFiles` 的短链表、`download-token` 的随机密钥都在进程内——重启即清空,多实例不共享。 (微信投递游标 `last_msg_id` 例外,它是落库的。)不要引入需要跨进程一致性的设计。 2. **配置冷加载**。`config.js` 的 `DEFAULTS` 在启动时 deep-merge 并校验;改 `config.yml` 后必须 diff --git a/README.md b/README.md index 074346d..9c0a132 100644 --- a/README.md +++ b/README.md @@ -20,6 +20,7 @@ | 隔离执行 | `terminal` 和技能在 `agent-executor` 容器中运行,只看到当前会话目录,根文件系统只读 | | 大文件交付 | 文件面板上传/下载/打包 zip;外部服务取图走带过期时间的公网短链 | | 上下文管理 | 手动压缩、按 token 阈值提示压缩、历史重放自动裁剪、会话标题自动生成 | +| 回合中投递 | 运行中发的消息先进输入框上方的待发送条幅:默认等本轮结束自动发出;可「干预」(当前工具跑完就插话)或「立即发送」(终止本轮并立刻发)。队列在服务端,关页面不丢 | | 定时任务 | 每会话最多一个 cron 任务;触发前清空模型可见历史,按计划执行并推送结果 | | 微信接入 | 扫码绑定个人微信,文本/图片/视频/文件进入同一套会话与命令体系 | | 语音输入 | 输入框为空时发送键变麦克风:点一下进入语音模式,输入框位置变成「按住 说话」,松开即转写并直接发送;发送键位置变键盘按钮可切回打字。套壳 App 走原生录音(http 页面也能用),浏览器走 MediaRecorder(需 HTTPS);识别在 `mcp_asr`,不经过模型、不消耗 token | diff --git a/app/AGENTS.md b/app/AGENTS.md index 98274e0..cc54329 100644 --- a/app/AGENTS.md +++ b/app/AGENTS.md @@ -79,18 +79,48 @@ POST /api/sessions/:id/messages checkToolArgs:JSON 非法/缺必填 → 整条 assistant 标 type='errAck' saveMessage(assistant) + recordModelUsage 压缩回合的收尾答复 → type='summary',之前全部消息 → type='archived' - 无 tool_calls → 若期间又有新 user 消息则继续,否则收尾 + 无 tool_calls → 待投递里有「干预」则投递并继续;否则若有新 user 消息继续,否则收尾 有 tool_calls → 逐个 executeTool → saveMessage(tool) → emit tool_result + (每步之后与整批之前各查一次「干预」,命中就先闭合批次再投递) → finalize + closeToolBatch(兜底:补齐本批未执行调用的合成回执) cancelled → status=cancelled 正常 → status=held,emit done,maybeGenerateTitle,run.taskWrap → taskClockOut + 收尾后若队列非空 → setImmediate 投递队首(排队模式的唯一出口) → maybeAutoCompress(回合彻底结束后才检查) ``` **给前端的是 SSE 事件,不是响应体**。前端在 `GET /api/sessions/:id/stream` 上听: `status`、`assistant_delta`、`reasoning_delta`、`tool_call_start`、`tool_call_args`、 `tool_call`、`tool_result`、`assistant_message`、`done`、`error`、`title`、`auto_compress`、 -`ui_card`,以及每 15s 的具名心跳 `ping`(注释帧不触发 JS 事件,所以用具名事件做前端看门狗)。 +`ui_card`、`pending_added`、`pending_removed`、`user_message`,以及每 15s 的具名心跳 `ping` +(注释帧不触发 JS 事件,所以用具名事件做前端看门狗)。 + +## 待投递消息(排队 / 干预 / 立即发送) + +回合正在跑时,Web 端发送不再「立即插话」,而是进**服务端队列**(`engine.js` 的 `pendings`, +进程内内存态,同 `runs`,重启即丢):输入框上方出现一行条幅,默认等本轮结束自动发出。 + +| 模式 | 入口 | 行为 | +|---|---|---| +| `queue`(默认) | 运行中点发送 | 本轮 `finalize` 后作为新回合的第一条消息发出 | +| `interject`(干预) | 条幅「干预」 | 当前工具跑完(或本条回复落库)后,闭合批次、就地插话,同一回合继续 | +| `now`(立即发送) | 条幅「立即发送」 | 杀进程 + abort 流,本回合判 `cancelled`,收尾后立刻发 | + +**铁律:队列里的消息绝不先落 `messages` 表。** 只在安全边界写库——① 工具批次闭合 +(本批每个 `tool_call_id` 都有回执);② 无 `tool_calls` 的回复已落库;③ 回合 finalize。 +否则 `user` 行会夹在 `assistant.tool_calls` 与 `tool` 回执之间,或批次没闭合就收尾, +上游一律拒收整个请求。 + +- `closeToolBatch(sessionId, reason)` 是配对兜底的唯一写入口:给最后一条带 `tool_calls` 的 + assistant 里缺回执的调用补一条 `is_error=1` 的合成 tool 行(「用户介入/终止,本次调用未执行」)。 + `finalize` 无条件调一次,取消路径与干预路径各调一次。 +- 读侧还有一层纯过滤(`llm.buildMessages` 的 `pairedByAssistant` / `emittedCallIds`):只下发 + 「本批(紧邻的连续 tool 行)确有回执」的调用,孤儿回执也不下发。DB/UI 不动,专门兜历史脏数据。 +- `stop()`(用户点「停止」)**会清空队列**(全停语义);「立即发送」不走 `stop`,只中断当前回合、保留队首。 +- 只允许升级**队首**(`promotePending` 对非队首回 409),避免「越过后面的消息先发」。 +- HTTP:`POST /messages` 的 `delivery:'queue'`;`POST /pending/:qid {action}`;`DELETE /pending/:qid`; + 会话详情响应带 `pending`,`status` 事件也带 `pending`(前端把条幅当服务端状态的回显)。 ## 会话状态机 diff --git a/app/server/engine.js b/app/server/engine.js index c1b0502..342632e 100644 --- a/app/server/engine.js +++ b/app/server/engine.js @@ -16,6 +16,13 @@ const TOOL_DEFINITIONS = require('./tools/definitions.json'); let cfg, db, bus; const runs = new Map(); // session_id -> {cancelled, procs:Set, abortController, looping:boolean} const titling = new Set(); // 正在生成标题的会话(防重入;标题落库后靠 title 非空自然不再触发) +// 待投递消息队列:session_id -> [{id, content, deepThink, mode, created_at}] +// 铁律:队列里的消息**绝不先落 messages 表**,只在「安全边界」写入并成为模型下一轮输入: +// ① 工具批次闭合(本批每个 tool_call_id 都有回执);② 无 tool_calls 的回复已落库; +// ③ 回合 finalize(循环已退、没有在跑的工具)。 +// 原因:tool 回执必须紧跟带 tool_calls 的 assistant,user 行插进批次中间、或批次没闭合就收尾, +// 都会让上游拒收整个请求(tool_call 配对)。进程内内存态(同 runs),重启即丢,不跨实例共享。 +const pendings = new Map(); // ---------- 小工具 ---------- const now = () => Date.now(); @@ -142,6 +149,8 @@ function emitStatus(sessionId) { session_id: sessionId, status: s.status, model_id: s.model_id, + // 待投递队列一并带上:前端把条幅当成服务端状态的回显,重连/换设备后自动对齐 + pending: listPending(sessionId), }); } @@ -456,6 +465,46 @@ function killRunProcs(run) { run.procs.clear(); } +// 关闭当前工具批次:给「最后一条带 tool_calls 的 assistant」里还没有回执的调用补合成 tool 行。 +// 上游硬约束:assistant.tool_calls 必须逐个配 tool 消息,缺一条整个请求被拒(400)。 +// 触发点:取消(含「立即发送」硬中断)、干预跳过同批剩余调用、finalize 兜底(异常退出)。 +// 只在批次尾部补:若最后一条非 tool 行已经是 user(历史遗留脏数据、user 插在批次中间), +// 补在后面会造成顺序错乱,交给 llm.buildMessages 的读侧配对过滤处理。 +// reason 是一句以冒号结尾的前缀,拼成模型能读懂的「为什么没执行」。 +function closeToolBatch(sessionId, reason) { + // 会话已被删除(用户在工具执行中删了会话):不再往库里补行,否则留下无法归属的孤儿行。 + if (!getSession(sessionId)) return 0; + // 只取最后一条非 tool 行 + 它之后的回执 id:走 idx_messages_session,不载全量历史 + //(finalize 每回合都会调一次,长会话下 loadHistory 太贵)。 + const last = db.prepare( + "SELECT id, role, tool_calls FROM messages WHERE session_id = ? AND role != 'tool' ORDER BY id DESC LIMIT 1" + ).get(sessionId); + if (!last || last.role !== 'assistant') return 0; // 最后一条非 tool 行不是 assistant:不是当前批次 + if (!last.tool_calls) return 0; // 收尾回复:批次已经闭合 + let calls = []; + try { calls = JSON.parse(last.tool_calls) || []; } catch (_) { return 0; } + if (!calls.length) return 0; + const got = new Set( + db.prepare( + "SELECT tool_call_id FROM messages WHERE session_id = ? AND role = 'tool' AND id > ? AND tool_call_id IS NOT NULL AND tool_call_id != ''" + ).all(sessionId, last.id).map(r => r.tool_call_id) + ); + let n = 0; + for (const c of calls) { + if (!c || !c.id || got.has(c.id)) continue; + const name = (c.function && c.function.name) || '未知工具'; + const text = 'Error: ' + reason + '本次调用未执行(' + name + ')。'; + const msgId = saveMessage(sessionId, { role: 'tool', tool_call_id: c.id, name, content: text, is_error: true }); + // 同步广播:前端工具卡不能停在「调用中」呼吸态 + bus.emit(sessionId, 'tool_result', { + tool_call_id: c.id, name, content: text, is_error: true, msg_id: msgId, + }); + n++; + } + if (n) log.info('tool', sessionId + ' 补齐 ' + n + ' 条未执行调用的合成回执(' + reason + ')'); + return n; +} + // ---------- Agent 主循环 ---------- async function runLoop(sessionId) { const run = getRun(sessionId, true); @@ -481,22 +530,34 @@ function finalize(sessionId, run) { const s = getSession(sessionId); if (!s || s.status !== 'active') { runs.delete(sessionId); return; } const cancelled = run.cancelled; + // 兜底:回合结束时本批 tool_call 必须逐个有回执。取消/异常/进程被杀都可能留下半批, + // 缺的补一条「未执行」合成回执——这是「工具调用不匹配」的唯一根治点。 + try { closeToolBatch(sessionId, cancelled ? (run.interruptReason || '用户已终止任务:') : '回合异常结束:'); } + catch (e) { log.warn('tool', sessionId + ' 关闭工具批次失败:' + (e && e.message || e)); } if (cancelled) { touch(sessionId, { status: 'cancelled', cancelled_at: now(), completed_at: null }); runs.delete(sessionId); bus.emit(sessionId, 'done', { status: 'cancelled' }); emitStatus(sessionId); - return; + } else { + // 正常结束:进入 held,绑定保持(key 非独占、无租约,不再自动到期);用户追问直接复用模型,唯一出口是手动「断开」。 + touch(sessionId, { status: 'held', held_at: now(), completed_at: null, cancelled_at: null }); + runs.delete(sessionId); + bus.emit(sessionId, 'done', { status: 'held' }); + emitStatus(sessionId); + maybeGenerateTitle(sessionId, s, run); + // 定时即下班:本回合创建过定时任务 → done 广播后收口(attachBus 监听已在 done 回调里同步捕获绑定入队投递, + // 此时删绑定不影响微信本次回复送达)。 + if (run.taskWrap) taskClockOut(sessionId); + } + // 队首待投递消息:回合已收尾(循环已退、批次已闭合),这是排队模式唯一的安全出口。 + // setImmediate 让 finalize 所在的 finally 先跑完(maybeAutoCompress 会读状态),再开新一轮。 + if (headPending(sessionId)) { + setImmediate(() => { + try { deliverPendingHead(sessionId); } + catch (e) { log.warn('msg', sessionId + ' 待投递消息发送失败:' + (e && e.message || e)); } + }); } - // 正常结束:进入 held,绑定保持(key 非独占、无租约,不再自动到期);用户追问直接复用模型,唯一出口是手动「断开」。 - touch(sessionId, { status: 'held', held_at: now(), completed_at: null, cancelled_at: null }); - runs.delete(sessionId); - bus.emit(sessionId, 'done', { status: 'held' }); - emitStatus(sessionId); - maybeGenerateTitle(sessionId, s, run); - // 定时即下班:本回合创建过定时任务 → done 广播后收口(attachBus 监听已在 done 回调里同步捕获绑定入队投递, - // 此时删绑定不影响微信本次回复送达)。 - if (run.taskWrap) taskClockOut(sessionId); } // 自动生成标题:每回合结束(finalize 成功分支)过门槛才触发,fire-and-forget 不阻塞收尾。 @@ -736,6 +797,13 @@ async function runLoopInner(sessionId, run) { } if (!hasTools) { + // 「干预」升级过的待投递消息:本条回复已落库,正是安全边界——直接插话并继续同一回合 + //(不用等 finalize 再开新一轮,模型能接着刚才的上下文改弦更张)。 + const head = headPending(sessionId); + if (head && head.mode === 'interject') { + deliverPendingHead(sessionId); + continue; + } // 回合结束;但若期间用户又发了新消息(live 投递),继续下一轮而不是收尾 if (!hasUserSince(sessionId, lastIncludedId)) break; continue; @@ -743,8 +811,19 @@ async function runLoopInner(sessionId, run) { // 执行工具 const vision = modelVision(session); + // 干预(整批还没开跑):一个工具都不执行,整批补「未执行」回执后立刻插话。 + // 顺序不能反:必须先闭合批次(写完全部 tool 回执)再写 user 行,否则 user 会夹在 + // assistant.tool_calls 与 tool 回执之间,上游直接拒收。 + const headBeforeBatch = headPending(sessionId); + if (headBeforeBatch && headBeforeBatch.mode === 'interject') { + closeToolBatch(sessionId, '用户已介入并要求中止:'); + deliverPendingHead(sessionId); + iter++; + continue; + } // 标题门槛信号:本批参数预检通过并真实执行 = 会话在干实事(finalize 据此判是否立题, - // 见 maybeGenerateTitle);errAck 批(参数畸形、下轮整轮对模型不可见)不算。 + // 见 maybeGenerateTitle);errAck 批(参数畸形、下轮整轮对模型不可见)不算, + // 被干预整批跳过(上面已 continue)也不计。 if (!isErrAck) run.toolWorked = true; for (const tc of msgRow.tool_calls) { if (run.cancelled) break; @@ -837,7 +916,18 @@ async function runLoopInner(sessionId, run) { image_url: imageRel ? '/api/sessions/' + encodeURIComponent(sessionId) + '/files/download?path=' + encodeURIComponent(imageRel) : undefined, msg_id: toolMsgId, }); + // 干预(当前工具已跑完、回执已落库):同批剩余调用不再执行,闭合批次后立刻插话。 + // 不杀进程——这就是「干预」与「立即发送」的唯一区别。 + const headAfterTool = headPending(sessionId); + if (headAfterTool && headAfterTool.mode === 'interject') { + closeToolBatch(sessionId, '用户已介入并要求中止:'); + deliverPendingHead(sessionId); + break; + } } + // 取消(含「立即发送」硬中断):本批还没跑到的调用补合成回执,否则库里留下 + // 「有调用无回执」的孤儿行,下一轮请求必被上游拒收(本次顺手修掉的存量 bug)。 + if (run.cancelled) closeToolBatch(sessionId, run.interruptReason || '用户已终止任务:'); iter++; } if (iter >= maxIter && !run.cancelled) { @@ -1058,6 +1148,132 @@ function createSession(title, preferModelId, assistantType, user) { return session; } +// ---------- 待投递消息(排队 / 干预 / 立即发送) ---------- +// 三种模式的差别只在「何时写库」,写库之前一律躺在 pendings 里(见文件头注释的铁律): +// queue → 本轮 finalize 后投递(默认;浏览器关了也照发,因为队列在服务端) +// interject → 当前工具批次闭合 / 本条回复落库后立即投递,同一回合内让模型看到 +// now → 硬中断(杀进程 + abort 流,本回合判 cancelled),收尾后立刻投递 +// 只允许升级队首:越过后面的消息先发会让对话顺序不可解释(前端也只有队首有这两个按钮)。 +function newPendingId() { + return 'q_' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8); +} + +function publicPending(it) { + return { id: it.id, content: it.content, mode: it.mode, created_at: it.created_at }; +} + +function pendingList(sessionId) { + return pendings.get(sessionId) || []; +} + +function headPending(sessionId) { + const list = pendings.get(sessionId); + return list && list.length ? list[0] : null; +} + +function listPending(sessionId) { + return pendingList(sessionId).map(publicPending); +} + +// 清空队列(用户点「停止」、删会话、清空会话):逐条广播,前端条幅随之消失。 +function clearPendings(sessionId) { + const list = pendings.get(sessionId); + if (!list || !list.length) return 0; + pendings.delete(sessionId); + for (const it of list) bus.emit(sessionId, 'pending_removed', { id: it.id, reason: 'cancelled' }); + log.info('msg', sessionId + ' 清空待投递消息 ' + list.length + ' 条'); + return list.length; +} + +// 入队。没有在跑的回合时,任何模式都等价于立即发送(队列只对运行中的回合有意义)。 +function enqueueMessage(sessionId, content, opts) { + const session = getSession(sessionId); + if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 }); + const text = String(content == null ? '' : content).trim(); + if (!text) throw Object.assign(new Error('content 不能为空'), { status_code: 400 }); + const run = runs.get(sessionId); + if (!run || !run.looping) { + const r = postUserMessage(sessionId, text, { deepThink: !!(opts && opts.deepThink) }); + return { message_id: r.message_id, delivered: r.delivered, pending: [] }; + } + const item = { + id: newPendingId(), content: text, + deepThink: !!(opts && opts.deepThink), mode: 'queue', created_at: now(), + }; + const list = pendingList(sessionId).slice(); + list.push(item); + pendings.set(sessionId, list); + bus.emit(sessionId, 'pending_added', publicPending(item)); + log.info('msg', sessionId + ' 待投递消息入队(队列 ' + list.length + '):' + text.slice(0, 60).replace(/\s+/g, ' ')); + return { pending_id: item.id, queued: true, pending: list.map(publicPending) }; +} + +// 升级队首:interject(跑完当前这一步就插话) / now(立刻中断本轮)。 +// 回合已经结束(没在跑)时直接投递——用户点按钮时恰好收尾,不该把消息卡在队列里。 +function promotePending(sessionId, qid, action) { + const session = getSession(sessionId); + if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 }); + const list = pendingList(sessionId); + const idx = list.findIndex(x => x.id === qid); + if (idx < 0) throw Object.assign(new Error('待发送消息不存在'), { status_code: 404 }); + if (idx !== 0) throw Object.assign(new Error('只能升级队首消息:前面的消息还没发出去'), { status_code: 409 }); + const run = runs.get(sessionId); + if (!run || !run.looping) { + deliverPendingHead(sessionId); + return { ok: true, delivered: true, pending: listPending(sessionId) }; + } + const item = list[0]; + if (action === 'now') { + item.mode = 'now'; + bus.emit(sessionId, 'pending_added', publicPending(item)); // 前端按 id upsert,按钮态跟着变 + run.interruptReason = '用户选择立即发送:'; + run.cancelled = true; + killRunProcs(run); + if (run.abortController) { try { run.abortController.abort(); } catch (_) {} } + log.info('msg', sessionId + ' 立即发送:中断当前回合,收尾后投递队首'); + } else { + item.mode = 'interject'; + bus.emit(sessionId, 'pending_added', publicPending(item)); + log.info('msg', sessionId + ' 干预:等待当前工具/回复结束后插话'); + } + return { ok: true, pending: listPending(sessionId) }; +} + +// 取消队列里的一条(条幅上的 ×)。任意一条都可删:删队首后剩下的自然顺延,顺序仍是 FIFO。 +function cancelPending(sessionId, qid) { + const session = getSession(sessionId); + if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 }); + const list = pendingList(sessionId); + const idx = list.findIndex(x => x.id === qid); + if (idx < 0) throw Object.assign(new Error('待发送消息不存在'), { status_code: 404 }); + const next = list.slice(); + next.splice(idx, 1); + if (next.length) pendings.set(sessionId, next); else pendings.delete(sessionId); + bus.emit(sessionId, 'pending_removed', { id: qid, reason: 'cancelled' }); + log.info('msg', sessionId + ' 取消待投递消息 ' + qid); + return { ok: true, pending: next.map(publicPending) }; +} + +// 投递队首:写库 + 广播。调用方必须已保证处在安全边界(批次已闭合 / 回合已收尾)。 +// 落库走 postUserMessage:正在跑时它是 live 追加(下一轮迭代自动带上),没在跑时直接开新一轮。 +function deliverPendingHead(sessionId) { + const list = pendingList(sessionId); + if (!list.length) return null; + const item = list[0]; + const next = list.slice(1); + if (next.length) pendings.set(sessionId, next); else pendings.delete(sessionId); + const r = postUserMessage(sessionId, item.content, { deepThink: item.deepThink }); + const row = db.prepare('SELECT created_at FROM messages WHERE id = ?').get(r.message_id); + bus.emit(sessionId, 'pending_removed', { id: item.id, reason: 'delivered' }); + // 排队期间前端不画这条消息(它还不是历史),落库这一刻才画 + bus.emit(sessionId, 'user_message', { + id: r.message_id, content: item.content, + created_at: (row && row.created_at) || item.created_at, pending_id: item.id, + }); + log.info('msg', sessionId + ' 待投递消息已送达(原模式 ' + item.mode + ',剩余 ' + next.length + ' 条)'); + return r; +} + // 用户消息入口:不再排队——任意非 looping 状态都是「拿模型立即开跑」(delivered 恒 live); // 绑定失效(配置改动后原模型被删/禁用)由 ensureBinding 自动改选,用户无感。 // opts.deepThink: true 时启用模型该「深度思考」参数(记在会话 run 上,正在跑的回合下一轮迭代会取到最新值)。 @@ -1088,9 +1304,13 @@ function postUserMessage(sessionId, content, opts) { function stop(sessionId) { const session = getSession(sessionId); if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 }); + // 「停止」= 全停:待投递队列一并作废。否则 finalize 会立刻把队首当成新回合发出去, + // 与用户按停止的意图相反(「立即发送」不走这里,它只中断当前回合、保留队首)。 + clearPendings(sessionId); const run = runs.get(sessionId); if (run) { run.cancelled = true; + run.interruptReason = '用户已终止任务:'; killRunProcs(run); if (run.abortController) { try { run.abortController.abort(); } catch (_) {} } } @@ -1415,6 +1635,7 @@ function clearSessionMessages(sessionId) { if (run.abortController) { try { run.abortController.abort(); } catch (_) {} } } runs.delete(sessionId); + clearPendings(sessionId); // 历史清零:队列里的消息也没了着落,一并作废 db.prepare('DELETE FROM messages WHERE session_id = ?').run(sessionId); wipeSessionTmp(sessionId); // 会话级 /tmp 随清空一并抹掉(尽力而为,失败只记日志不阻断) autoCompressProposed.delete(sessionId); // 历史清零,恢复自动压缩提议额度 @@ -1523,6 +1744,10 @@ module.exports = { activeRuns, createSession, postUserMessage, + enqueueMessage, + promotePending, + cancelPending, + listPending, stop, releaseHold, renameSession, @@ -1537,6 +1762,7 @@ module.exports = { loadHistory, checkToolArgs, // 参数预检/信封解包两个纯函数:导出供探针与回归验证(运行链路由 runLoopInner 内部调用) unwrapToolArgs, + closeToolBatch, // 批次闭合兜底:导出供回归验证(正常链路由 runLoopInner / finalize 调用) saveMessage, recordModelUsage, modelUsageStats, diff --git a/app/server/llm.js b/app/server/llm.js index aac1890..cd2c0a9 100644 --- a/app/server/llm.js +++ b/app/server/llm.js @@ -219,7 +219,33 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn) } // tool 回执按 tool_call_id 索引:给 errAck 行拼错误提示时取执行时挡下的原因 const toolRowById = new Map(); - for (const row of history) if (row.role === 'tool' && row.tool_call_id) toolRowById.set(row.tool_call_id, row); + // 只收「会下发」的回执:archived 行不进模型,不能拿它当配对凭据 + //(否则 assistant 的调用被保留、回执却被跳过,上游照样拒收)。 + for (const row of history) { + if (row.role !== 'tool' || !row.tool_call_id || row.type === 'archived') continue; + toolRowById.set(row.tool_call_id, row); + } + // 已下发的 tool_call id 集合:tool 行按它反查自己有没有「主」。 + // 与下面的调用侧过滤合成「读侧配对兜底」:库里的孤儿行(旧版本中途终止留下的有调用无回执、 + // 或历史被外部改动)一律不进请求——严格上游对配对是硬约束,缺一条整请求被拒。 + // 只影响发给模型的那一份,DB 与 UI 完全不动。 + const emittedCallIds = new Set(); + // 预扫:每条带 tool_calls 的 assistant「紧跟着它的那批回执」里真实存在的 call id。 + // 只往下扫连续的 tool 行,遇到 user/assistant 就停——上游要求 tool 回执紧跟在 + // 带 tool_calls 的 assistant 后面,中间夹任何消息(旧版 live 追投就可能把 user 插进来) + // 都会让整批非法。所以不能拿「全库里有这条回执」当配对凭据。 + const pairedByAssistant = new Map(); // assistant 行 id -> Set(call_id) + for (let i = 0; i < history.length; i++) { + const r = history[i]; + if (r.role !== 'assistant' || !r.tool_calls) continue; + const ids = new Set(); + for (let j = i + 1; j < history.length && history[j].role === 'tool'; j++) { + // archived 回执不进模型,不能当作「已答复」凭据(否则调用被保留、回执被跳过) + if (history[j].type === 'archived') continue; + if (history[j].tool_call_id) ids.add(history[j].tool_call_id); + } + pairedByAssistant.set(r.id, ids); + } // 「已消费」分界 = 最后一条**写过文本**的 assistant 行(不要求无 tool_calls): // 描述写在 content 里 + 继续调工具,就是模型真看到图的证据(见文件头注释的循环复盘)。 // errAck / archived 不发模型,不算回复:它们之前的图不算被消费。 @@ -293,8 +319,20 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn) // reasoning_ack_field 改名注入后此键必被剥除,不会泄往上游)。 if (row.reasoning) m.__reasoning = row.reasoning; if (row.tool_calls) { - m.tool_calls = JSON.parse(row.tool_calls); - if (trimActive && TRIM.writeRounds > 0) trimWriteCalls(m.tool_calls, roundsAfter.get(row.id) || 0); + let calls = []; + try { calls = JSON.parse(row.tool_calls) || []; } catch (_) { calls = []; } + // 配对兜底(读侧):只下发本批确有回执的调用。旧版本中途终止、外部工具异常、 + // user 行插进批次中间,都会留下无法配对的调用,严格上游会拒收整个请求。 + const pairedIds = pairedByAssistant.get(row.id) || new Set(); + const paired = calls.filter(c => c && c.id && pairedIds.has(c.id)); + if (!paired.length) { + // 整轮调用都没回执:纯工具轮整行不发;带正文的保留为普通文本回复 + if (!String(m.content || '').trim()) return; + } else { + m.tool_calls = paired; + for (const c of paired) emittedCallIds.add(c.id); + if (trimActive && TRIM.writeRounds > 0) trimWriteCalls(m.tool_calls, roundsAfter.get(row.id) || 0); + } } if (!m.content) delete m.content; messages.push(m); @@ -302,6 +340,8 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn) } // errAck 轮的 tool 回执:随该轮一起丢弃,避免无主 tool 消息 if (row.role === 'tool' && dropToolCallIds.has(row.tool_call_id)) return; + // 孤儿 tool 回执(调用行被过滤/存档/errAck 丢弃):单独下发必被上游拒收,直接跳过 + if (row.role === 'tool' && !emittedCallIds.has(row.tool_call_id)) return; // tool/user 行:含图哨兵 JSON 还原为内容块(解析结果按行 id 缓存);已消费的图只留文字描述 + 标记 const blocks = cachedDecodeBlocks(session, row); let content = row.content || ''; diff --git a/app/server/public/css/style.css b/app/server/public/css/style.css index 706de4b..abada14 100644 --- a/app/server/public/css/style.css +++ b/app/server/public/css/style.css @@ -1616,6 +1616,27 @@ body.pv-resizing #pv-pane iframe { pointer-events: none; } } @keyframes drop-overlay-in { from { opacity: 0; } to { opacity: 1; } } +/* ================= 待发送条幅(运行中排队 / 干预 / 立即发送) ================= */ +/* 输入卡上方一行小条:正文单行省略 + 动作按钮。多条时逐条堆叠,每条仍是一行。 + 配色刻意与「编辑提示条」的蓝色区分:排队是“稍后执行”的提示态,不是输入态。 */ +.send-queue { display: flex; flex-direction: column; gap: 6px; margin-bottom: 8px; } +.sq-item { + display: flex; align-items: center; gap: 6px; + padding: 5px 5px 5px 11px; + border-radius: 12px; background: #fff4dc; color: #a06a00; font-size: 12.5px; +} +.sq-item .sq-text { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.sq-item .sq-tag { flex: none; font-size: 11.5px; opacity: .75; } +.sq-item button { + flex: none; padding: 2px 9px; border-radius: 8px; + font-size: 12.5px; font-weight: 600; color: inherit; background: none; border: none; +} +.sq-item button:active { background: rgba(160, 106, 0, 0.12); } +.sq-item button:disabled { opacity: .45; } +.sq-item .sq-x { padding: 2px 7px; font-weight: 500; } +/* 已升级为「干预/立即发送」但还没到边界:按钮置灰,显示“等待当前步骤” */ +.sq-item.sq-busy button:not(.sq-x) { opacity: .45; } + /* ================= 编辑已发送消息提示条 ================= */ /* 覆盖式重发:输入框内部的浅蓝提示条(嵌在 .input-shell 顶端,间距由 shell 的 gap 提供)。 */ .edit-bar { diff --git a/app/server/public/index.html b/app/server/public/index.html index da44908..13a1e24 100644 --- a/app/server/public/index.html +++ b/app/server/public/index.html @@ -157,10 +157,13 @@