aicodeswitch 5.2.13 → 6.0.0

package/dist/server/agent-map/agent-map-service.js

@@ -28,15 +28,27 @@ const events_1 = require("events");
 const activity_extractor_1 = require("./activity-extractor");
 const session_meta_1 = require("./session-meta");
 const notifier_1 = require("../notifier");
-const ACTIVE_WINDOW_MS = 60000; // 最近 60s 内有活动 → active
-const IDLE_WINDOW_MS = 10 * 60000; // 10min 内有活动但超过 active 窗口 → idle；超出 → completed
-const SWEEP_INTERVAL_MS = 15000; // 每 15s 扫描一次状态迁移
+const IDLE_WINDOW_MS = 10 * 60000; // 无在途请求后，10min 内 → idle；超出 → completed
+const SWEEP_INTERVAL_MS = 15000; // 每 15s 扫描一次状态迁移（含在途陈旧度检查）
 const MAX_EVENTS_PER_SESSION = 200;
 const MAX_GLOBAL_EVENTS = 500;
 const RECENT_WINDOW_FOR_STATS_MS = 60000;
+// SSE 流「静默」判定：流已开始产出后，超过该时长无新 chunk 视为停滞（用户规范：30s）。
+const SSE_SILENCE_MS = 30000;
+// Thinking（思考）请求的静默上限：思考类模型在首 Token 后、正式内容前常有较长静默思考期
+// （部分上游不流式下发 thinking token），需比普通 SSE 30s 更宽松，避免误判停滞。
+const THINKING_SILENCE_MS = 3 * 60000;
+// 同步请求 / SSE 首 Token 前的「最长存活」保护：服务中断导致请求永不返回时，
+// 超过该时长强制结束（用户规范：5min），避免会话永远卡在「进行中」。
+const SYNC_MAX_MS = 5 * 60000;
 // 「一轮结束」OS 通知冷却：同一会话在此窗口内的多次 active→idle（典型来自主轮之后的
 // 后台/计数/compact 等续发请求，每个 end_turn 都会再触发一次迁移）只弹一次，避免重复打扰。
 const NOTIFY_COOLDOWN_MS = 60000;
+// 「任务结束」防抖延迟（同时作用于：展示状态保持 active 的时长 + 结束通知的弹前等待）：
+// 检测到任务结束时，先保持「进行中」满该时长，期满且无新请求才落实「空闲」并弹通知；若期间发起新
+// 主请求（用户/客户端马上继续下一轮），lastActivityAt 刷新 + 取消挂起通知 → 继续保持「进行中」。
+// 避免「每轮结束都闪一下空闲 / 都弹通知」，也兜底吸收 end_turn 误判。
+const NOTIFY_DEBOUNCE_MS = 8000;
 // 启动重建：只回填最近 1h 内有活动的会话，每会话最多回填 N 条事件，避免重复解析大量历史分片
 const REBUILD_SINCE_MS = 60 * 60000;
 const REBUILD_EVENTS_PER_SESSION = 30;
@@ -83,17 +95,29 @@ class AgentMapService extends events_1.EventEmitter {
             value: false
         });
         // 阈值可调（供测试/配置覆盖）
-        Object.defineProperty(this, "activeWindowMs", {
+        Object.defineProperty(this, "idleWindowMs", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: ACTIVE_WINDOW_MS
+            value: IDLE_WINDOW_MS
         });
-        Object.defineProperty(this, "idleWindowMs", {
+        Object.defineProperty(this, "sseSilenceMs", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: IDLE_WINDOW_MS
+            value: SSE_SILENCE_MS
+        });
+        Object.defineProperty(this, "thinkingSilenceMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: THINKING_SILENCE_MS
+        });
+        Object.defineProperty(this, "syncMaxMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: SYNC_MAX_MS
         });
         this.setMaxListeners(50);
     }
