lark-remote 0.5.3 → 0.5.4

package/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.4] - 2026-10-12
+
+### 修复
+
+- **codex「本 run」token 少算（多步运行只统计了最后一步）**：codex 每发起一次模型调用就记一条 token 用量，一个回合里有几趟工具往返就有几条，而运行结束卡片与 `/resume` 末尾统计此前只取最后一条。于是一个跑了 7 趟工具往返的回合，实际输出 3,648 个 token 只显示 679、未命中缓存的输入 3,022 只显示 212。现在按回合汇总该回合内所有调用的用量，与 codex 自己按回合统计的结果逐字段一致；「Context」仍显示最后一次调用的上下文窗口占用，累计用量与 `Total` 的取法不变。恢复会话时服务端可能重放上回合的用量，已按回合标识丢弃。更早的、不带回合标识的记录保持原读法
+
+### 变更
+
+- **测试注释与用例类型对齐**：一处用例注释改为不点名具体消息；两处 app-server 用例的类型写法与协议定义对齐（这些文件不在既有类型检查覆盖范围内，改动不影响运行时行为）。无行为变化
+
 ## [0.5.3] - 2026-10-12
 
 ### 修复

package/dist/runner/codex/app-server/translator.js

@@ -222,6 +222,11 @@ export class CodexAppServerTranslator {
         this.threadId = params.threadId;
         this.turnId = params.turn.id;
         this.turnStatus = params.turn.status ?? 'inProgress';
+        // 单 turn 用量从零开始累计：turn 内每次采样都会发一条
+        // `thread/tokenUsage/updated`，本 run 的用量是这些增量之和（不是最后一条）。
+        // resume 后服务端重放的上一 turn 用量若在此之后到达，由 handleTokenUsageUpdated
+        // 的 turnId 闸门挡掉。
+        this.usage = { inputTokens: 0, outputTokens: 0 };
         this.textByItem.clear();
         this.reasoningByItem.clear();
         this.toolOutputByItem.clear();
@@ -455,22 +460,31 @@ export class CodexAppServerTranslator {
         ];
     }
     handleTokenUsageUpdated(params) {
+        // 归属闸门：resume 之后服务端可能重放上一 turn 的 tokenUsage（turnId 不同），
+        // 计入会把上一 turn 的消耗算成本 run。本轮 turnId 由 turn/started 确立。
+        if (params.turnId && this.turnId && params.turnId !== this.turnId) {
+            return [];
+        }
         const last = params.tokenUsage.last;
         // 协议原生 inputTokens 含 cached（total = input + output），而 lark-remote 的
         // 卡片契约是 ccusage 口径「input_tokens 表示未命中缓存的输入」（design §9.21）。
         // 在入口归一，否则 done 卡 Input 会等于 Context、cache% 分母重复计数、
         // Total 被 max(total, input+output+cache) 抬高一倍（实测 364K → 727K）。
         // jsonl 链路有同一处减法（session/codex/rollout-reader.ts buildUsageFromScan）。
+        // 单 turn 口径：一个 turn 内每次采样各发一条通知（实测 7 次工具往返 = 7 条），
+        // 本 run 是这些增量之和——只取最后一条会把多步 run 低报（实测 3,648 output 显示成 679）。
         const cachedInputTokens = last.cachedInputTokens === undefined
             ? undefined
             : Math.min(last.cachedInputTokens, last.inputTokens);
-        this.usage = {
-            inputTokens: last.inputTokens - (cachedInputTokens ?? 0),
-            outputTokens: last.outputTokens,
-            cachedInputTokens,
-            totalTokens: last.totalTokens,
-            contextLimit: params.tokenUsage.modelContextWindow,
-        };
+        this.usage.inputTokens += last.inputTokens - (cachedInputTokens ?? 0);
+        this.usage.outputTokens += last.outputTokens;
+        if (cachedInputTokens !== undefined) {
+            this.usage.cachedInputTokens = (this.usage.cachedInputTokens ?? 0) + cachedInputTokens;
+        }
+        if (last.totalTokens !== undefined) {
+            this.usage.totalTokens = (this.usage.totalTokens ?? 0) + last.totalTokens;
+        }
+        this.usage.contextLimit = params.tokenUsage.modelContextWindow ?? this.usage.contextLimit;
         return [];
     }
     /**

package/dist/session/codex/rollout-reader.js

@@ -42,6 +42,9 @@ function subtractRawUsage(a, b) {
         total_tokens: a.total_tokens - b.total_tokens,
     };
 }
+function emptyTurnUsage() {
+    return { input: 0, cached: 0, output: 0, total: 0 };
+}
 /**
  * `compacted` 事件自带的摘要调用 usage（`latest_token_usage_record.usage`）。
  * 用于把「压缩前窗口」与「摘要调用自身的消耗」区分开——两者都写在 compacted 前。
@@ -141,12 +144,19 @@ function scanCodexRollout(filePath, includeEvents) {
     // exactly the 0.153 compatibility incident shape.
     let userResponseItemCount = 0;
     // token_count tracking: codex emits cumulative `total_token_usage` and an
-    // incremental `last_token_usage`. We want the LAST turn's usage (matches
-    // pi/opencode /resume "last turn" display semantics). When
+    // incremental `last_token_usage` **per sampling call** — one turn with tool
+    // round-trips logs several `token_count` lines. We want the LAST turn's usage
+    // = the sum of that turn's samplings (matches pi/opencode /resume "last turn"
+    // display semantics). Turn boundaries come from `task_started`. When
     // last_token_usage is absent we derive it as total - previous_total.
     let lastRawUsage;
     /** 上一条被接受的 raw usage；compacted 分支回退一条时用（见下方注释）。 */
     let previousRawUsage;
