运行中发送改为待发送条幅:排队 / 干预 / 立即发送
- 运行中点发送不再立即插话,改为进服务端队列(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 事件清单与待投递队列语义。
This commit is contained in:
@@ -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` 后必须
|
||||
|
||||
@@ -20,6 +20,7 @@
|
||||
| 隔离执行 | `terminal` 和技能在 `agent-executor` 容器中运行,只看到当前会话目录,根文件系统只读 |
|
||||
| 大文件交付 | 文件面板上传/下载/打包 zip;外部服务取图走带过期时间的公网短链 |
|
||||
| 上下文管理 | 手动压缩、按 token 阈值提示压缩、历史重放自动裁剪、会话标题自动生成 |
|
||||
| 回合中投递 | 运行中发的消息先进输入框上方的待发送条幅:默认等本轮结束自动发出;可「干预」(当前工具跑完就插话)或「立即发送」(终止本轮并立刻发)。队列在服务端,关页面不丢 |
|
||||
| 定时任务 | 每会话最多一个 cron 任务;触发前清空模型可见历史,按计划执行并推送结果 |
|
||||
| 微信接入 | 扫码绑定个人微信,文本/图片/视频/文件进入同一套会话与命令体系 |
|
||||
| 语音输入 | 输入框为空时发送键变麦克风:点一下进入语音模式,输入框位置变成「按住 说话」,松开即转写并直接发送;发送键位置变键盘按钮可切回打字。套壳 App 走原生录音(http 页面也能用),浏览器走 MediaRecorder(需 HTTPS);识别在 `mcp_asr`,不经过模型、不消耗 token |
|
||||
|
||||
+32
-2
@@ -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`(前端把条幅当服务端状态的回显)。
|
||||
|
||||
## 会话状态机
|
||||
|
||||
|
||||
+237
-11
@@ -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,
|
||||
|
||||
+43
-3
@@ -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 || '';
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -157,10 +157,13 @@
|
||||
<!-- ================= 底部输入区 ================= -->
|
||||
<footer>
|
||||
<div class="attach-chips hidden" id="attach-chips"></div>
|
||||
<!-- 待发送条幅:运行中发出的消息先排在这里(不立即入库),逐条一行。
|
||||
默认等本轮结束自动发出;队首可「干预」(跑完当前这步就插话)或「立即发送」(中断本轮)。 -->
|
||||
<div class="send-queue hidden" id="send-queue" aria-live="polite"></div>
|
||||
<div class="input-shell">
|
||||
<!-- 编辑已发送消息:覆盖式重发提示条(发送后丢弃该条及其后的历史) -->
|
||||
<div class="edit-bar hidden" id="edit-bar">
|
||||
<span>正在编辑已发送的消息,发送后将丢弃其后的历史</span>
|
||||
<span>编辑已发送消息:发送后将丢弃原历史信息</span>
|
||||
<button id="edit-cancel" type="button">取消</button>
|
||||
</div>
|
||||
<div class="up-cards hidden" id="up-cards" aria-label="已上传文件"></div>
|
||||
|
||||
@@ -412,6 +412,8 @@
|
||||
state.status = (s && s.status) || '';
|
||||
state.modelId = (s && s.model_id) || ''; // 顶部动作区展示当前模型
|
||||
state.schedule = detail.schedule || null; // 定时任务数据(顶部动作区副标题)
|
||||
state.pending = Array.isArray(detail.pending) ? detail.pending : []; // 待投递队列(服务端内存态回显)
|
||||
renderSendQueue();
|
||||
renderHeader();
|
||||
updateHeaderActions();
|
||||
|
||||
|
||||
@@ -170,6 +170,7 @@
|
||||
schedule: null, // 当前会话定时任务(详情 schedule 字段,null=无)
|
||||
sessions: [], // 抽屉列表缓存
|
||||
attachments: [], // 待发送附件 {file, name, size}
|
||||
pending: [], // 待投递消息队列(服务端内存态的回显):{id, content, mode, created_at}
|
||||
editingMsgId: 0, // 正在编辑的历史消息 id(0=普通发送,覆盖式重发)
|
||||
lastImgBlobUrl: null, // 任务文件图片预览的 blob URL,下次预览或开新图时回收
|
||||
lastPdfBlobUrl: null, // 同上:PDF 页内预览的 blob URL(浏览器内建查看器用)
|
||||
|
||||
@@ -79,6 +79,8 @@
|
||||
state.sessionTitle = '';
|
||||
state.sessionType = 'secretary';
|
||||
state.pendingModel = '';
|
||||
state.pending = [];
|
||||
renderSendQueue();
|
||||
state.streamEl = null;
|
||||
state.streamText = '';
|
||||
state.toolCards = {};
|
||||
@@ -190,6 +192,8 @@
|
||||
state.status = '';
|
||||
state.modelId = '';
|
||||
state.schedule = null; // 防详情返回前残留上一会话的任务状态
|
||||
state.pending = []; // 同上:队列是会话级的,先清空,详情回来再回显
|
||||
renderSendQueue();
|
||||
// 先从抽屉列表缓存取会话类型,让顶部 icon 立即正确;详情回来后由 renderDetail 纠正
|
||||
const cached = (state.sessions || []).find(x => x.id === id);
|
||||
state.sessionType = (cached && cached.assistant_type) || 'secretary';
|
||||
@@ -249,6 +253,8 @@
|
||||
state.status = '';
|
||||
state.modelId = '';
|
||||
state.schedule = null;
|
||||
state.pending = [];
|
||||
renderSendQueue();
|
||||
state.pendingModel = '';
|
||||
state.attachments = [];
|
||||
if (typeof clearEditState === 'function') clearEditState();
|
||||
@@ -548,13 +554,15 @@
|
||||
async function stopSession() {
|
||||
if (!state.sessionId) return;
|
||||
const held = state.status === 'held';
|
||||
const queued = (state.pending || []).length;
|
||||
try {
|
||||
if (held) {
|
||||
await req('POST', '/api/sessions/' + state.sessionId + '/release');
|
||||
toast('已断开');
|
||||
} else {
|
||||
await req('POST', '/api/sessions/' + state.sessionId + '/stop');
|
||||
toast('已发送终止指令');
|
||||
// 「停止」是全停:服务端会把待投递队列一并作废,这里明确告知,不让消息静静消失
|
||||
toast(queued ? '已终止,队列中 ' + queued + ' 条消息已取消' : '已发送终止指令');
|
||||
}
|
||||
} catch (e) { toast((held ? '断开失败:' : '终止失败:') + e.message); }
|
||||
}
|
||||
|
||||
@@ -19,7 +19,7 @@
|
||||
const content = ta.value.trim();
|
||||
const editingId = state.editingMsgId || 0;
|
||||
// 没有文字就不发(避免产生空消息);但只有附件时允许发送——粘贴长文本转成的 .txt 需要能单独发出。
|
||||
// 运行中也是这条规则:有字就发(后端 live 追投),没字又没附件时按钮本身是「停止」。
|
||||
// 运行中也是这条规则:有字就发,没字又没附件时按钮本身是「停止」。
|
||||
if (!content && !state.attachments.length) return;
|
||||
|
||||
const pending = state.attachments.slice();
|
||||
@@ -43,7 +43,10 @@
|
||||
const text = names.length
|
||||
? '用户上传了文件:' + names.join('、') + (content ? '\n\n' + content : '')
|
||||
: content;
|
||||
const body = { content: text, deepThink: !!state.deepThink };
|
||||
// 是否排队由**服务端**决定:Web 端一律交 delivery:'queue',回合在跑就进队列,
|
||||
// 没在跑就等价于立即发送(enqueueMessage 直接走 postUserMessage)。
|
||||
// 不用 state.status 判断——SSE 状态可能过期,误判成 live 会把 user 行插进工具批次中间。
|
||||
const body = { content: text, deepThink: !!state.deepThink, delivery: 'queue' };
|
||||
let sent;
|
||||
if (editingId) {
|
||||
// 覆盖式编辑:先撤掉本地该条及其后的渲染,再让服务端删除同范围历史并以新内容重开一轮
|
||||
@@ -56,7 +59,15 @@
|
||||
}
|
||||
clearUploadCards(); // 消息已发出(告知行已拼入正文),卡片使命完成清掉
|
||||
|
||||
appendUserMsg(text, atts.map(a => a.name), sent && sent.message_id);
|
||||
// 排队回执:条幅以服务端返回的队列为准(本端不画气泡,等真正落库的 user_message 再画);
|
||||
// 竞态下服务端发现回合已结束会直接送达(没有 queued 字段),那就照常当普通发送处理。
|
||||
const queued = !!(sent && sent.queued);
|
||||
if (queued) {
|
||||
state.pending = sent.pending || [];
|
||||
renderSendQueue();
|
||||
} else {
|
||||
appendUserMsg(text, atts.map(a => a.name), sent && sent.message_id);
|
||||
}
|
||||
// 标题取用户原文,不带文件告知行;纯附件发送时退回粘贴文本的前缀
|
||||
const seed = content || (pending[0] && pending[0].titleSeed) || '';
|
||||
if (!state.sessionTitle && seed) {
|
||||
@@ -65,7 +76,8 @@
|
||||
renderHeader();
|
||||
// 运行中插话:正文字流进行中已有一个气泡作「活着」的信号,不再挂打字占位
|
||||
//(刚挂上就会被下一个 delta 移除,只会闪一下);工具间隙里补上占位反而有用。
|
||||
if (!state.streaming) addTyping();
|
||||
// 排队时本回合没有任何新动静,不挂占位。
|
||||
if (!queued && !state.streaming) addTyping();
|
||||
loadSessionList();
|
||||
} catch (e) {
|
||||
// 发送失败:附件还原+草稿文本回填(发送前已清空输入框,挂起/失败不能让文字蒸发),
|
||||
@@ -83,6 +95,56 @@
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- 待发送条幅 ----------
|
||||
// 队列本身在服务端(engine.pendings),关页面/换设备/重连都不丢;这里只负责画。
|
||||
// 每条一行;只有队首有「干预 / 立即发送」,其余显示排队中(不能越过前一条先发)。
|
||||
function renderSendQueue() {
|
||||
const box = $('send-queue');
|
||||
if (!box) return;
|
||||
const list = state.pending || [];
|
||||
box.classList.toggle('hidden', !list.length);
|
||||
if (!list.length) { box.innerHTML = ''; return; }
|
||||
box.innerHTML = list.map((it, i) => {
|
||||
const busy = it.mode === 'interject' || it.mode === 'now';
|
||||
const tag = it.mode === 'now' ? '<span class="sq-tag">正在中断…</span>'
|
||||
: it.mode === 'interject' ? '<span class="sq-tag">等待当前步骤…</span>'
|
||||
: (i === 0 ? '' : '<span class="sq-tag">排队中</span>');
|
||||
const acts = (i === 0 && !busy)
|
||||
? '<button data-act="interject" title="当前工具调用结束后立即插话">干预</button>' +
|
||||
'<button data-act="now" title="终止本轮工具调用并立即发送">立即发送</button>'
|
||||
: '';
|
||||
return '<div class="sq-item' + (busy ? ' sq-busy' : '') + '" data-qid="' + esc(it.id) + '">' +
|
||||
'<span class="sq-text" title="' + esc(it.content) + '">' + esc(it.content) + '</span>' +
|
||||
tag + acts +
|
||||
'<button class="sq-x" data-act="cancel" title="取消这条">×</button></div>';
|
||||
}).join('');
|
||||
}
|
||||
|
||||
// 条幅按钮:× 取消;干预/立即发送升级队首(服务端只在安全边界真正投递)。
|
||||
async function onSendQueueClick(e) {
|
||||
const btn = e.target.closest('#send-queue button[data-act]');
|
||||
if (!btn || !state.sessionId) return;
|
||||
const item = btn.closest('.sq-item');
|
||||
const qid = item && item.dataset.qid;
|
||||
if (!qid) return;
|
||||
const act = btn.dataset.act;
|
||||
btn.disabled = true;
|
||||
try {
|
||||
const base = '/api/sessions/' + state.sessionId + '/pending/' + encodeURIComponent(qid);
|
||||
const r = act === 'cancel' ? await req('DELETE', base) : await req('POST', base, { action: act });
|
||||
if (r && Array.isArray(r.pending)) { state.pending = r.pending; renderSendQueue(); }
|
||||
if (act === 'cancel') return;
|
||||
if (r && r.delivered) return; // 回合已结束:服务端直接投递,等 user_message 画气泡
|
||||
toast(act === 'now' ? '已请求中断,随后立即发送' : '已请求干预:当前步骤结束后插话');
|
||||
} catch (err) {
|
||||
toast('操作失败:' + err.message);
|
||||
renderSendQueue();
|
||||
}
|
||||
}
|
||||
|
||||
const sendQueueBox = $('send-queue');
|
||||
if (sendQueueBox) sendQueueBox.addEventListener('click', onSendQueueClick);
|
||||
|
||||
// ---------- SSE 流 ----------
|
||||
// 助手消息流式容器:首个 delta 到达时创建,同时为思考面板预留挂载点
|
||||
function ensureStreamWrap() {
|
||||
@@ -158,12 +220,15 @@
|
||||
state.lastSseAt = Date.now(); // 建连即重置静默计时
|
||||
// 任何具名事件都算连接存活:静默看门狗与回前台宽限共用(error 不列,原生连接错误也走 error)
|
||||
['ping', 'status', 'assistant_delta', 'reasoning_delta', 'assistant_message', 'tool_call_start',
|
||||
'tool_call_args', 'tool_call', 'tool_result', 'ui_card', 'auto_compress', 'done', 'title', 'think_auto']
|
||||
'tool_call_args', 'tool_call', 'tool_result', 'ui_card', 'auto_compress', 'done', 'title', 'think_auto',
|
||||
'pending_added', 'pending_removed', 'user_message']
|
||||
.forEach(function (n) { es.addEventListener(n, function () { markSseAlive(n); }); });
|
||||
es.addEventListener('status', ev => {
|
||||
const d = JSON.parse(ev.data);
|
||||
state.status = d.status;
|
||||
if (d.model_id) state.modelId = d.model_id;
|
||||
// 待投递队列以服务端为准(重连/换标签页后条幅能自动回到真实状态)
|
||||
if (Array.isArray(d.pending)) { state.pending = d.pending; renderSendQueue(); }
|
||||
renderHeader();
|
||||
updateHeaderActions();
|
||||
updateScrollBottomBtn(); // 状态切换同步右下角转圈(开始/结束干活)
|
||||
@@ -348,8 +413,33 @@
|
||||
es.addEventListener('auto_compress', ev => {
|
||||
proposeAutoCompress(JSON.parse(ev.data));
|
||||
});
|
||||
// 待发送条幅:新入队 / 升级(同 id upsert)
|
||||
es.addEventListener('pending_added', ev => {
|
||||
const d = JSON.parse(ev.data);
|
||||
if (!d || !d.id) return;
|
||||
const list = state.pending.slice();
|
||||
const i = list.findIndex(x => x.id === d.id);
|
||||
if (i >= 0) list[i] = d; else list.push(d);
|
||||
state.pending = list;
|
||||
renderSendQueue();
|
||||
});
|
||||
// 出队(已送达 / 被取消 / 停止时整体清空)
|
||||
es.addEventListener('pending_removed', ev => {
|
||||
const d = JSON.parse(ev.data);
|
||||
state.pending = state.pending.filter(x => x.id !== (d && d.id));
|
||||
renderSendQueue();
|
||||
});
|
||||
// 排队消息真正落库:这一刻它才成为历史,画进聊天区(排队期间不画)
|
||||
es.addEventListener('user_message', ev => {
|
||||
const d = JSON.parse(ev.data);
|
||||
if (!d || !d.id || state.renderedSigs[d.id]) return; // 防重(重连补拉/多标签页)
|
||||
appendUserMsg(d.content, null, d.id);
|
||||
removeTyping();
|
||||
});
|
||||
es.addEventListener('done', ev => {
|
||||
removeTyping(); // 本轮结束,占位亦终止(如模型报错无回复)
|
||||
let doneStatus = '';
|
||||
try { doneStatus = (JSON.parse(ev.data) || {}).status || ''; } catch (_) { /* 无 data 的连接层错误 */ }
|
||||
// 压缩回合异常结束的兜底(模型报错回合直接 break / 被终止 → 不会有带 is_summary 的最终消息):
|
||||
// 复位等待状态并还原压缩按钮,历史保持原样不动。
|
||||
if (state.pendingSummary) {
|
||||
@@ -364,10 +454,20 @@
|
||||
state.streamWrap = null;
|
||||
state.streamReasoning = '';
|
||||
state.streamThinkEl = null;
|
||||
// 异常收尾兜底:把参数未流完的早卡就地回填收尾,避免占位态永远呼吸
|
||||
// 异常收尾兜底:把参数未流完的早卡就地回填收尾,避免占位态永远呼吸。
|
||||
// 被「立即发送/停止」硬中断时,这些调用根本没落库、不会再有回执,
|
||||
// 结果区要明确写「已取消」,否则卡片永远停在「执行中…」。
|
||||
for (const sid of Object.keys(state.toolCallStreaming)) {
|
||||
const stg = state.toolCallStreaming[sid];
|
||||
finalizeToolCardArgs(sid, stg.name, stg.args);
|
||||
const card = state.toolCards[sid];
|
||||
const pre = card && card.querySelector('.tool-result');
|
||||
if (pre && pre.textContent === '执行中…') {
|
||||
card.classList.add('error');
|
||||
const spin = card.querySelector('.spin');
|
||||
if (spin) spin.textContent = '⏹';
|
||||
pre.textContent = doneStatus === 'cancelled' ? '已取消(本轮被终止,未执行)' : '本轮已结束,未收到结果';
|
||||
}
|
||||
}
|
||||
state.toolCards = {};
|
||||
state.toolCallStreaming = {}; // 流式参数早卡映射随会话/回合重置
|
||||
|
||||
@@ -16,17 +16,46 @@ function wrap(fn) {
|
||||
}
|
||||
|
||||
// 附件上传只写任务目录文件(见 routes/files.js),消息正文原样入库,不再拼接任何通知行。
|
||||
// delivery:
|
||||
// live(默认,兼容旧调用方/微信)→ 立即入库;回合在跑时下一轮迭代自动带上
|
||||
// queue → 回合在跑时进待投递队列(不落库),回合收尾后自动发出;不在跑则等价于 live
|
||||
// 「干预 / 立即发送」不走这里,而是对已在队列里的条目做升级(POST /pending/:qid)。
|
||||
router.post('/:id/messages', wrap((req, res) => {
|
||||
const content = String((req.body && req.body.content) || '').trim();
|
||||
if (!content) return res.status(400).json({ error: 'content 不能为空' });
|
||||
// deepThink:是否启用模型该「深度思考」参数(thinking_params 合并进上游请求体)
|
||||
const deepThink = !!(req.body && req.body.deepThink);
|
||||
const delivery = String((req.body && req.body.delivery) || 'live');
|
||||
if (delivery === 'queue') {
|
||||
const r = engine.enqueueMessage(req.params.id, content, { deepThink });
|
||||
log.info('msg', (req.user || '-') + ' ' + req.params.id + ' 用户消息(' +
|
||||
(r.queued ? '排队 ' + r.pending_id : r.delivered || '?') + '):' +
|
||||
content.slice(0, 60).replace(/\s+/g, ' '));
|
||||
return res.json(r);
|
||||
}
|
||||
const r = engine.postUserMessage(req.params.id, content, { deepThink });
|
||||
log.info('msg', (req.user || '-') + ' ' + req.params.id + ' 用户消息(' + (r && r.delivered || '?') + '):' +
|
||||
content.slice(0, 60).replace(/\s+/g, ' '));
|
||||
res.json(r);
|
||||
}));
|
||||
|
||||
// 待投递队列:升级队首(干预 / 立即发送)。
|
||||
// 干预 = 等当前工具跑完/本条回复落库后插话;立即发送 = 杀进程 + abort 流,本回合收尾后立刻发。
|
||||
router.post('/:id/pending/:qid', wrap((req, res) => {
|
||||
const action = String((req.body && req.body.action) || 'interject');
|
||||
if (action !== 'interject' && action !== 'now') {
|
||||
return res.status(400).json({ error: 'action 只能是 interject 或 now' });
|
||||
}
|
||||
const r = engine.promotePending(req.params.id, req.params.qid, action);
|
||||
log.info('msg', (req.user || '-') + ' ' + req.params.id + ' 待投递消息 ' + req.params.qid + ' → ' + action);
|
||||
res.json(r);
|
||||
}));
|
||||
|
||||
// 取消一条待投递消息(条幅上的 ×)。
|
||||
router.delete('/:id/pending/:qid', wrap((req, res) => {
|
||||
res.json(engine.cancelPending(req.params.id, req.params.qid));
|
||||
}));
|
||||
|
||||
|
||||
// 覆盖式编辑:删除该条及其后的历史,再以新内容重开一轮(运行中 409)。
|
||||
router.post('/:id/messages/:mid/edit', wrap((req, res) => {
|
||||
|
||||
@@ -208,6 +208,8 @@ router.get('/:id', wrap((req, res) => {
|
||||
files: listTaskFiles(taskDir),
|
||||
schedule,
|
||||
running: !!(engine.getRun(session.id) || {}).looping,
|
||||
// 待投递队列(刷新/换设备后条幅能原样恢复):只在服务端内存里,重启即空
|
||||
pending: engine.listPending(session.id),
|
||||
has_more: hasMore, // 分页模式下:是否还有更早的历史
|
||||
oldest_id: messages.length ? messages[0].id : null, // 本页最早行 id,作为下一页 before 游标
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user