@@ -131,9 +155,14 @@ class AgentMapService extends events_1.EventEmitter {
                         continue;
                     const lastRequestAt = s.lastRequestAt || s.firstRequestAt || now;
                     const { status, reason } = this.inferStatus({
-                        lastRequestAt,
+                        lastActivityAt: lastRequestAt,
                         lastStatusCode: s.lastStatusCode,
                         inFlight: 0,
+                        streamingInFlight: 0,
+                        thinkingInFlight: 0,
+                        streamFirstChunkAt: 0,
+                        inFlightSince: 0,
+                        lastTurnEnd: null,
                         now,
                     });
                     this.states.set(s.id, {
@@ -145,6 +174,10 @@ class AgentMapService extends events_1.EventEmitter {
                         lastRequestAt,
                         requestCount: s.requestCount || 0,
                         totalTokens: s.totalTokens || 0,
+                        inputTokens: s.inputTokens || 0,
+                        outputTokens: s.outputTokens || 0,
+                        runningInputTokens: 0,
+                        runningOutputTokens: 0,
                         lastToolName: s.lastToolName,
                         lastActivitySummary: s.lastActivitySummary,
                         lastStatusCode: s.lastStatusCode,
@@ -152,6 +185,13 @@ class AgentMapService extends events_1.EventEmitter {
                         status,
                         statusReason: reason,
                         inFlight: 0,
+                        lastActivityAt: lastRequestAt,
+                        streamingInFlight: 0,
+                        thinkingInFlight: 0,
+                        streamFirstChunkAt: 0,
+                        inFlightSince: 0,
+                        notifiedForTurn: false,
+                        notifyTimer: null,
                     });
                 }
                 this.broadcastStats();
@@ -283,7 +323,13 @@ class AgentMapService extends events_1.EventEmitter {
             }
         });
     }
-    // ============ 在途请求注册表 ============
+    // ============ 在途请求注册表 + 可靠活动追踪 ============
+    /**
+     * 请求开始：在途计数 + 活动时钟刷新。
+     * - background=true（count_tokens / compact / 后台请求）：刷新活动、计入在途，用于「是否还活着」判定；
+     *   但不重置 notifiedForTurn —— 这样主任务结束后紧跟的后台请求不会再次触发结束通知。
+     * - background=false（主轮请求）：视为「新一轮用户任务」，重置 notifiedForTurn，允许结束时再弹一次通知。
+     */
     startRequest(sessionId, agent, opts) {
         if (!sessionId || sessionId === '-')
             return;
@@ -301,14 +347,38 @@ class AgentMapService extends events_1.EventEmitter {
                 lastRequestAt: now,
                 requestCount: 0,
                 totalTokens: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                runningInputTokens: 0,
+                runningOutputTokens: 0,
                 status: 'active',
                 statusReason: 'in-flight',
                 inFlight: 0,
+                lastActivityAt: now,
+                streamingInFlight: 0,
+                thinkingInFlight: 0,
+                streamFirstChunkAt: 0,
+                inFlightSince: now,
+                notifiedForTurn: false,
+                notifyTimer: null,
             };
             this.states.set(sessionId, st);
         }
+        if (st.inFlight === 0) {
+            // 新的一批在途开始：记录起跑时刻（同步请求 5min 超时基线）
+            st.inFlightSince = now;
+            st.streamFirstChunkAt = 0;
+        }
         st.inFlight += 1;
+        if (opts === null || opts === void 0 ? void 0 : opts.thinking)
+            st.thinkingInFlight += 1;
         st.lastRequestAt = now;
+        st.lastActivityAt = now;
+        if (!(opts === null || opts === void 0 ? void 0 : opts.background)) {
+            // 主轮（用户发起的新任务）：会话再次活跃 → 取消上一轮可能挂起的结束通知（防抖），并重置通知标记
+            this.cancelNotifyTimer(st);
+            st.notifiedForTurn = false;
+        }
         // 有在途请求必然 active
         if (st.status !== 'active') {
             st.status = 'active';
@@ -316,17 +386,95 @@ class AgentMapService extends events_1.EventEmitter {
         }
         this.emitSession(st);
     }
