模型调度改造:去排队去独占,key 共享并发+「最不 active」优先级选 key;绑定持久化、失效自动改选,弹窗任意可选

This commit is contained in:
2026-09-27 20:51:34 +08:00
parent 3084e4f28a
commit de1a6b59a9
13 changed files with 230 additions and 372 deletions
+2 -1
View File
@@ -85,7 +85,8 @@ const DEFAULTS = {
upload: { image_compress_threshold_kb: 1536, image_max_dim: 2000, image_quality: 0.85, confirm_size_mb: 10 },
// 技能根目录:留空取 workspace_root 同级 skills(/workspace/tasks → /workspace/skills)。
skills: { skills_root: '', timeout_ms: 120000 },
// 回合结束后模型保持占用(held)租约:无人观看 idle_release_ms 释放,有人观看最长 active_max_ms,sweep_ms 巡检。
// 【已废弃】旧版模型保持租约(held 到期自动释放)。调度已改为「key 共享并发 + 优先级选择」(见 engine.chooseKey),
// 不再有任何到期逻辑;字段保留仅为旧 config.yml 兼容(解析不报错),运行期无人读取。
model_hold: { idle_release_ms: 180000, active_max_ms: 1800000, sweep_ms: 10000 },
// 日志等级:debug < info < warn < error < none(none=全部静默)。
log_level: 'info',
+10 -5
View File
@@ -61,6 +61,9 @@ function initDb(dbPath) {
FOREIGN KEY (session_id) REFERENCES sessions(id)
);
-- 模型池:一行一个物理 key 槽位(id=「平台#下标」),由配置重建(见 engine.syncModelPool)。
-- key 不再独占(多会话可共享同一 key 并发 looping),调度只是按「最不 active」优顺序选(见 engine.chooseKey)。
-- is_busy / current_session_id 是旧版独占时代的残留列:保留不读写,只存 last_used_at(轮转依据)。
CREATE TABLE IF NOT EXISTS model_pool (
id TEXT PRIMARY KEY,
display_name TEXT,
@@ -69,6 +72,8 @@ function initDb(dbPath) {
last_used_at INTEGER
);
-- 旧版 FIFO 等待队列表:已废弃(排队语义整体移除,会话绑不到模型不再挂队等而是直接报错),
-- 表与列保留(SQLite 删表不值得),代码不再读写。
CREATE TABLE IF NOT EXISTS wait_queue (
id INTEGER PRIMARY KEY AUTOINCREMENT,
session_id TEXT NOT NULL,
@@ -129,16 +134,16 @@ function initDb(dbPath) {
`);
// 升级老库:model_usage 补 cached_tokens 列(输入 token 缓存命中量累计,算历史命中率)
try { db.exec('ALTER TABLE model_usage ADD COLUMN cached_tokens INTEGER DEFAULT 0'); } catch (_) { /* 已存在 */ }
// 迁移:旧库补 held_at 列(held 保持租约起始时间)
// 升级老库:旧库补 held_at 列(进入 held 的时刻;现仅展示/自动压缩校验用,租约到期逻辑已随「key 不独占」一并移除)
const cols = db.prepare('PRAGMA table_info(sessions)').all();
if (!cols.some(c => c.name === 'held_at')) db.exec('ALTER TABLE sessions ADD COLUMN held_at INTEGER');
// 迁移:model_slot 记会话占用的具体池 key 槽位(「平台#key下标」,平台 key 为其下模型共享资源),
// model_id 仍存模型 id 供展示/统计(见 engine.bindModel)。
// 迁移:model_slot 记会话粘住的具体池 key 槽位(「平台#key下标」,key 为共享资源不再独占),
// 跨结版/重启保持(只有手动换绑或模型失效改选会动),model_id 存模型 id 供展示/统计(见 engine.applyBinding)。
if (!cols.some(c => c.name === 'model_slot')) db.exec('ALTER TABLE sessions ADD COLUMN model_slot TEXT');
// 迁移:model_pool 一行一个物理 key 槽位(id=「平台#下标」),last_used_at 支撑「最久未用先上」轮转(见 engine.freeModel)
// 迁移:model_pool 一行一个物理 key 槽位(id=「平台#下标」),last_used_at 支撑「最久未用先上」轮转(见 engine.chooseKey)
const poolCols = db.prepare('PRAGMA table_info(model_pool)').all();
if (!poolCols.some(c => c.name === 'last_used_at')) db.exec('ALTER TABLE model_pool ADD COLUMN last_used_at INTEGER');
// 迁移:last_model_id 记住会话最近用过的模型,释放后新消息优先回绑(见 engine.dispatchQueued)
// 迁移:last_model_id 记住会话最近用过的模型(换绑时一并刷新),绑定失效时供 ensureBinding 优先回原平台/原模型
if (!cols.some(c => c.name === 'last_model_id')) {
db.exec('ALTER TABLE sessions ADD COLUMN last_model_id TEXT');
db.exec('UPDATE sessions SET last_model_id = model_id WHERE last_model_id IS NULL AND model_id IS NOT NULL');
+130 -261
View File
@@ -1,4 +1,4 @@
// 核心引擎:会话管理、模型池调度(FIFO)、Agent 主循环、任务目录。
// 核心引擎:会话管理、模型池调度(优先级选 key:无排队、无独占)、Agent 主循环、任务目录。
// 单进程内存模型:JS 单线程 + better-sqlite3 同步 API,不存在跨进程竞争。
const fs = require('fs');
const path = require('path');
@@ -141,27 +141,16 @@ function emitStatus(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() {
registerProfilePrompts(); // profile 自定义 prompt 注册进 llm(文本已随配置加载读入)
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'
);
// 池槽位按物理 key 拆分:槽位 id = 「平台#key下标」,一个 key 同时只服务一个会话(concurrency 仍仅记录未调度)。
// 同平台的模型共享这批 key:平台 key 全部被占时,其下所有模型都不可再选。
// 池槽位按物理 key 拆分:槽位 id = 「平台#key下标」,key 为共享资源(同平台模型共用,也可多会话同时用,见 chooseKey)。
// enable:false 的模型不进池:平台下模型全禁用则该平台不建槽位(与其他模型配置一致,重启生效)。
const seen = new Set();
for (const m of cfg.models) if (m.enable !== false) seen.add(m.platform + '#' + m.key_index);
@@ -170,23 +159,40 @@ function syncModelPool() {
for (const row of db.prepare('SELECT id FROM model_pool').all()) {
if (!seen.has(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, model_slot=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, model_slot=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();
// 进程重启后:key 非独占,所有会话的绑定保持不动(顶部展示的模型持续可见,直到用户手动断开/换绑)。
// active(重启后必无回合进程)与遗留 queued 会话统一归位 held;指向已被删除/禁用模型的绑定,
// 下次发消息时由 ensureBinding 自动改选(优先留原平台),用户无感。
db.prepare('UPDATE model_pool SET is_busy = 0, current_session_id = NULL').run(); // 旧版独占列清残留(调度已不读)
db.prepare("UPDATE sessions SET status='held', held_at=COALESCE(held_at, updated_at), updated_at=? WHERE status IN ('active','queued')").run(now());
}
function freeModel() {
// 轮转:最久未用(从未用过排最前)的空闲 key 先上 → 全平台 key 自然摊平,
// 平台 key 灌满后自动轮到下一个平台(见 pickModelFor)。
return db.prepare('SELECT * FROM model_pool WHERE is_busy = 0 ORDER BY ifnull(last_used_at, 0), id').get();
// ---------- 模型池调度(优先级选择,无排队、无独占) ----------
// key 是共享资源:同一个 key 可同时服务多个 looping 会话(上游 key 本身支持多并发),
// 调度只是挑「最不 active」的一个:looping 回合数少 → 在用(active/held)会话数少 → 最久未用(轮转摊平)→ id。
// preferPlatform:优先留在原平台(绑定模型失效改选、用户手动选模时用);
// strict=true 时限定该平台(没有该平台的槽位就返回 null,供手动绑定「就要这个模型」的语义)。
function chooseKey(preferPlatform, strict) {
const rows = db.prepare('SELECT id, last_used_at FROM model_pool').all();
if (!rows.length) return null;
const users = {}; // slot -> 在用会话数(active/held)
for (const r of db.prepare("SELECT model_slot AS s, COUNT(*) AS c FROM sessions WHERE model_slot IS NOT NULL AND status IN ('active','held') GROUP BY model_slot").all()) users[r.s] = r.c;
const looping = {}; // slot -> 回合执行中的会话数(内存 runs,库里无此状态)
for (const [id, run] of runs) {
if (!run || !run.looping) continue;
const s = db.prepare('SELECT model_slot FROM sessions WHERE id = ?').get(id);
if (s && s.model_slot) looping[s.model_slot] = (looping[s.model_slot] || 0) + 1;
}
const ranked = rows.slice().sort((a, b) =>
((looping[a.id] || 0) - (looping[b.id] || 0)) ||
((users[a.id] || 0) - (users[b.id] || 0)) ||
((a.last_used_at || 0) - (b.last_used_at || 0)) ||
(a.id < b.id ? -1 : (a.id > b.id ? 1 : 0)));
if (preferPlatform) {
const sub = ranked.filter(r => platformOf(r.id) === preferPlatform);
if (sub.length) return sub[0];
if (strict) return null;
}
return ranked[0];
}
// 模型 id「平台/模型」或池槽位 id「平台#key下标」→ 平台名。
@@ -198,14 +204,6 @@ function platformOf(id) {
return sl >= 0 ? s.slice(0, sl) : s;
}
// 指定平台的空闲 key 槽位:最久未用的先上。
// 用范围比较而非 LIKE,避免平台名里的 _/% 被当通配符。
function freeKeyOf(platform) {
if (!platform) return null;
return db.prepare('SELECT * FROM model_pool WHERE id >= ? AND id < ? AND is_busy = 0 ORDER BY ifnull(last_used_at, 0), id LIMIT 1')
.get(platform + '#', platform + '#\uffff');
}
// 平台下启用中的模型 id 列表(cfg.models 按 key 展开过,这里去重并保留配置顺序)。
function platformModels(platform) {
const seen = new Set();
@@ -341,60 +339,37 @@ function archiveTaskBrief(sessionId) {
}
}
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());
// ---------- 绑定 ----------
// 写入绑定:会话粘住自己的 key+模型(断开/结版/终止不清,跨重启沿用,追问免选),
// 并刷新槽位 last_used_at(「最久未用先上」的轮转依据)。model_id 同时用于展示/统计。
function applyBinding(sessionId, key, modelId) {
db.prepare('UPDATE model_pool SET last_used_at = ? WHERE id = ?').run(now(), key.id);
db.prepare('UPDATE sessions SET model_id=?, model_slot=?, last_model_id=?, updated_at=? WHERE id=?')
.run(modelId, key.id, modelId, now(), sessionId);
}
function dequeue(sessionId) {
db.prepare('DELETE FROM wait_queue WHERE session_id = ?').run(sessionId);
// 会话绑定的 key+模型是否仍有效:槽位在池里(配置冷加载,改配置需重启,重启后池已重建)、
// 模型在启用列表里(enable:false / 改名 / 整平台删除都会命中失效)。
function bindingValid(session) {
if (!session || !session.model_slot || !session.model_id) return false;
if (!db.prepare('SELECT 1 FROM model_pool WHERE id = ?').get(session.model_slot)) return false;
return platformModels(platformOf(session.model_slot)).includes(session.model_id);
}
// key:占用的池 key 槽位行(id=「平台#ki」);modelId:选定的模型 id(同平台模型共享 key,绑定时才决定用哪个)。
// status:绑定后的会话状态。
// - 'active'(默认):绑定即开跑(有待回应消息,紧随其后 runLoop);排队派发 dispatchQueued 用。
// - 'held':仅预留模型占位(手动选模/新建选模,尚无待回应消息),
// 用户发首条消息后由 postUserMessage 的 held 分支转 active 开跑。
function bindModel(session, key, modelId, status) {
const st = status === 'held' ? 'held' : 'active';
db.prepare('UPDATE model_pool SET is_busy = 1, current_session_id = ?, last_used_at = ? WHERE id = ?').run(session.id, now(), key.id);
// model_id/last_model_id 存模型 id(展示/统计用),model_slot 记占用的具体 key 槽位;
// last_model_id 不随释放清除:会话再次需要模型时优先回绑同平台(见 pickModelFor)
db.prepare("UPDATE sessions SET status=?, model_id=?, model_slot=?, last_model_id=?, held_at=?, updated_at=? WHERE id=?")
.run(st, modelId, key.id, modelId, st === 'held' ? now() : null, now(), session.id);
// 开回合前确保有效绑定:配置改动导致原模型失效时自动改选「最不 active」的 key,优先留在原平台
//(chooseModel 同平台还偏好旧模型),对用户透明;池完全为空时报错(配置问题,比静默挂起诚实)。
function ensureBinding(session) {
if (bindingValid(session)) return;
const old = session.model_id || session.last_model_id || '';
const key = chooseKey(platformOf(old), false);
if (!key) throw Object.assign(new Error('无可用模型:请检查配置并重启服务'), { status_code: 503 });
const plat = platformOf(key.id);
const modelId = chooseModel(plat, plat === platformOf(old) ? old : '');
if (!modelId) throw Object.assign(new Error('无可用模型:请检查配置并重启服务'), { status_code: 503 });
applyBinding(session.id, key, modelId);
log.info('model', session.id + ' 原绑定失效(' + (old || '无') + '),自动改选 ' + modelId + '(key ' + key.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, model_slot = 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 });
}
// 手动选定模型:占用其平台任意一个空闲 key(平台 key 全满才算被占);模型需在启用列表中。
const want = String(modelId || '');
const plat = platformOf(want);
const key = freeKeyOf(plat);
if (!key || !platformModels(plat).includes(want)) 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, key, want, pending ? 'active' : 'held');
emitStatus(sessionId);
log.info('model', sessionId + ' 手动绑定模型 ' + want + '(key ' + key.id + ')');
if (pending) runLoop(sessionId);
return { ok: true, model_id: want };
}
// 是否还有待回应的新用户消息(最后一条非 tool 消息是 user)。
function hasPendingUser(sessionId) {
const rows = loadHistory(sessionId);
@@ -405,106 +380,40 @@ function hasPendingUser(sessionId) {
return false;
}
// 为排队会话挑 key+模型:上次用过的模型(last_model_id)所在平台有空闲 key 则优先回该平台;
// 否则按「最久未用」取全局任意空闲 key。具体模型由 chooseModel 在 key 平台上定(同平台偏好上次模型)。
function pickModelFor(session) {
const want = session.last_model_id || '';
let key = want ? freeKeyOf(platformOf(want)) : null;
if (!key) key = freeModel();
if (!key) return null;
const plat = platformOf(key.id);
const model = chooseModel(plat, platformOf(want) === plat ? want : '');
return model ? { key, model } : null;
}
// 有空闲 key 就按 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;
// 上面已确认有空闲 key;若目标平台无启用模型/无空闲 key 致分配失败(理论上不会),退回队尾等下次派发。
const got = pickModelFor(session);
if (!got) { enqueue(session.id); continue; }
// 无待回应消息的会话(如新建后从未发言)只预留不占跑,绑成 held 等首条消息。
// 待开跑的压缩回合(内存 run.summarizing,见 summarizeContext)也算待处理:
// 它没有对应的用户消息行,hasPendingUser 判不到,需单独纳入。
const run0 = runs.get(session.id);
const pending = hasPendingUser(session.id) || !!(run0 && run0.summarizing);
bindModel(session, got.key, got.model, 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) {
// 手动为会话指定模型(前端弹窗任意可点,已无「占用」概念):仅回合正在输出时拒绝(换绑语义不明)。
// 模型需在启用配置中且其平台有槽位;已结版/已终止会话换绑后继续(held 待发),
// 若有未回应消息(如终止时留下未回答的提问)则直接 active 并立刻开跑。
function bindToSession(sessionId, modelId) {
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' });
if (!s) 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 want = String(modelId || '');
const plat = platformOf(want);
if (!platformModels(plat).includes(want)) throw Object.assign(new Error('模型不存在或已禁用'), { status_code: 409 });
const key = chooseKey(plat, true);
if (!key) throw Object.assign(new Error('该平台暂无可用 key(请检查配置并重启)'), { status_code: 409 });
touch(sessionId, { cancelled_at: null, completed_at: null });
applyBinding(sessionId, key, want);
const pending = hasPendingUser(sessionId);
touch(sessionId, { status: pending ? 'active' : 'held', held_at: pending ? null : now() });
emitStatus(sessionId);
dispatchQueued();
log.info('model', sessionId + ' 手动绑定模型 ' + want + '(key ' + key.id + ')');
if (pending) runLoop(sessionId);
return { ok: true, model_id: want };
}
// 用户主动「断开」: held 会话放弃保持租约,结版为 completed(区别于终止的 cancelled)
// ---------- 断开(held → completed) ----------
// 纯状态动作:key 已无独占与租约,没有任何要「释放」的东西;绑定保持,断开后再发消息仍直接沿用原模型。
// 存在的意义只是把顶部「保持中 · 模型」的状态胶囊收起来(用户确认不再追问)。
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);
touch(sessionId, { status: 'completed', completed_at: now(), held_at: null });
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(); // 不阻止进程退出
return { ok: true };
}
// ---------- 运行控制 ----------
@@ -563,14 +472,12 @@ function finalize(sessionId, run) {
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 保持租约,不释放模型,用户追问可直接复用
// 正常结束:进入 held,绑定保持(key 非独占、无租约,不再自动到期);用户追问直接复用模型,唯一出口是手动「断开」。
touch(sessionId, { status: 'held', held_at: now(), completed_at: null, cancelled_at: null });
runs.delete(sessionId);
bus.emit(sessionId, 'done', { status: 'held' });
@@ -995,69 +902,61 @@ function unwrapToolArgs(tools, name, raw) {
function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
// ---------- 对外 API ----------
// 新建即绑模(无排队):指定了优先模型(welcome 预选)就取其平台「最不 active」的 key;
// 模型无效或平台无槽位退回全局优先级选。池完全为空直接报错(配置问题),不建吊儿郎当的会话。
function createSession(title, preferModelId, assistantType, user) {
const want = String(preferModelId || '');
let key = null, modelId = '';
if (want && platformModels(platformOf(want)).includes(want)) {
key = chooseKey(platformOf(want), true);
if (key) modelId = want;
else log.warn('model', '新建会话指定模型 ' + want + ' 的平台暂无可用 key,退回全局选择');
}
if (!key) {
key = chooseKey('', false);
if (!key) throw Object.assign(new Error('无可用模型:请检查配置并重启服务'), { status_code: 503 });
modelId = chooseModel(platformOf(key.id), '') || '';
if (!modelId) throw Object.assign(new Error('无可用模型:请检查配置并重启服务'), { status_code: 503 });
}
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','advising',NULL,?,?,?,?)"
).run(id, title || '', assistantType || 'secretary', user || '', now(), now());
"INSERT INTO sessions (id, title, status, phase, model_id, model_slot, last_model_id, held_at, assistant_type, user, created_at, updated_at) VALUES (?,?,'held','advising',?,?,?,?,?,?,?,?)"
).run(id, title || '', modelId, key.id, modelId, now(), assistantType || 'secretary', user || '', now(), now());
db.prepare('UPDATE model_pool SET last_used_at = ? WHERE id = ?').run(now(), key.id);
profile.freezeSnapshot(db, id); // 冻结画像快照:仅创建/清空时点注入,会话内恒定(见 user-profile.js)
// 新会话一律落 advising(顾问模式):先聊天判意图,任务书 task.md 落地才转 executing(见 enterExecuting)
// 指定了模型且其平台恰好有空闲 key → 直接绑定,跳过排队;否则回退到 FIFO 队列
const prefer = preferModelId && platformModels(platformOf(preferModelId)).includes(preferModelId)
? freeKeyOf(platformOf(preferModelId))
: null;
if (prefer) {
// 新建时指定模型 = 仅预留(此时还没有任何消息):先绑成 held 占住 key,
// 用户发首条消息后再转 active 开跑
bindModel(getSession(id), prefer, preferModelId, 'held');
emitStatus(id);
} else {
enqueue(id);
dispatchQueued();
}
// 已绑定模型(选中的空闲模型 / 自动派发立即拿到模型)时保持 held,等首条消息再开跑。
emitStatus(id);
const session = getSession(id);
return session;
}
// 用户消息入口。
// 用户消息入口:不再排队——任意非 looping 状态都是「拿模型立即开跑」(delivered 恒 live);
// 绑定失效(配置改动后原模型被删/禁用)由 ensureBinding 自动改选,用户无感。
// 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 });
const messageId = saveMessage(sessionId, { role: 'user', content });
// 预建/更新 run 记录,记下本轮的 deepThink(被 runLoop / callModel 读取)
const run = getRun(sessionId, true);
run.deepThink = !!(opts && opts.deepThink);
// 真实用户消息到达:若还有个「已排队但尚未开跑」的压缩回合(见 summarizeContext),
// 让它作废,避免新消息被误当成压缩回合处理;已在跑(looping)的不动,
// 由其收尾时自行清空 summarizing。
if (run.summarizing && !run.looping) run.summarizing = null;
// 预建/更新 run 记录,记下本轮的 deepThink(被 runLoop / callModel 读取)
const run = getRun(sessionId, true);
run.deepThink = !!(opts && opts.deepThink);
// 真实用户消息到达:若还有个「尚未开跑」的压缩回合(见 summarizeContext),
// 让它作废,避免新消息被误当成压缩回合处理;已在跑(looping)的不动,
// 由其收尾时自行清空 summarizing。
if (run.summarizing && !run.looping) run.summarizing = 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);
// 其余全部状态(held/active 闲置/completed/cancelled/遗留 queued):确保有效绑定后直接开跑
ensureBinding(session);
touch(sessionId, { status: 'active', held_at: null, completed_at: null, cancelled_at: null });
emitStatus(sessionId);
return { message_id: messageId, delivered: after && after.status === 'active' ? 'live' : 'queued' };
runLoop(sessionId);
return { message_id: messageId, delivered: 'live' };
}
function stop(sessionId) {
@@ -1069,21 +968,17 @@ function stop(sessionId) {
killRunProcs(run);
if (run.abortController) { try { run.abortController.abort(); } catch (_) {} }
}
dequeue(sessionId);
if (session.status === 'active') {
// run 在循环退出处会 finalize;若无循环在跑则直接收尾
// 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 会话同时释放模型保持租约
touch(sessionId, { status: 'cancelled', cancelled_at: now(), held_at: null, completed_at: null });
}
emitStatus(sessionId);
dispatchQueued();
return { ok: true };
}
@@ -1107,7 +1002,6 @@ function deleteSession(sessionId, deleteDir) {
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);
autoCompressProposed.delete(sessionId); // 提议闸门随会话销毁
if (deleteDir) {
@@ -1125,8 +1019,7 @@ function deleteSession(sessionId, deleteDir) {
// 并在压缩回合的收尾答复 emit 时带 is_summary: true,前端据此把气泡装进摘要卡片并淡出存档旧历史。
// 收尾落库:摘要行标 type='summary',它之前的全部消息标 type='archived'
//(UI 保留展示、不再发给模型,后续对话从摘要开始)。
// 注意:排队等模型的压缩回合只记在内存 run 上,服务重启会丢(旧版靠库里的指令行存活);
// 重启后需重新点「压缩」。
// 注意:压缩回合标记(run.summarizing)只在内存,服务重启即丢;旧版靠库里的指令行存活。
// 限制:与 clearSessionMessages 类似——会话执行中(active)禁止操作,避免和正在跑的回合抢上下文。
// 响应回显 prompt:前端「开始压缩后渲染成一条普通用户消息气泡」;只回一句短提示,
// 不回完整模板(压缩指令的真实内容在压缩回合开跑时实时序列化进 system prompt,
@@ -1139,34 +1032,16 @@ function summarizeContext(sessionId) {
throw Object.assign(new Error('任务正在执行,请先「终止」再压缩'), { status_code: 409 });
}
const prompt = '正在压缩上下文:AI 将基于完整对话记录生成摘要…';
// 与 postUserMessage 同样的唤醒/排队流转,但不落任何消息行;
// run.summarizing 标记本回合为压缩回合,摘要产出后由 runLoopInner 清空。
// 与 postUserMessage 同样的唤醒语义(不再排队、不落消息行);run.summarizing 标记本回合为压缩回合,摘要产出后由 runLoopInner 清空。
// 状态流转时顺带重置 deepThink:压缩回合不需要思考参数,避免沿用上一轮的残留值。
const r = getRun(sessionId, true);
r.summarizing = true;
r.deepThink = false;
let delivered;
if (session.status === 'held') {
// 保持租约期内:直接复用当前绑定的模型,无需排队
touch(sessionId, { status: 'active', held_at: null });
emitStatus(sessionId);
runLoop(sessionId);
delivered = 'live';
} else if (session.status === 'active') {
// 上方已排除 looping;active 空闲时直接开跑
runLoop(sessionId);
delivered = 'live';
} else {
// 排队 / 已完成 / 已终止 → 重新入队;若派发后已立即拿到空闲模型,则算直接送达
//(dispatchQueued 会把带 summarizing 的排队会话当作有待处理回合开跑)
touch(sessionId, { status: 'queued', cancelled_at: null, completed_at: null, held_at: null });
enqueue(sessionId);
dispatchQueued();
const after = getSession(sessionId);
emitStatus(sessionId);
delivered = after && after.status === 'active' ? 'live' : 'queued';
}
return { prompt, delivered };
ensureBinding(session);
touch(sessionId, { status: 'active', held_at: null, completed_at: null, cancelled_at: null });
emitStatus(sessionId);
runLoop(sessionId);
return { prompt, delivered: 'live' };
}
// 自动压缩确认前的宽限期(ms):超长回合刚结束时,前端还在收尾渲染(最终消息落 DOM、会话列表刷新等),
@@ -1182,7 +1057,7 @@ const autoCompressProposed = new Set();
// 由前端弹 modal 询问,用户点「立即压缩」后才 POST /summarize 开启与手动「摘要」完全相同的压缩回合。
// 每会话至多提议一次(autoCompressProposed 闸门):取消/忽略后不再反复弹窗,想压可手动点「压缩」。
// 护栏:压缩回合自身不再检查(防递归);被终止的回合不触发;仅正常收尾进入 held 后触发;
// 延迟期间用户抢先发言/手动压缩/终止、租约到期释放都会改动 status 或 held_at,回调里校验后放弃推送;
// 延迟期间用户抢先发言/手动压缩/终止、手动断开都会改动 status 或 held_at,回调里校验后放弃推送;
// 无 SSE 观看者时事件静默丢弃且不计数(提议本就是交互式功能,下个超长回合还会再试)。
function maybeAutoCompress(sessionId, run, wasCompressTurn) {
try {
@@ -1214,9 +1089,8 @@ function maybeAutoCompress(sessionId, run, wasCompressTurn) {
}
}
// 清空会话的对话内容:删除该会话的全部消息记录,但保留会话本身与任务目录文件。
// 状态收尾为 completed(释放模型占用、移出等待队列);此后再次发言从零开始,
// 不再携带旧历史。执行中的会话不允许清空,需先「终止」。
// 清空会话的对话内容:删除该会话的全部消息记录,但保留会话本身与任务目录文件(绑定也保持,下次发言沿用原模型)。
// 状态收尾为 completed;此后再次发言从零开始,不再携带旧历史。执行中的会话不允许清空,需先「终止」。
// 阶段语义:清空是 executing 唯一回头路——回到 advising 重新规划(单会话只解决一个问题),
// 旧任务书 mv 进 .task-history/ 防污染(archiveTaskBrief);压缩不碰 phase,不在此列。
function clearSessionMessages(sessionId) {
@@ -1232,8 +1106,6 @@ function clearSessionMessages(sessionId) {
if (run.abortController) { try { run.abortController.abort(); } catch (_) {} }
}
runs.delete(sessionId);
dequeue(sessionId);
releaseModel(sessionId);
db.prepare('DELETE FROM messages WHERE session_id = ?').run(sessionId);
archiveTaskBrief(sessionId); // 旧任务书先归档(mv),新一轮 advising 不会被上一问题的约定污染
autoCompressProposed.delete(sessionId); // 历史清零,恢复自动压缩提议额度
@@ -1245,7 +1117,6 @@ function clearSessionMessages(sessionId) {
bus.emit(sessionId, 'title', { title: null }); // 供其他打开同一会话的窗口同步清掉旧标题
bus.emit(sessionId, 'phase', { phase: 'advising' });
emitStatus(sessionId);
dispatchQueued();
return { ok: true };
}
@@ -1324,10 +1195,8 @@ module.exports = {
taskDirOf,
loadHistory,
saveMessage,
queuePosition,
recordModelUsage,
modelUsageStats,
dispatchQueued,
bindToSession,
TOOL_DEFINITIONS,
effectiveTools,
+1 -1
View File
@@ -338,7 +338,7 @@
userPaused = false;
removeTyping();
renderHeader();
updatePhaseBar({ model_id: s && s.model_id, queue_pos: detail.queue_pos });
updatePhaseBar({ model_id: s && s.model_id });
const box = $('chat-view');
box.innerHTML = '';
appendMessagesDom(detail.messages || [], box).closeArc();
+1 -1
View File
@@ -12,7 +12,7 @@
* POST /api/sessions/:id/files 附件上传(multipart)
* GET /api/sessions/:id/stream SSE 流式输出
* POST /api/sessions/:id/stop | /release 状态栏「终止/断开」
* POST /api/sessions/:id/bind {model_id} 状态栏「选择模型」(已完成/已终止会话)
* POST /api/sessions/:id/bind {model_id} 状态栏「选择模型」(任意可选,仅输出中拒绝)
* DELETE /api/sessions/:id/messages 状态栏「清空」(会话内删除已移除,清空由这里承担)
* DELETE /api/sessions/:id/messages/:messageId 删除单条消息/工具卡(删 assistant 连带工具回执;单删工具卡同步摘除父调用)
* GET /api/models 状态栏「选择模型」弹窗模型列表
+19 -23
View File
@@ -10,8 +10,8 @@
return d.getFullYear() + '年' + (d.getMonth() + 1) + '月';
}
// 抽屉行状态指示:仅进行中的会话(排队/活跃/保持)展示彩色圆点,已完成/已终止不显示
const DRAWER_STATUS_TEXT = { queued: '排队中', active: '活跃中', held: '保持中' };
// 抽屉行状态指示:仅进行中的会话(活跃/保持)展示彩色圆点,已完成/已终止不显示(排队已废弃)
const DRAWER_STATUS_TEXT = { active: '活跃中', held: '保持中' };
function drawerStatusDot(s) {
const st = s && s.status;
const label = DRAWER_STATUS_TEXT[st];
@@ -258,26 +258,26 @@
if (!(state.view === 'chat' && state.sessionId)) { bar.classList.add('hidden'); return; }
bar.classList.remove('hidden');
const pill = $('status-pill');
const stMap = { queued: '排队中', active: '活跃中', held: '保持中', completed: '已完成', cancelled: '已终止' };
const stMap = { active: '活跃中', held: '保持中', completed: '已完成', cancelled: '已终止' };
let text = stMap[state.status] || state.status || '--';
if (d && d.queue_pos) text += '(第 ' + d.queue_pos + ' 位)';
// active/held 时附带当前占用的模型
if ((state.status === 'active' || state.status === 'held') && d && d.model_id) {
// 持有绑定的态都附带当前模型:key 非独占、无租约,绑定跨结版持续可见;
// 仅手动「断开」(held→completed)收起展示,「终止」不算断开(绑定仍在,再发言沿用)
if (d && d.model_id && state.status !== 'completed') {
text += ' · ' + d.model_id;
}
pill.textContent = text;
// 状态胶囊配色:活跃中绿(执行中)、保持中黄(已答完、保持模型中)等;状态栏整体同步染色
pill.className = 'status-pill ' + (state.status || '');
bar.className = 'phase-bar ' + (state.status || '');
// 活跃中提供「终止」;保持中改为「断开」(主动放弃保持租约,会话结为已完成)
// 活跃中提供「终止」;保持中改为「断开」(纯状态动作:收起保持态徽标,绑定仍在、再发言继续用原模型)
const btn = $('stop-btn');
const actionable = state.status === 'active' || state.status === 'held';
btn.classList.toggle('hidden', !actionable);
btn.textContent = state.status === 'held' ? '断开' : '终止';
btn.classList.toggle('muted', state.status === 'held');
// 已完成/已终止时提供「选择模型」,手动指定空闲模型后继续对话
// 非输出中都可「选择模型」:key 不再独占/排队,任意模型即点即换(后端仅 looping 拒绝)
const msBtn = $('model-switch-btn');
if (msBtn) msBtn.classList.toggle('hidden', !(state.sessionId && (state.status === 'completed' || state.status === 'cancelled')));
if (msBtn) msBtn.classList.toggle('hidden', !(state.sessionId && state.status && state.status !== 'active'));
// 状态栏「压缩」按钮:active 时不允许(避免与正在跑的回合抢上下文);
// 其余状态可点。未发起总结时可点;发起后按钮 disabled 防双击。
const cpBtn = $('compress-btn');
@@ -415,7 +415,7 @@
try {
if (held) {
await req('POST', '/api/sessions/' + state.sessionId + '/release');
toast('已断开,模型已释放');
toast('已断开');
} else {
await req('POST', '/api/sessions/' + state.sessionId + '/stop');
toast('已发送终止指令');
@@ -440,8 +440,8 @@
} else {
// 平台颜色盘(循环使用)
const DOT_COLORS = ['#3B82F6','#10B981','#F59E0B','#EF4444','#8B5CF6','#EC4899','#06B6D4','#F97316'];
// 按平台分组;/api/models 已按模型聚合槽位:slots_total/slots_busy = 该模型的 key 总数/被占数,
// is_busy 仅在全部 key 被占时为真(同模型还剩空闲 key 就仍可再选)。
// 按平台分组;/api/models 已按模型聚合槽位:slots_total/slots_used = 该模型的 key 总数/在用会话数。
// 任意模型都可点:key 不再独占也不再排队,选「在用」的不影响任何会话(共享并发)。
const platMap = new Map();
for (const m of rows) {
const pk = m.platform || '';
@@ -451,20 +451,16 @@
platMap.get(pk).models.push(m);
}
const groups = [...platMap.values()];
// 可选 = 模型还有空闲 key 槽位;统计可用数供底部提示
for (const g of groups) for (const m of g.models) if (!m.is_busy) avail++;
avail = rows.length; // 底部提示改报模型总数(已无「空闲」概念)
modelsHtml = groups.map((g, gi) => {
const dotColor = DOT_COLORS[gi % DOT_COLORS.length];
const itemHtml = g.models.map(m => {
const total = m.slots_total || g.keyCount || 1;
const free = total - (m.slots_busy || 0);
const disabled = !!m.is_busy;
const title = m.is_busy ? ' 占用中' : ((m.slots_busy || 0) > 0 ? ' ' + free + '/' + total + ' key 空闲' : '');
const used = m.slots_used || 0;
const title = used ? ' 在用×' + used : '';
// 无会话 = welcome 入口:点模型只记预选(建档时透传 model_id),不直接绑定
const act = state.sessionId ? 'bindModel' : 'choosePendingModel';
const pre = !state.sessionId && state.pendingModel === m.id ? ' <span class="msw-busy">预选</span>' : '';
return '<div class="msw-item' + (disabled ? ' disabled' : '') + '"' +
(disabled ? '' : ' onclick="' + act + '(\'' + esc(m.id) + '\')"') + '>' +
return '<div class="msw-item" onclick="' + act + '(\'' + esc(m.id) + '\')">' +
'<div class="msw-radio"></div>' +
'<div class="msw-info">' +
'<div class="msw-name">' + esc(m.display_name || m.mid || m.id) +
@@ -489,9 +485,9 @@
} catch (e) {
modelsHtml = '<div class="empty-tip">读取模型列表失败:' + e.message + '</div>';
}
// 空闲数并进顶部提示句(原 footer「共 X 个模型可用」不再单独占行)
// 总数并进顶部提示句(原 footer「共 X 个模型可用」不再单独占行)
if (sub) sub.textContent = (state.sessionId ? '选择一个模型继续当前会话' : '选择一个模型用于新会话')
+ (avail ? '(共 ' + avail + ' 个空闲)' : '');
+ (avail ? '(共 ' + avail + ' 个模型)' : '');
list.innerHTML = modelsHtml;
}
function closeModelSwitch() { $('bind-model-modal').classList.add('hidden'); }
@@ -510,7 +506,7 @@
await req('POST', '/api/sessions/' + id + '/bind', { model_id: modelId });
toast('已绑定模型 ' + modelId);
} catch (e) { toast('绑定失败:' + e.message); }
// 无论成败都刷新会话详情(失败多为并发占用,状态可能已变);按已加载量分页重渲染,避免长会话退回全量重建
// 无论成败都刷新会话详情(失败多为正在输出中换绑被拒,状态可能已变);按已加载量分页重渲染,避免长会话退回全量重建
try {
const detail = await req('GET', '/api/sessions/' + id + '?limit=' + Math.max(CHAT_PAGE_SIZE, state.chatLoadedCount));
if (state.sessionId === id) { renderDetail(detail); connectStream(); }
+2 -7
View File
@@ -410,11 +410,6 @@
{ path: 'upload.image_quality', label: 'JPEG 质量(0~1)', type: 'float' },
{ path: 'upload.confirm_size_mb', label: '大文件确认阈值(MB)', type: 'int' },
] },
{ group: '模型租约(会话结束后的保持)', items: [
{ path: 'model_hold.idle_release_ms', label: '无人观看释放(ms)', type: 'int' },
{ path: 'model_hold.active_max_ms', label: '最长保持(ms)', type: 'int' },
{ path: 'model_hold.sweep_ms', label: '巡检间隔(ms)', type: 'int' },
] },
];
function kvPlain(label, v) {
return '<div class="cfg-kv"><label>' + esc(label) + '</label><b>' + esc(dispVal(v)) + '</b></div>';
@@ -927,13 +922,13 @@
? '<span class="model-card-state pending">待重启</span>'
: '<span class="model-card-state off">已禁用</span>')
: run
? '<span class="model-card-state ' + (run.is_busy ? 'busy' : 'idle') + '">' + (run.is_busy ? '占用中' : '空闲') + '</span>'
? '<span class="model-card-state ' + (run.slots_used ? 'busy' : 'idle') + '">' + (run.slots_used ? '在用×' + run.slots_used : '空闲') + '</span>'
: '<span class="model-card-state pending">待重启</span>';
return '<div class="model-card' + (disabled ? ' off' : '') + '" title="点击编辑平台" onclick="sUI.mEdit(' + pi + ')">' +
'<div class="model-card-head">' +
'<span class="model-card-name">' + esc(m.display_name || m.mid || m.id) + '</span>' +
'<span class="model-card-meta">' + esc(m.mid || m.id) +
(run && run.is_busy && run.current_session_id ? ' · 会话 ' + esc(run.current_session_id) : '') + '</span>' +
(run && run.slots_used && run.current_session_id ? ' · 会话 ' + esc(run.current_session_id) : '') + '</span>' +
stateHtml +
'<label class="model-en-sw" title="' + (disabled ? '已禁用,点击启用' : '启用中,点击禁用') + '" onclick="event.stopPropagation()">' +
'<input type="checkbox"' + (disabled ? '' : ' checked') + ' onchange="sUI.mToggleEnable(\'' + encodeURIComponent(m.id) + '\')">' +
+2 -3
View File
@@ -34,13 +34,13 @@ router.post('/:id/stop', wrap((req, res) => {
res.json(r);
}));
// 断开:held 会话主动放弃模型保持租约,结版为已完成(非终止)
// 断开:held 会话收起「保持中」态,结版为已完成(纯状态动作:key 非独占,无模型可释放,绑定仍在可继续用)
router.post('/:id/release', wrap((req, res) => {
res.json(engine.releaseHold(req.params.id));
}));
// 清空会话内容:删除全部消息记录,保留会话本身与任务目录文件(不再随下条消息重发旧历史)。
// 状态收尾为已完成并释放模型/出队;正在执行的回合会被拒绝(需先「终止」)。
// 状态收尾为已完成(绑定保持,下次发言沿用原模型);正在执行的回合会被拒绝(需先「终止」)。
router.delete('/:id/messages', wrap((req, res) => {
const r = engine.clearSessionMessages(req.params.id);
log.info('msg', (req.user || '-') + ' ' + req.params.id + ' 清空会话内容(文件保留)');
@@ -99,7 +99,6 @@ router.get('/:id/stream', (req, res) => {
status: session.status,
phase: session.phase,
model_id: session.model_id,
queue_pos: session.status === 'queued' ? engine.queuePosition(session.id) : null,
});
});
+3 -12
View File
@@ -90,7 +90,7 @@ router.post('/', wrap((req, res) => {
}));
// 列表查询参数(2.0):
// status=active|done|all 归档分组:active=排队/活跃/保持,done=已完成/已终止
// status=active|done|all 归档分组:active=活跃/保持(含遗留 queued),done=已完成/已终止
// q=关键词 标题或消息内容 LIKE 搜索
// before + before_id 游标分页(上一页末行的 updated_at,id),避免 offset 翻页在
// updated_at 变动时重复/漏行
@@ -128,15 +128,6 @@ router.get('/', wrap((req, res) => {
+ whereSql + ' ORDER BY updated_at DESC, id DESC LIMIT ?'
);
const rows = stmt.all.apply(stmt, args.concat([limit]));
const qpos = db.prepare(
'SELECT session_id, ROW_NUMBER() OVER (ORDER BY queued_at, id) AS pos FROM wait_queue'
).all();
const posMap = {};
for (const r of qpos) posMap[r.session_id] = r.pos;
for (const row of rows) {
row.queue_pos = row.status === 'queued' ? (posMap[row.id] || null) : null;
}
if (req.query.with_total === '1') {
const cnt = db.prepare('SELECT COUNT(*) AS n FROM sessions' + whereSql);
const total = cnt.all.apply(cnt, args)[0].n;
@@ -216,7 +207,6 @@ router.get('/:id', wrap((req, res) => {
messages,
files: listTaskFiles(taskDir),
schedule,
queue_pos: session.status === 'queued' ? engine.queuePosition(session.id) : null,
running: !!(engine.getRun(session.id) || {}).looping,
has_more: hasMore, // 分页模式下:是否还有更早的历史
oldest_id: messages.length ? messages[0].id : null, // 本页最早行 id,作为下一页 before 游标
@@ -226,7 +216,8 @@ router.get('/:id', wrap((req, res) => {
// 按需加载单条消息的完整内容(用于 tool 消息的懒加载)
router.get('/:id/messages/:mid', wrap(getMessage));
// 手动占用空闲模型(仅已结版/已终止可绑,见 bindToSession):状态栏「选择模型」弹窗发起。
// 手动为会话指定模型(状态栏「选择模型」弹窗发起):不再排队/不再独占,任意空闲与否都可绑;
// 仅会话正在输出(looping)时拒绝(见 engine.bindToSession)。
// 曾有的 profile 会话模式绑定已废弃:profile 只由「阶段强制 + 模型配置默认」决定(见 engine.resolveProfileName)。
router.post('/:id/bind', wrap((req, res) => {
const mid = (req.body || {}).model_id;
+7 -7
View File
@@ -3,10 +3,10 @@
// 先把会话历史整体存档(type='archived',llm.buildMessages 会跳过 → AI 只看到本次
// prompt,等价全新会话),再经 engine.postUserMessage 投递任务 prompt 自动开跑,
// 结果留在会话里供用户次日查看。
// 形态照抄 engine.js 的 startHoldSweeper:模块级 timer + setInterval + unref,
// 单次异常只记日志,绝不中断定时器。
// 启动时序:必须在 engine.init() 之后调 start(engine)(见 server.js)——
// engine.init() 先把 active 退回队列 / held 结版归位,首轮 tick 才不会看到脏状态。
// 形态:模块级 timer + setInterval + unref(同旧版 engine 的 holdSweeper,该定时器已随
// 「key 不独占不排队」改造删除),单次异常只记日志,绝不中断定时器。
// 启动时序:在 engine.init() 之后调 start(engine)(见 server.js)——init 先把会话状态归位,
// 首轮 tick 才不会看到脏状态。
// 依赖注入 engine 而非 require('./engine'):engine→executor→scheduler 已有引用链,
// 顶层反向 require 会成环拿到半成品 exports。
const { CronExpressionParser } = require('cron-parser'); // 锁定 v5.10.1:API 是 CronExpressionParser.parse(v4 的 parseExpression 已不存在)
@@ -116,9 +116,9 @@ function archiveHistory(db, sessionId) {
}
// 投递 + 复活一体:postUserMessage 已按会话当时状态全量流转,无需单独复活步骤——
// held → 转 active 立即开跑(注意:会抢占保持中的模型);
// queued / completed / cancelled → 重新入队并尝试派发:有空闲模型当轮即跑,
// 没有则留在队列等 dispatchQueued(正是「半夜无人值守排队执行」场景,不是异常)。
// 新调度下不再有排队:任意非 looping 态(held/completed/cancelled)都直接拿模型开跑(恒 delivered:'live');
// 绑定模型已被配置改动失效时由 ensureBinding 自动改选(优先留原平台);
// 仅模型池整体为空会抛错(tick 捕获后标 last_status=error,不阻塞其它任务)。
function deliver(sessionId, prompt) {
return eng.postUserMessage(sessionId, prompt);
}
+14 -14
View File
@@ -62,19 +62,19 @@ app.use(require('./routes/data-page'));
// model_pool 表只有 id/display_name/占用态,会话页「选择模型」弹窗需要按平台分组展示。
// 配置里新增但重启前未进池的模型不在此返回(池才是运行时真相)。
app.get('/api/models', (req, res) => {
// 池行是平台物理 key(id=「平台#下标」):key 为平台下模型共享资源,
// 按模型聚合返回:slots_total/slots_busy = 平台 key 总数/被占数,is_busy = 平台 key 全满(其下所有模型都不可选)。
const keyRows = db.prepare('SELECT id, is_busy, current_session_id FROM model_pool').all();
// 池行是平台物理 key(id=「平台#下标」):key 为共享资源——非独占,多个会话可同时绑同一个 key
// 并发 looping(调度只是优先级选 key,见 engine.chooseKey)。
// 「在用」按 sessions 实时算:各平台 key 上绑着的 active/held 会话数(展示用途,无「不可选」语义)。
const keyRows = db.prepare('SELECT id FROM model_pool').all();
const totalByPlat = {};
const busyByPlat = {};
const sessByPlat = {};
for (const r of keyRows) {
const plat = r.id.split('#')[0];
totalByPlat[plat] = (totalByPlat[plat] || 0) + 1;
if (r.is_busy) {
busyByPlat[plat] = (busyByPlat[plat] || 0) + 1;
if (r.current_session_id) (sessByPlat[plat] = sessByPlat[plat] || []).push(r.current_session_id);
}
}
for (const s of db.prepare("SELECT id, model_slot FROM sessions WHERE model_slot IS NOT NULL AND status IN ('active','held')").all()) {
const plat = String(s.model_slot).split('#')[0];
(sessByPlat[plat] = sessByPlat[plat] || []).push(s.id);
}
// 模型行取自生效配置(cfg 重启生效,与池同步):按模型 id 去重、保留配置顺序,禁用模型不返回。
const cfgNow = engine.getConfig();
@@ -84,14 +84,14 @@ app.get('/api/models', (req, res) => {
if (m.enable === false || seen.has(m.id)) continue;
seen.add(m.id);
const total = totalByPlat[m.platform] || 0;
const busy = busyByPlat[m.platform] || 0;
const using = sessByPlat[m.platform] || [];
rows.push({
id: m.id, display_name: m.display_name, platform: m.platform, mid: m.mid,
vision: !!m.vision, type: m.type, key_count: total,
profile: m.profile || '', // 模型默认 prompt+tools 组合(model_profiles 名,空 = 全量)
slots_total: total, slots_busy: busy,
is_busy: total > 0 && busy >= total ? 1 : 0,
current_session_id: (sessByPlat[m.platform] || []).join(','),
slots_total: total,
slots_used: using.length, // 在用会话数(active/held,可超 key 数:共享不独占)
current_session_id: using.join(','), // 在用会话 id 列表(展示用)
});
}
const stats = engine.modelUsageStats();
@@ -173,8 +173,8 @@ mcp.init(cfg).then(async () => {
// 优雅退出(照抄 executor/server.js 的 shutdown 形态):node 在容器里是 PID 1,
// 不显式注册监听时 SIGTERM 会被直接忽略,docker stop/restart 只能白等满
// stop_grace_period(默认 10s)后被 SIGKILL。scheduler/holdSweeper 的 timer
// 均已 unref,退出只需收掉监听与 SSE 长连接。
// stop_grace_period(默认 10s)后被 SIGKILL。scheduler 的 timer 已 unref,
// 退出只需收掉监听与 SSE 长连接。
function shutdown(sig) {
log.info('shutdown', '收到 ' + sig + ',停止服务');
bus.closeAllSessions(); // 给前端干净的流结束(走重连/回放),而不是 TCP reset