jbc-dssi 1.1.0 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbc-dssi",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "type": "module",
   "description": "鲸编程 - 不只是手机遥控操作电脑,而是将电脑级的Agent能力装进手机",
   "keywords": [

package/vendor/groups/bridge/engine.js

@@ -71,6 +71,52 @@ function normalizeUsage(usage) {
   return any ? out : null;
 }
 
+/**
+ * 把一次模型调用的 usage 累加进本轮 —— **2026-10-31 修的就是这里**。
+ *
+ * 【为什么必须累加】
+ *   一个 turn 会被拆成多个 step，**每一步都发一条 assistant/message、各带这一步的
+ *   usage**。旧实现 `lastUsage = usage` 只留最后一条，于是面板出现自相矛盾的数字：
+ *   「共 10 步」却只有 60,686 tok —— 而第 10 步单独就 60,686（59,008+240+1,438），
+ *   前 9 步全丢。真机那一轮（2026-10-31 21:26:57~21:27:45，群会话 session-66663e11）
+ *   逐步核对：10 步合计 539,775 tok（缓存命中 521,728 / 未命中 9,159 / 输出 8,888），
+ *   谷价 ≈¥0.0551；旧口径只显示 60,686 tok / ≈¥0.0072，少算约 9 步。
+ *
+ * 【口径】与单聊（`android/.../data/Transcript.kt` 的 `addUsage`）和 Web UI 的
+ *   `deriveTurnTokenUsage` 完全一致：每条 assistant/message 的 usage 各自相加；
+ *   totalTokens 也逐条相加，**不**用 input+output 重算（会与 Web 差出数字）。
+ *   同一 step 的重试会产生多条 assistant/message：用量按 attempt 累加（与单聊一致），
+ *   步数则由调用方按 step 号去重。
+ */
+function sumUsage(acc, u) {
+  if (!acc) return u;
+  return {
+    inputTokens: acc.inputTokens + u.inputTokens,
+    outputTokens: acc.outputTokens + u.outputTokens,
+    cacheReadTokens: acc.cacheReadTokens + u.cacheReadTokens,
+    cacheWriteTokens: acc.cacheWriteTokens + u.cacheWriteTokens,
+    totalTokens: acc.totalTokens + u.totalTokens,
+  };
+}
+
+/**
+ * 把落库的「逐步用量」数组合成一行用量 —— **读侧唯一口径**（2026-11-01 存储结构修复）。
+ *
+ * 只在记录带 `stepUsages`（新格式）时使用。旧记录没这个数组，调用方必须原样使用
+ * 历史 `usage`，**不允许**拿它去"猜"或"补" —— 按负责人决定历史不救、不做回填。
+ *
+ * 返回 null：整轮一条有效用量都没有（老 DSH / 这轮没统计到）→ 手机侧不显示用量项。
+ */
+function aggregateStepUsages(stepUsages) {
+  if (!Array.isArray(stepUsages)) return null;
+  let acc = null;
+  for (const one of stepUsages) {
+    const u = normalizeUsage(one);
+    if (u) acc = sumUsage(acc, u);
+  }
+  return acc;
+}
+
 /**
  * @param {object} opts
  * @param {object} opts.ctx DSH 上下文（sessionController 公开方法）
@@ -130,7 +176,11 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
 
   /**
    * 投递一轮给一个成员，等回复完成后 settle。
-   * @returns {Promise<{text?:string, failed?:string, missed?:boolean, usage?:object|null, steps?:number}>}
+   *
+   * @returns {Promise<{text?:string, failed?:string, missed?:boolean,
+   *   usage?:object|null, steps?:number, stepUsages?:Array<object>}>}
+   *   `stepUsages` = 本轮每一步的用量（每一步一条，按到达顺序）；它和 `usage`
+   *   （各步求和）一起进房间日志，供读侧还原与兼容老客户端。
    */
   function deliver(group, member, prompt, attachments = {}) {
     return new Promise((resolve) => {
@@ -156,7 +206,21 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
       let prompted = false;
       let minTurn = null;
       let lastText = '';
-      let lastUsage = null;
+      /*
+       * 本轮用量 = 各 step 的 usage **累加**（见 [sumUsage]）。
+       *
+       * 2026-10-31 之前这里是 `lastUsage`（只留最后一条 assistant/message），
+       * 于是「共 N 步」配的是"最后一步"的 token，步数越多的轮次少算越多。
+       */
+      let turnUsage = null;
+      /*
+       * 本轮**逐步**用量（2026-11-01 新增）：每一步一条，与 turnUsage 同源。
+       *
+       * 为什么存这个：旧存储只留聚合值，刷新/重进后无法还原「每一步花了多少」，
+       * 历史记录也就永远只能信当时写下的那个数。逐步入库后，读侧可以用它求和还原 ——
+       * 面板在实时、刷新、重进、换端任何时刻都是同一份数据的计算结果。
+       */
+      const stepUsages = [];
       /*
        * 「共 N 步」的账：turn → 这一轮出现过的 step 号集合。
        *
@@ -227,13 +291,21 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
                   // 工具调用那几步没有 text，不能拿它们当回答；有正文才覆盖。
                   const text = assistantText(event);
                   if (text) lastText = text;
-                  const usage = normalizeUsage(data.usage);
-                  if (usage) lastUsage = usage;
                   /*
                    * 步数：**所有** assistant/message 都要记，包括只调工具、不画块的那几步
                    * （与单聊一致 —— token 大头正是这些步骤花掉的）。
                    */
                   const step = typeof data.step === 'number' ? data.step : -1;
+                  const usage = normalizeUsage(data.usage);
+                  if (usage) {
+                    /*
+                     * 逐步入库：步号 + 这一步的五个 token 字段。
+                     * 同一步重试会各存一条（用量按 attempt 累加，与单聊/Web 一致），
+                     * 步数仍由 turnStepNums 按 step 号去重，两者互不影响。
+                     */
+                    stepUsages.push({ step, ...usage });
+                    turnUsage = sumUsage(turnUsage, usage);
+                  }
                   if (step >= 0 && typeof data.turn === 'number') {
                     if (!turnStepNums.has(data.turn)) turnStepNums.set(data.turn, new Set());
                     turnStepNums.get(data.turn).add(step);
@@ -249,7 +321,7 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
                      */
                     const endTurn = typeof data.turn === 'number' ? data.turn : lastTurn;
                     const steps = turnStepNums.get(endTurn)?.size ?? 0;
-                    settle({ text: lastText, usage: lastUsage, steps });
+                    settle({ text: lastText, usage: turnUsage, steps, stepUsages });
                   }
                   ac.abort();
                 } else if (event?.type === 'turn/error' || event?.type === 'turn/failed') {
@@ -308,7 +380,21 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
     });
   }
 
-  /** 把一次投递的结果落成房间行（成员/主管同一套：手机侧按 memberId 显示名字与主管标）。 */
+  /**
+   * 把一次投递的结果落成房间行（成员/主管同一套：手机侧按 memberId 显示名字与主管标）。
+   *
+   * 房间行里的「本轮用量」有两种格式，**读侧必须都认**：
+   *
+   *   旧格式（2026-10-31 及以前落盘的行，只保留聚合值、无法重算）：
+   *     { usage: {inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, totalTokens}, steps: 10 }
+   *   新格式（2026-11-01 起，多一个逐步数组）：
+   *     { usage: {...恒等于逐步求和...}, steps: 10,
+   *       stepUsages: [{ step: 1, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, totalTokens }, ...] }
+   *
+   * `usage` 新格式里照写：给还没升级的老手机读（它们只认这个字段）。
+   * 新手机的 GroupStore 优先用 `stepUsages` 求和 —— 刷新/重进后与实时同源。
+   * 旧行没有 `stepUsages`：读侧原样显示历史值，不补 0、不重算、不报错（历史不救）。
+   */
   function emitReplyLine(group, round, member, result) {
     const text = String(result.text ?? '').trim() || '[未回应]';
     emitLine(group.id, {
@@ -319,6 +405,10 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
       text,
       usage: result.usage ?? null,
       steps: result.steps ?? 0,
+      // 只有真的收到过 usage 才写这个字段；否则 JSON 里不出现（= 老格式，读侧回落）
+      stepUsages: Array.isArray(result.stepUsages) && result.stepUsages.length > 0
+        ? result.stepUsages
+        : undefined,
       round: round?.rounds ?? 0,
     });
     round.totalTurns += 1;
@@ -560,9 +650,21 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
     }
   }
 
-  /** 打开群聊页时拉房间历史。 */
+  /**
+   * 打开群聊页时拉房间历史。
+   *
+   * 【读侧口径（2026-11-01）】
+   *   带 `stepUsages` 的新记录：用量由逐步数据**当场求和**再下发 —— 刷新/重进拿到的
+   *     值和实时那一刻完全同源（这份和也是 `usage` 字段的来源，二者恒等）。
+   *   没有 `stepUsages` 的旧记录：**原样返回**，显示当时写下的历史值。按负责人决定
+   *     历史不救 —— 这里不猜、不补 0、不拿别的字段假装重算。
+   */
   function roomSnapshot(group) {
-    return (state.rooms[group.id] ?? []).slice(-ROOM_LOG_MAX);
+    return (state.rooms[group.id] ?? []).slice(-ROOM_LOG_MAX).map((line) => {
+      if (!Array.isArray(line?.stepUsages) || line.stepUsages.length === 0) return line;
+      const usage = aggregateStepUsages(line.stepUsages);
+      return usage ? { ...line, usage } : line;
+    });
   }
 
   return { handleUserMessage, roomSnapshot, ensureGroupSession };