-    endRequest(sessionId) {
+    /** SSE 流真正开始（pipeline 已建立）。记一个在途流，并刷新活动时钟（首 Token 仍待 heartbeat 标记）。 */
+    markStreaming(sessionId) {
+        if (!sessionId || sessionId === '-')
+            return;
+        const st = this.states.get(sessionId);
+        if (!st)
+            return;
+        st.streamingInFlight += 1;
+        st.lastActivityAt = Date.now();
+    }
+    /**
+     * SSE chunk 心跳：每流经一个下游 chunk 刷新一次活动时钟（节流由调用方负责）。
+     * 可附带当前流式请求的实时累计 usage（input/output）：写入 running 计数并广播 session-update，
+     * 使前端节点在流式过程中随 token 增长实时上移。finalize 时 onFinalized 会把最终值并入累计并清零 running。
+     */
+    heartbeat(sessionId, usage) {
+        if (!sessionId || sessionId === '-')
+            return;
+        const st = this.states.get(sessionId);
+        if (!st)
+            return;
+        const now = Date.now();
+        st.lastActivityAt = now;
+        if (st.streamFirstChunkAt === 0)
+            st.streamFirstChunkAt = now;
+        if (usage) {
+            st.runningInputTokens = usage.inputTokens || 0;
+            st.runningOutputTokens = usage.outputTokens || 0;
+            this.emitSession(st);
+        }
+    }
+    /** 请求结束：在途计数递减（流式请求同时递减在途流计数，思考请求递减思考计数）。不立即改 status，由 onFinalized / reevaluate / sweep 决定。 */
+    endRequest(sessionId, opts) {
         if (!sessionId || sessionId === '-')
             return;
         const st = this.states.get(sessionId);
         if (!st)
             return;
         st.inFlight = Math.max(0, st.inFlight - 1);
-        // 不立即改 status，由 onFinalized 的重算决定
+        if (opts === null || opts === void 0 ? void 0 : opts.isStream)
+            st.streamingInFlight = Math.max(0, st.streamingInFlight - 1);
+        if (opts === null || opts === void 0 ? void 0 : opts.thinking)
+            st.thinkingInFlight = Math.max(0, st.thinkingInFlight - 1);
+        st.lastActivityAt = Date.now();
+        if (st.inFlight === 0) {
+            st.inFlightSince = 0;
+            st.streamingInFlight = 0;
+            st.thinkingInFlight = 0;
+            st.streamFirstChunkAt = 0;
+            // 在途已清空：实时累计让位给 onFinalized 的最终累计，避免双算
+            st.runningInputTokens = 0;
+            st.runningOutputTokens = 0;
+        }
+    }
+    /**
+     * 重算单个会话状态并广播（含通知判定）。供 onFinalized / 安全网 / REST 主动刷新复用。
+     * 返回是否有状态变化。
+     */
+    reevaluate(sessionId) {
+        if (!sessionId || sessionId === '-')
+            return false;
+        const st = this.states.get(sessionId);
+        if (!st)
+            return false;
+        const prevStatus = st.status;
+        const { status, reason } = this.inferStatus({
+            lastActivityAt: st.lastActivityAt,
+            lastStatusCode: st.lastStatusCode,
+            inFlight: st.inFlight,
+            streamingInFlight: st.streamingInFlight,
+            thinkingInFlight: st.thinkingInFlight,
+            streamFirstChunkAt: st.streamFirstChunkAt,
+            inFlightSince: st.inFlightSince,
+            lastTurnEnd: st.lastTurnEnd,
+            now: Date.now(),
+        });
+        if (status === prevStatus && reason === st.statusReason)
+            return false;
+        st.status = status;
+        st.statusReason = reason;
+        // 安全网路径（finalizeLog 未走 onFinalized 的泄漏场景）：脱离 active 时补调度防抖通知
+        if (status !== 'active')
+            this.considerEndNotify(st, status === 'error');
+        this.emitSession(st);
+        return true;
     }
     // ============ 请求收尾：抽事件 + 重算状态 + 广播 ============
     onFinalized(ctx) {
+        var _a;
         if (!ctx.sessionId || ctx.sessionId === '-')
             return;
         const extractInput = {
@@ -374,8 +522,19 @@ class AgentMapService extends events_1.EventEmitter {
                 lastRequestAt: ctx.timestamp,
                 requestCount: 0,
                 totalTokens: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                runningInputTokens: 0,
+                runningOutputTokens: 0,
                 status: 'active',
                 inFlight: 0,
+                lastActivityAt: ctx.timestamp,
+                streamingInFlight: 0,
+                thinkingInFlight: 0,
+                streamFirstChunkAt: 0,
+                inFlightSince: ctx.timestamp,
+                notifiedForTurn: false,
+                notifyTimer: null,
             };
             this.states.set(ctx.sessionId, st);
         }
@@ -392,6 +551,10 @@ class AgentMapService extends events_1.EventEmitter {
         st.requestCount += 1;
         if (ctx.tokensDelta)
             st.totalTokens += ctx.tokensDelta;
+        if (ctx.inputTokensDelta)
+            st.inputTokens += ctx.inputTokensDelta;
+        if (ctx.outputTokensDelta)
+            st.outputTokens += ctx.outputTokensDelta;
         if (ctx.model)
             st.lastModel = ctx.model;
         if (ctx.statusCode != null)
@@ -400,21 +563,31 @@ class AgentMapService extends events_1.EventEmitter {
             st.lastActivitySummary = summary;
         if (toolName)
             st.lastToolName = toolName;
-        // 本轮响应是否表示「一轮结束」（精确信号，替代纯时间窗）
+        // 本轮响应是否表示「一轮结束」：
+        // - true  = end_turn 等明确结束 → 任务完成，可弹通知
+        // - false = tool_use 等还要继续 → 客户端将本地执行工具后再次请求，此时静默、保持「进行中」
+        // - null  = 无法判定 → 兜底按结束处理
         const turnEnd = (0, activity_extractor_1.detectTurnEnd)(ctx.agent, ctx.downstreamResponseBody, ctx.responseBody);
         st.lastTurnEnd = turnEnd;
-        // 重算状态（onFinalized 时请求已结束，inFlight 会被 endRequest 减，但可能尚未调用）
-        const prevStatus = st.status;
+        // 重算状态：请求已结束（endRequest 已把 inFlight 减 1）。inferStatus 会在「结束」情形下防抖保持 active。
         const { status, reason } = this.inferStatus({
-            lastRequestAt: st.lastRequestAt,
+            lastActivityAt: st.lastActivityAt,
             lastStatusCode: st.lastStatusCode,
             inFlight: st.inFlight,
+            streamingInFlight: st.streamingInFlight,
+            thinkingInFlight: st.thinkingInFlight,
+            streamFirstChunkAt: st.streamFirstChunkAt,
+            inFlightSince: st.inFlightSince,
+            lastTurnEnd: turnEnd,
             now,
-            turnEnd,
         });
         st.status = status;
         st.statusReason = reason;
-        this.maybeNotifyTurnEnd(prevStatus, st);
+        // 任务结束检测：无在途且末响应非 tool_use（end_turn / 未知）→ 调度防抖通知。
+        // tool_use 不调度（客户端将本地执行工具后继续）；防抖期内来新主请求会取消它。
+        if (st.inFlight === 0 && st.lastTurnEnd !== false) {
+            this.considerEndNotify(st, ((_a = st.lastStatusCode) !== null && _a !== void 0 ? _a : 0) >= 500);
+        }
         // 记录事件
         if (events.length > 0) {
             this.recordEvents(ctx.sessionId, events);
@@ -466,10 +639,61 @@ class AgentMapService extends events_1.EventEmitter {
                 if (meta.title)
                     st.title = meta.title;
                 st.metaResolved = true;
+                // legacy 会话（修复前累积、拆分从未持久化）：点开详情时按日志回填输入/输出拆分
+                this.backfillTokenSplit(st).catch(err => console.error('[AgentMap] backfillTokenSplit error:', err));
             }
             return { source, projectPath: meta.projectPath || (st === null || st === void 0 ? void 0 : st.projectPath), title: meta.title || (st === null || st === void 0 ? void 0 : st.title) };
         });
     }
+    /**
+     * 历史 token 输入/输出拆分回填。
+     * 仅对 legacy 会话生效：累计 token > 0 但拆分为 0（修复前从未持久化）。
+     * 从该会话的全部请求日志现算 usage.inputTokens / outputTokens 之和，写回 RuntimeState + DB（绝对值），
+     * 之后新请求照常在回填基线上累加。每个会话只回填一次（tokenSplitBackfilled）。
+     */
+    backfillTokenSplit(st) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (st.tokenSplitBackfilled)
+                return;
+            if (st.source !== 'global')
+                return;
+            // 仅 legacy 标记：累计有值但拆分为 0。新会话（拆分已随请求累加）不触发。
+            if (!(st.totalTokens > 0 && st.inputTokens === 0 && st.outputTokens === 0)) {
+                st.tokenSplitBackfilled = true;
+                return;
+            }
+            if (!((_a = this.db) === null || _a === void 0 ? void 0 : _a.getLogsBySessionId) || !((_b = this.db) === null || _b === void 0 ? void 0 : _b.updateSession)) {
+                st.tokenSplitBackfilled = true;
+                return;
+            }
+            st.tokenSplitBackfilled = true; // 先置位，防并发重复回填
+            try {
+                // 取全部日志（默认 limit=100 会漏算大 session），传一个大上限以覆盖完整历史
+                const logs = yield this.db.getLogsBySessionId(st.sessionId, Number.MAX_SAFE_INTEGER);
+                let inputTokens = 0;
+                let outputTokens = 0;
+                for (const log of logs) {
+                    const u = log.usage;
+                    if (!u)
+                        continue;
+                    inputTokens += u.inputTokens || u.promptTokens || 0;
+                    outputTokens += u.outputTokens || u.completionTokens || 0;
+                }
+                if (inputTokens > 0 || outputTokens > 0) {
+                    st.inputTokens = inputTokens;
+                    st.outputTokens = outputTokens;
+                    // 绝对写入 DB（不走 upsertSession 的累加语义），后续新请求在其上累加
+                    yield this.db.updateSession(st.sessionId, { inputTokens, outputTokens });
+                    this.emitSession(st);
+                }
+            }
+            catch (err) {
+                st.tokenSplitBackfilled = false; // 失败则允许下次重试
+                throw err;
+            }
+        });
+    }
     // ============ 任务结束 OS 通知 ============
     setNotifyEnabled(enabled) {
         this.notifyEnabled = !!enabled;
@@ -498,25 +722,60 @@ class AgentMapService extends events_1.EventEmitter {
     notifyTest() {
         (0, notifier_1.notify)({ title: '🔔 AICodeSwitch', body: '测试通知：通知功能可用' });
     }
-    /** active → idle 迁移时，只要开关开启就弹 OS 通知（一轮工作结束）。不再看页面是否后台。 */
-    maybeNotifyTurnEnd(prevStatus, st) {
+    /**
+     * 结束通知调度（基于「结束检测」，而非展示状态迁移）：
+     * - onFinalized 检测到一轮结束（inFlight==0 且非 tool_use）时调用；
+     * - sweep / reevaluate 检测到停滞/泄漏脱离 active 时调用。
+     * 每轮只调度一次（notifiedForTurn 去重）；499（用户取消）不调度。实际弹通知由 scheduleNotify 防抖。
+     * 展示状态的「防抖保持 active」由 inferStatus 负责，fireNotify 落实 idle，二者经 NOTIFY_DEBOUNCE_MS 对齐。
+     */
+    considerEndNotify(st, isError) {
         if (!this.notifyEnabled)
             return;
-        if (prevStatus !== 'active' || st.status !== 'idle')
-            return;
-        // 499 = 用户主动放弃停止任务，属于预期行为，不弹系统通知
+        if (st.notifiedForTurn)
+            return; // 本轮已调度
         if (st.lastStatusCode === 499)
+            return; // 用户主动取消，不弹
+        st.notifiedForTurn = true;
+        this.scheduleNotify(st, isError);
+    }
+    /** 安排一条防抖结束通知（先取消已挂起的，再重新计时）。 */
+    scheduleNotify(st, isError) {
+        this.cancelNotifyTimer(st);
+        st.notifyTimer = setTimeout(() => {
+            st.notifyTimer = null;
+            this.fireNotify(st, isError);
+        }, NOTIFY_DEBOUNCE_MS);
+        // 不阻止进程退出
+        if (typeof st.notifyTimer.unref === 'function')
+            st.notifyTimer.unref();
+    }
+    /** 取消挂起的防抖通知（会话再次活跃时调用）。 */
+    cancelNotifyTimer(st) {
+        if (st.notifyTimer) {
+            clearTimeout(st.notifyTimer);
+            st.notifyTimer = null;
+        }
+    }
+    /** 真正弹出 OS 通知（防抖窗口结束、未被取消时调用）。过 60s 冷却兜底。同时把「防抖保持的 active」落实为 idle。 */
+    fireNotify(st, isError) {
+        // 防抖期间用户可能关掉了通知开关 → 不弹
+        if (!this.notifyEnabled)
             return;
-        // 冷却去重：主轮结束后常伴有后台/计数/compact 等续发请求，各自 end_turn 会重复触发 active→idle，
-        // 在冷却窗口内只弹一次，避免同一任务弹两条通知。
         const now = Date.now();
         if (st.lastNotifyAt && now - st.lastNotifyAt < NOTIFY_COOLDOWN_MS)
             return;
         st.lastNotifyAt = now;
+        // 把展示状态从「防抖保持的 active」落实为 idle，与通知同步；仅当确无在途请求（不覆盖后台请求进行中的 active）
+        if (st.inFlight === 0 && st.status === 'active') {
+            st.status = isError ? 'error' : 'idle';
+            st.statusReason = isError ? 'upstream error' : 'turn ended';
+            this.emitSession(st);
+        }
         const agentName = st.agent === 'codex' ? 'Codex' : 'Claude Code';
         (0, notifier_1.notify)({
-            title: `✅ AICodeSwitch · ${agentName}`,
-            body: st.title || st.lastActivitySummary || '任务已暂停，等待下一步',
+            title: `${isError ? '⚠️' : '✅'} AICodeSwitch · ${agentName}`,
+            body: st.title || st.lastActivitySummary || (isError ? '任务出现异常' : '任务已结束，等待下一步'),
         });
     }
     recordEvents(sessionId, events) {
@@ -531,35 +790,58 @@ class AgentMapService extends events_1.EventEmitter {
             this.globalEvents.splice(0, this.globalEvents.length - MAX_GLOBAL_EVENTS);
         }
     }
-    // ============ 状态推断（纯函数，基于活跃度） ============
+    // ============ 状态推断（纯函数，基于「在途 + 真实活动时钟 + 轮次语义」） ============
     inferStatus(args) {
-        // 在途请求 → active
-        if (args.inFlight > 0)
-            return { status: 'active', reason: 'in-flight' };
-        // 末次失败 → error（即使时间较近也标 error，下一次成功会刷回 active）
+        // 末次上游 5xx → error（即使时间较近也标 error，下一次成功会刷回 active）
         if (args.lastStatusCode != null && args.lastStatusCode >= 500) {
-            return { status: 'error', reason: `upstream ${args.lastStatusCode}` };
+            return { status: 'error', reason: `upstream ${args.lastStatusCode}`, notifyEligible: true };
+        }
+        // 在途请求：判定是否「真正存活」（区分同步 / SSE / 思考）。在途期间任何「停滞→idle」都可通知。
+        if (args.inFlight > 0) {
+            if (args.streamingInFlight > 0) {
+                if (!args.streamFirstChunkAt) {
+                    // 首 Token 前：思考类模型 TTFT 可能较长，按同步超时 5min 等待
+                    const since = args.inFlightSince || args.lastActivityAt;
+                    if (args.now - since <= this.syncMaxMs)
+                        return { status: 'active', reason: 'awaiting first token', notifyEligible: true };
+                    return { status: 'idle', reason: 'stream stalled (no first token)', notifyEligible: true };
+                }
+                // 已开始产出：思考请求用更宽的 THINKING_SILENCE_MS，否则 SSE_SILENCE_MS（30s）
+                const limit = args.thinkingInFlight > 0 ? this.thinkingSilenceMs : this.sseSilenceMs;
+                const since = args.streamFirstChunkAt;
+                if (args.now - since <= limit) {
+                    return { status: 'active', reason: args.thinkingInFlight > 0 ? 'thinking' : 'streaming', notifyEligible: true };
+                }
+                return { status: 'idle', reason: args.thinkingInFlight > 0 ? 'thinking timeout' : 'stream stalled', notifyEligible: true };
+            }
+            // 同步请求：5min 内视为仍在处理；超过则视作服务中断、强制结束
+            const since = args.inFlightSince || args.lastActivityAt;
+            if (args.now - since <= this.syncMaxMs)
+                return { status: 'active', reason: 'in-flight', notifyEligible: true };
+            return { status: 'idle', reason: 'sync timeout', notifyEligible: true };
         }
-        const elapsed = args.now - args.lastRequestAt;
-        // 499 = 客户端主动断开（用户放弃停止任务）：视为「已取消」，立即停止脉冲进入 idle，过 idleWindow 再 completed
+        // 无在途请求：按「上一轮响应语义 + 距最近活动时长」判 idle / completed，并决定是否可通知
+        const elapsed = args.now - args.lastActivityAt;
+        // 499 = 客户端主动断开（用户放弃停止任务）：视为「已取消」，立即进入 idle
         if (args.lastStatusCode === 499) {
             if (elapsed <= this.idleWindowMs)
-                return { status: 'idle', reason: 'client cancelled' };
-            return { status: 'completed', reason: 'cancelled earlier' };
+                return { status: 'idle', reason: 'client cancelled', notifyEligible: true };
+            return { status: 'completed', reason: 'cancelled earlier', notifyEligible: true };
         }
-        // 精确信号：本轮响应明确「结束」→ 立即停止脉冲，进入 idle（超时再 completed）
-        if (args.turnEnd === true) {
+        // tool_use：客户端正在本地执行工具，随后会再发请求 → 保持「进行中」，且**不可通知**（避免每次工具调用误弹）
+        if (args.lastTurnEnd === false) {
             if (elapsed <= this.idleWindowMs)
-                return { status: 'idle', reason: 'turn ended' };
-            return { status: 'completed', reason: 'inactive' };
-        }
-        // 仍将继续（tool_use）或信号未知 → 回退到活跃时间窗
-        if (elapsed <= this.activeWindowMs) {
-            return { status: 'active', reason: args.turnEnd === false ? 'tool loop' : 'recent request' };
+                return { status: 'active', reason: 'executing tool locally', notifyEligible: false };
+            return { status: 'idle', reason: 'tool exec abandoned', notifyEligible: false };
         }
+        // end_turn（true）或无法判定（null，兜底按结束处理）：
+        // 先防抖保持 active 满 NOTIFY_DEBOUNCE_MS（避免请求边界处「闪一下空闲」），期满才落实 idle/completed。
+        // 防抖期内若发起新主请求，lastActivityAt 会被刷新 → 继续保持 active，不闪、不弹通知。
+        if (elapsed <= NOTIFY_DEBOUNCE_MS)
+            return { status: 'active', reason: 'turn ending (debounced)', notifyEligible: true };
         if (elapsed <= this.idleWindowMs)
-            return { status: 'idle', reason: 'no recent activity' };
-        return { status: 'completed', reason: 'inactive' };
+            return { status: 'idle', reason: 'turn ended', notifyEligible: true };
+        return { status: 'completed', reason: 'inactive', notifyEligible: true };
     }
     // ============ 定时清扫 ============
     sweep() {
@@ -568,17 +850,34 @@ class AgentMapService extends events_1.EventEmitter {
         this.states.forEach(st => {
             const prevStatus = st.status;
             const { status, reason } = this.inferStatus({
-                lastRequestAt: st.lastRequestAt,
+                lastActivityAt: st.lastActivityAt,
                 lastStatusCode: st.lastStatusCode,
                 inFlight: st.inFlight,
+                streamingInFlight: st.streamingInFlight,
+                thinkingInFlight: st.thinkingInFlight,
+                streamFirstChunkAt: st.streamFirstChunkAt,
+                inFlightSince: st.inFlightSince,
+                lastTurnEnd: st.lastTurnEnd,
                 now,
-                turnEnd: st.lastTurnEnd,
             });
-            if (status !== prevStatus) {
+            // 状态迁移，或在途请求已陈旧/泄漏（inFlight>0 却不再存活）→ 清零泄漏的计数器
+            const statusChanged = status !== prevStatus;
+            const leakedInFlight = st.inFlight > 0 && status !== 'active';
+            if (statusChanged || leakedInFlight) {
+                if (leakedInFlight) {
+                    // 修复「永远卡在进行中」：endRequest 未配对到达（早退/异常）导致的在途泄漏，这里兜底清零
+                    st.inFlight = 0;
+                    st.streamingInFlight = 0;
+                    st.thinkingInFlight = 0;
+                    st.inFlightSince = 0;
+                    st.streamFirstChunkAt = 0;
+                }
                 st.status = status;
                 st.statusReason = reason;
                 changed = true;
-                this.maybeNotifyTurnEnd(prevStatus, st);
+                // 停滞/泄漏/异常导致脱离 active → 调度防抖通知（正常结束已在 onFinalized 调度，notifiedForTurn 去重）
+                if (status !== 'active')
+                    this.considerEndNotify(st, status === 'error');
                 this.emitSession(st);
             }
         });
@@ -640,7 +939,10 @@ class AgentMapService extends events_1.EventEmitter {
             firstRequestAt: st.firstRequestAt,
             lastRequestAt: st.lastRequestAt,
             requestCount: st.requestCount,
-            totalTokens: st.totalTokens,
+            // 展示值 = 已落盘累计 + 在途实时累计，使节点在流式过程中随 token 增长实时上移
+            totalTokens: st.totalTokens + st.runningInputTokens + st.runningOutputTokens,
+            inputTokens: st.inputTokens + st.runningInputTokens,
+            outputTokens: st.outputTokens + st.runningOutputTokens,
             lastToolName: st.lastToolName,
             lastActivitySummary: st.lastActivitySummary,
             lastStatusCode: st.lastStatusCode,
@@ -696,6 +998,8 @@ class AgentMapService extends events_1.EventEmitter {
             clearInterval(this.sweepTimer);
             this.sweepTimer = null;
         }
+        // 清理所有挂起的防抖通知定时器，避免销毁后仍触发
+        this.states.forEach(st => this.cancelNotifyTimer(st));
         this.states.clear();
         this.sessionEvents.clear();
         this.globalEvents = [];

package/dist/server/conversions/index.js

@@ -276,8 +276,16 @@ function buildTargetBody(options) {
             if (result.messages) {
                 result.messages = (0, mapper_js_2.fixThinkingHistory)(result.messages, 'completions');
             }
-            // 剥离 stream_options（reasoning_content 提供商通常不支持）
-            delete result.stream_options;
+            // stream_options 剥离策略由 providerConfig.streamOptions 决定：
+            //   'supported'   → 保留（DeepSeek 等支持 include_usage，能拿到真实 usage）
+            //   'unsupported' → 剥离（已知会报错的供应商）
+            //   'auto'/缺省   → 维持历史行为：reasoning_content 剥离
+            const streamOpt = providerConfig.streamOptions || 'auto';
+            const shouldStripStreamOptions = streamOpt === 'unsupported' ||
+                (streamOpt === 'auto' && isReasoningContentCompletion);
+            if (shouldStripStreamOptions) {
+                delete result.stream_options;
+            }
         }
         // 注入 thinking 参数（如 thinking: { type: 'enabled' }）和 effort 参数
         if (providerConfig.supportsThinking || providerConfig.supportsEffort) {

package/dist/server/conversions/thinking/providers.js

@@ -6,17 +6,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_CONFIG = void 0;
 exports.getReasoningConfig = getReasoningConfig;
 exports.applyReasoningConfig = applyReasoningConfig;
+// streamOptions 语义（决定流式请求是否保留 stream_options.include_usage）：
+//   'supported'   → 已知支持 include_usage 的供应商，保留 → 流式可拿到真实 usage
+//   'unsupported' → 已知会对 stream_options 报错的供应商，剥离
+//   'auto'        → 未明确，由 conversions/index.ts 按 outputFormat 兜底（reasoning_content 剥离，其余保留）
 const PROVIDER_CONFIGS = [
-    { patterns: ['deepseek'], config: { supportsThinking: true, supportsEffort: true, thinkingParam: 'thinking', effortParam: 'reasoning_effort', effortValueMode: 'deepseek', outputFormat: 'reasoning_content' } },
-    { patterns: ['moonshot', 'kimi'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content' } },
-    { patterns: ['qwen', 'dashscope'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'enable_thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content' } },
-    { patterns: ['zhipu', 'glm', 'bigmodel'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content' } },
+    { patterns: ['deepseek'], config: { supportsThinking: true, supportsEffort: true, thinkingParam: 'thinking', effortParam: 'reasoning_effort', effortValueMode: 'deepseek', outputFormat: 'reasoning_content', streamOptions: 'supported' } },
+    { patterns: ['moonshot', 'kimi'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content', streamOptions: 'supported' } },
+    { patterns: ['qwen', 'dashscope'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'enable_thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content', streamOptions: 'supported' } },
+    { patterns: ['zhipu', 'glm', 'bigmodel'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content', streamOptions: 'supported' } },
     { patterns: ['minimax'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'reasoning_split', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_details' } },
-    { patterns: ['mimo', 'xiaomimimo'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content' } },
+    { patterns: ['mimo', 'xiaomimimo'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content', streamOptions: 'auto' } },
     { patterns: ['openrouter'], config: { supportsThinking: false, supportsEffort: true, thinkingParam: 'none', effortParam: 'reasoning.effort', effortValueMode: 'openrouter', outputFormat: 'reasoning' } },
-    { patterns: ['siliconflow'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'enable_thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content' } },
+    { patterns: ['siliconflow'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'enable_thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content', streamOptions: 'supported' } },
     { patterns: ['stepfun', 'step'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'none', effortParam: 'reasoning_effort', effortValueMode: 'low_high', outputFormat: 'reasoning' } },
-    { patterns: ['agnes'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'chat_template_kwargs', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content' } },
+    { patterns: ['agnes'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'chat_template_kwargs', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content', streamOptions: 'auto' } },
 ];
 const DEFAULT_CONFIG = {
     supportsThinking: false,
@@ -25,6 +29,7 @@ const DEFAULT_CONFIG = {
     effortParam: 'none',
     effortValueMode: 'passthrough',
     outputFormat: 'reasoning_content',
+    streamOptions: 'auto',
 };
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
 /** Detect reasoning config for a given provider */