+    /**
+     * 末个 turn 的累计用量；`null` = 文件里没有 `task_started`（旧数据），
+     * 此时 flow 字段退回「末条 token_count」语义（见 buildUsageFromScan）。
+     */
+    let turnUsage = null;
     // Context window limit from the same token_count event as lastRawUsage
     // (codex reports info.model_context_window per turn; absent on old data).
     let lastContextLimit;
@@ -194,6 +204,12 @@ function scanCodexRollout(filePath, includeEvents) {
                     }
                     lastUserMessageSource = human.source;
                 }
+                else if (payload.type === 'task_started') {
+                    // turn 边界：一个 turn 一条 task_started（与 task_complete 成对，
+                    // turn_id 见 session_meta 之后的 `turn_context`）。从这里开始重新
+                    // 累计本 turn 的用量。
+                    turnUsage = emptyTurnUsage();
+                }
                 else if (payload.type === 'token_count') {
                     const info = payload.info;
                     const last = info?.last_token_usage;
@@ -217,6 +233,13 @@ function scanCodexRollout(filePath, includeEvents) {
                         lastRawUsage = raw;
                         const ctxWindow = info?.model_context_window;
                         lastContextLimit = typeof ctxWindow === 'number' ? ctxWindow : undefined;
+                        if (turnUsage) {
+                            const cached = Math.min(raw.cached_input_tokens, raw.input_tokens);
+                            turnUsage.input += raw.input_tokens - cached;
+                            turnUsage.cached += cached;
+                            turnUsage.output += raw.output_tokens;
+                            turnUsage.total += raw.total_tokens;
+                        }
                     }
                     // 压缩后的水位：压缩收尾 token_count 全 0（raw 不满足上面 zero-filter），
                     // 但 total_tokens 表达真实窗口；之后若出现普通 turn（input>0），
@@ -288,6 +311,7 @@ function scanCodexRollout(filePath, includeEvents) {
         lastContextLimit,
         lastTotalUsage,
         previousTotals,
+        turnUsage,
         compactCount,
         compactPreContextLength,
         compactPostContextLength,
@@ -298,25 +322,38 @@ function scanCodexRollout(filePath, includeEvents) {
  * input = raw - cached (codex reports cached input separately), cache
  * creation is never reported by codex, reasoning is a subset of output
  * (display-only, never added to total).
+ *
+ * Flow fields (input/output/cache/total) are the **sum over the last turn's
+ * samplings** when the file marks turn boundaries (`task_started`) — one codex
+ * turn logs one `token_count` per sampling, so the last line alone understates
+ * a tool-looping run (measured: 212 / 679 displayed vs 3,022 / 3,648 consumed).
+ * Legacy files without `task_started` keep the last-`token_count` semantics.
  * contextLength = input_tokens (= (input_tokens-cached) + cached + 0),
  * i.e. input + cacheRead + cacheCreation — the unified context-window
  * occupancy contract across all five readers (excludes
  * output/reasoning).
  */
 function buildUsageFromScan(scan) {
-    const { lastRawUsage, lastContextLimit, lastTotalUsage, compactCount, compactPreContextLength, compactPostContextLength, } = scan;
+    const { lastRawUsage, lastContextLimit, lastTotalUsage, turnUsage, compactCount, compactPreContextLength, compactPostContextLength, } = scan;
     if (!lastRawUsage)
         return undefined;
     const r = lastRawUsage;
     const cached = Math.min(r.cached_input_tokens, r.input_tokens);
+    // 本 run = 末个 turn 全部采样之和；旧数据（无 task_started）退回末条。
+    const flow = turnUsage ?? {
+        input: r.input_tokens - cached,
+        cached,
+        output: r.output_tokens,
+        total: r.total_tokens,
+    };
     const usage = {
-        inputTokens: r.input_tokens - cached,
-        outputTokens: r.output_tokens,
+        inputTokens: flow.input,
+        outputTokens: flow.output,
         contextLength: r.input_tokens,
         contextLimit: lastContextLimit,
-        cacheReadTokens: cached,
+        cacheReadTokens: flow.cached,
         cacheCreationTokens: 0,
-        totalTokens: r.total_tokens,
+        totalTokens: flow.total,
     };
     // Cumulative from the final total_token_usage (non-cached input +
     // output), summed across all turns in the session.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",