@yalieny/pi-better-cost-display-footer 2.1.2 → 2.2.0

package/README.md

@@ -6,6 +6,7 @@ pi 扩展:脚本化多段计价动态列表 + footer 增强。
 - **计费自愈**:每轮比对期望 cost(配置 × 当前档位)与实际参与计费的 `ctx.model.cost`,不一致则重注册纠正;连续 3 次未收敛则停止重试并在 footer 显式告警(金额前 `≈`、标签加 `?`),不再静默错价.
 - **档位标签**:价格后紧跟当前档位标签(如 `¥0.047(梁文峰)`),按档位 id 配置文案与颜色;未配置标签的档位不显示。
 - **CH 精度**:footer 缓存命中率小数位可配(默认 1 位)。
+- **tok/s 速率(思考/正文分相位)**:footer 常显 —— 流式中只显示当前相位的实时值 `⚡45.2t/s`(思考中/出字中都是这个形式,无前缀,2s 滚动窗口);assistant 消息结束(工具执行前)后冻结,只在冻结态带前缀,固定三档 `⚡(175.1/r31.8/o613.4)t/s` = 总吞吐 / 思考(r标识) / 正文(o标识),无值打 `-` 占位:本条无思考就是 `⚡(334.8/r-/o336.2)t/s`(无思考时总与正文本就重合)。分母均从各相位首 delta 起算,不含首 token 延迟与工具执行时长。实时值为估算(字符折算 token),思考/正文各自的折算比由真实 `usage.output`/`usage.reasoning` EMA 自校准(初始 4,限幅 0.5~8);异常速率(>1000 t/s)丢弃。注:DeepSeek 在工具循环的续写消息里经常不吐思考,所以 r 档会时有时无(显示为 `-`)。
 - **货币符号**:按 provider 配置计费金额符号(默认 `$`)。
 - **配置升级**:旧版顶层计价配置与 `peakWindows` 首次启动自动迁移为 provider 分层 + `tierFn` 格式(语义不变)。
 
@@ -110,4 +111,5 @@ node --experimental-strip-types test/drift-probe.ts      # 端到端:守卫重
 
 ## 变更记录
 
+- **2.2.0** footer 新增 tok/s 速率(思考/正文分相位):流式中显示当前相位实时值 `⚡45.2t/s`(无前缀,2s 滚动窗口),assistant `message_end` 用真实 `usage` 冻结为固定三档 `⚡(175.1/r31.8/o613.4)t/s`(总/思考/正文,无值打 `-` 占位);分母从各相位首 delta 起算,不含首 token 延迟与工具执行时长(定稿用 message_end 而非 turn_end)。实时值为估算,思考/正文各自的折算比由真实 token EMA 自校准(初始 4,限幅 0.5~8);异常速率(>1000 t/s)丢弃;无效 `usage`(失败/中止)不覆盖定稿值。/cost-tier 新增两档折算比。
 - **2.1.2** 修复"档位标签正确但计费金额按错档结算":注册守卫改为按实际计费 cost 判定漂移(不再只看档位字符串),注册失败不再写入守卫(下一轮自动重试);漂移 3 次未收敛转为 footer 可见告警(`≈` + 标签 `?`);新增 `/cost-tier` 诊断命令与注册失败一次性提示。方案见 `docs/fix-plan-stale-cost-tier.md`。

package/extensions/pi-better-cost-display-footer.ts

@@ -194,6 +194,201 @@ let footerLabel: FooterLabel | null = null;
 /** ponytail: 漂移重试预算固定 3 次，不做指数退避；真出现抖动再把预算做成配置项 */
 const DRIFT_RETRY_LIMIT = 3;
 
+/* ---------- tok/s 实时速率（思考 / 正文分相位） ---------- */
+
+/** ponytail: 窗口与折算上限固定；窗口 2s 是 GUI 可读性的取舍，不做配置项 */
+const SPEED_WINDOW_MS = 2000;
+/** 初始“字符/token”比：与 pi 自身（pi-ai estimate）的 4 一致，随后用真实 token 校准 */
+const SPEED_CHARS_PER_TOKEN_DEFAULT = 4;
+/** 校准比限幅：0.5（CJK 密集）~ 8（思考/结构化短词） */
+const SPEED_RATIO_MIN = 0.5;
+const SPEED_RATIO_MAX = 8;
+/** 校准 EMA 系数：每条消息往实测值靠 30%，数条内收敛 */
+const SPEED_CALIBRATION_ALPHA = 0.3;
+/** 超过该速率视为异常样本（t/s），丢弃并沿用上次值 */
+const SPEED_MAX = 1000;
+
+/** 相位：r = 思考（reasoning），o = 正文（output − reasoning，含工具调用参数） */
+type SpeedPhaseKind = "r" | "o";
+
+/** 单相位的 2s 滚动窗口累计 */
+interface SpeedPhase {
+  /** 本相位首个 delta 时刻；null = 本相位无产出 */
+  firstMs: number | null;
+  /** 本相位最近一个 delta 时刻（相位时长 = last − first） */
+  lastMs: number;
+  chars: number;
+  /** 已计入窗口的估算 token（单调，与窗口裁剪解耦，避免裁剪后重复计数） */
+  tokens: number;
+  samples: { t: number; n: number }[];
+  /** 本相位最近一次实时速率 */
+  rate: number | null;
+}
+
+/** 定稿三档速率；null = 该档无法计算 */
+interface SpeedFinal {
+  /** 总吞吐 = output / (首 delta → message_end) */
+  total: number | null;
+  /** 思考 = reasoning / 思考段时长 */
+  r: number | null;
+  /** 正文 = (output − reasoning) / 正文段时长 */
+  o: number | null;
+}
+
+function newPhase(): SpeedPhase {
+  return { firstMs: null, lastMs: 0, chars: 0, tokens: 0, samples: [], rate: null };
+}
+
+/** 各相位“字符/token”校准比：跨消息保留 */
+const speedRatio: Record<SpeedPhaseKind, number> = {
+  r: SPEED_CHARS_PER_TOKEN_DEFAULT,
+  o: SPEED_CHARS_PER_TOKEN_DEFAULT,
+};
+
+/**
+ * 速率状态：每个 delta 按相位进各自的滚动窗口 → assistant message_end 用真实 usage
+ * （output / reasoning）定稿三档并校准折算比。流式中显示当前相位实时值，空闲显示定稿三档。
+ *
+ * 为何实时值只能估算：没有任何 provider 在流中回传逐块累计 output token（Anthropic 的
+ * message_delta / Bedrock 的 metadata / OpenAI 的 include_usage 都只在末尾给一次），
+ * 只能由文本长度推；真值用于定稿与校准。
+ *
+ * 为何用 message_end 而非 turn_end 定稿：agent-loop 顺序是
+ * turn_start → 流式 message_* → 执行工具 → turn_end，用 turn_end 会把工具执行时长算进分母
+ * （流 200 token 后跑 60s 构建 → 报 3 t/s）。message_end 就在流式结束、工具开始前。
+ *
+ * 为何分相位：两段速度差一个数量级（实测 deepseek-flash：思考 ~32 t/s、正文 ~613 t/s），
+ * 混在一起的平均既不代表“模型在跑”也不代表“字出来的速度”。
+ */
+const speed = {
+  think: newPhase(),
+  text: newPhase(),
+  /** 当前正在产出的相位；null = 空闲（显示定稿值） */
+  active: null as SpeedPhaseKind | null,
+  /** 本条消息首 delta 时刻（总口径分母起点） */
+  firstMs: null as number | null,
+  /** 最近一条消息的定稿三档 */
+  final: null as SpeedFinal | null,
+};
+
+/** 速率合理区间（t/s）；异常样本返回 null */
+function reasonableRate(rate: number): number | null {
+  return Number.isFinite(rate) && rate > 0 && rate <= SPEED_MAX ? rate : null;
+}
+
+/** 清空单条消息的累计，保留定稿值与校准比（assistant 消息开始时调用） */
+export function resetSpeedTurn(): void {
+  speed.think = newPhase();
+  speed.text = newPhase();
+  speed.active = null;
+  speed.firstMs = null;
+}
+
+/** 会话开始/切换：全部清空（含定稿值与校准比，避免沿用上个会话的数字） */
+export function resetSpeedSession(): void {
+  speed.final = null;
+  speedRatio.r = SPEED_CHARS_PER_TOKEN_DEFAULT;
+  speedRatio.o = SPEED_CHARS_PER_TOKEN_DEFAULT;
+  resetSpeedTurn();
+}
+
+/** 相位实时速率：窗口内 token / 实际耗时（窗口不满时按相位首 delta 起算） */
+function phaseLiveRate(p: SpeedPhase, nowMs: number): number | null {
+  if (p.firstMs === null) return null;
+  const cutoff = nowMs - SPEED_WINDOW_MS;
+  p.samples = p.samples.filter((s) => s.t >= cutoff);
+  const elapsedSec = (nowMs - Math.max(cutoff, p.firstMs)) / 1000;
+  if (elapsedSec <= 0) return null;
+  const tokens = p.samples.reduce((sum, s) => sum + s.n, 0);
+  const measured = reasonableRate(tokens / elapsedSec);
+  if (measured !== null) p.rate = measured;
+  return p.rate;
+}
+
+/**
+ * 消费一片流式文本（按相位累计），返回该相位的实时速率
+ * @param kind - "r" 思考 / "o" 正文（含工具调用参数）
+ */
+export function pushSpeedDelta(kind: SpeedPhaseKind, delta: string, nowMs: number): number | null {
+  const p = kind === "r" ? speed.think : speed.text;
+  if (delta.length > 0) {
+    speed.active = kind;
+    if (speed.firstMs === null) speed.firstMs = nowMs;
+    if (p.firstMs === null) p.firstMs = nowMs;
+    p.lastMs = nowMs;
+    p.chars += delta.length;
+    // 字符按折算比换算 token，只把新增量入窗口（累计量单调，裁剪后不会重复计数）
+    const target = Math.round(p.chars / speedRatio[kind]);
+    if (target > p.tokens) {
+      p.samples.push({ t: nowMs, n: target - p.tokens });
+      p.tokens = target;
+    }
+  }
+  return phaseLiveRate(p, nowMs);
+}
+
+/** 用真实 token 校准某相位的“字符/token”比；样本无效时保持原值 */
+function calibrate(kind: SpeedPhaseKind, chars: number, realTokens: number): void {
+  if (realTokens <= 0 || chars <= 0) return;
+  const measured = Math.min(SPEED_RATIO_MAX, Math.max(SPEED_RATIO_MIN, chars / realTokens));
+  speedRatio[kind] =
+    speedRatio[kind] * (1 - SPEED_CALIBRATION_ALPHA) + measured * SPEED_CALIBRATION_ALPHA;
+}
+
+/** 相位时长（首 → 末 delta，秒）；样本不足返回 null */
+function phaseSpanSec(p: SpeedPhase): number | null {
+  if (p.firstMs === null || p.lastMs <= p.firstMs) return null;
+  return (p.lastMs - p.firstMs) / 1000;
+}
+
+/**
+ * 消息结束（流式刚结束、工具还没开始）：用真实 usage 定稿三档速率并校准折算比。
+ * 分母 = 相位首 delta → 相位末 delta（总口径为首 delta → message_end），
+ * 不含首 token 延迟与工具执行时长。
+ * @param output - usage.output（含思考）
+ * @param reasoning - usage.reasoning（思考 token，output 的子集；provider 不报时为 0）
+ */
+export function finishSpeedTurn(output: number, nowMs: number, reasoning = 0): SpeedFinal | null {
+  const { think, text, firstMs } = speed;
+  const reasoningTokens = Math.max(0, Math.min(reasoning, output));
+  const textTokens = output - reasoningTokens;
+  calibrate("r", think.chars, reasoningTokens);
+  calibrate("o", text.chars, textTokens);
+  const totalSec = firstMs === null ? null : (nowMs - firstMs) / 1000;
+  const thinkSec = phaseSpanSec(think);
+  const textSec = phaseSpanSec(text);
+  const final: SpeedFinal = {
+    total: output > 0 && totalSec !== null && totalSec > 0 ? reasonableRate(output / totalSec) : null,
+    r: reasoningTokens > 0 && thinkSec !== null ? reasonableRate(reasoningTokens / thinkSec) : null,
+    o: textTokens > 0 && textSec !== null ? reasonableRate(textTokens / textSec) : null,
+  };
+  resetSpeedTurn();
+  // 有真值才覆盖：失败/中止的消息 usage 可能全 0
+  if (final.total !== null || final.r !== null || final.o !== null) speed.final = final;
+  return speed.final;
+}
+
+/**
+ * footer 的 tok/s 片段：流式中 `⚡12.3t/s`（当前相位实时值，不加前缀）；空闲固定三档
+ * `⚡(175.1/r31.8/o613.4)t/s`（总/思考/正文，总档靠位置识别，r/o 带标识），无值打 `-` 占位
+ */
+export function formatSpeedPart(): string {
+  if (speed.active !== null) {
+    const p = speed.active === "r" ? speed.think : speed.text;
+    if (p.rate !== null) return `⚡${p.rate.toFixed(1)}t/s`;
+  }
+  const f = speed.final;
+  if (!f) return "";
+  const cell = (tag: string, v: number | null) => `${tag}${v === null ? "-" : v.toFixed(1)}`;
+  const total = f.total === null ? "-" : f.total.toFixed(1);
+  return `⚡(${total}/${cell("r", f.r)}/${cell("o", f.o)})t/s`;
+}
+
+/** 当前折算比，供 /cost-tier 诊断 */
+export function speedRatios(): { r: number; o: number } {
+  return { r: speedRatio.r, o: speedRatio.o };
+}
+
 /** 一次性提示：TUI 下扩展的 console.error 不落盘也不可见，错误必须走 ui.notify */
 function notifyOnce(ctx: ExtensionContext, text: string): void {
   if (text === lastErrorText) return;
@@ -622,6 +817,9 @@ function installCustomFooter(ctx: ExtensionContext): void {
         const precision = currentCfg?.cacheHitRatePrecision ?? 1;
         statsParts.push(`CH${latestCacheHitRate.toFixed(precision)}%`);
       }
+      // tok/s：⚡ 常显；流式中为当前相位实时值（r 思考 / o 正文），空闲/工具执行时为定稿三档
+      const speedPart = formatSpeedPart();
+      if (speedPart) statsParts.push(speedPart);
       // 订阅制 provider 无法从扩展读取 modelRuntime，退化为内置的特例
       const usingSubscription = c?.model?.provider === "kimi-coding";
       // 未配置模型只改 CH；金额符号和档位标签保持内置默认
@@ -828,6 +1026,7 @@ export default function (pi: ExtensionAPI): void {
         `tierFn: ${fnStatus}`,
         `守卫: ${appliedKey ? "已置位（配置与档位未变则不重注册）" : "未置位（下一轮重注册）"}`,
         `漂移重试: ${driftRetries}/${DRIFT_RETRY_LIMIT}`,
+        `速率折算: 思考 ${speedRatios().r.toFixed(2)} / 正文 ${speedRatios().o.toFixed(2)} 字符/token（真实 token 校准，初始 4）`,
         `最近注册: ${lastRegisterResult}`,
       ];
       const text = `[pi-better-cost-display-footer]\n${lines.join("\n")}`;
@@ -836,9 +1035,27 @@ export default function (pi: ExtensionAPI): void {
     },
   });
   pi.on("session_start", (_e, ctx) => {
+    resetSpeedSession();
     installCustomFooter(ctx);
     apply(pi, ctx);
   });
+  // 速率事件：message_start 清累计（一次 LLM 调用内的估算不跨消息），
+  // message_update 累积流式增量，assistant message_end（工具执行前）用实际 output token 定稿
+  pi.on("message_start", (e) => {
+    if (e.message.role === "assistant") resetSpeedTurn();
+  });
+  // 定稿用 message_end（流式刚结束、工具还没跑）：用 turn_end 会把工具执行时长算进分母
+  pi.on("message_end", (e) => {
+    if (e.message.role !== "assistant") return;
+    const u = e.message.usage;
+    finishSpeedTurn(u?.output ?? 0, Date.now(), u?.reasoning ?? 0);
+  });
+  pi.on("message_update", (e) => {
+    const ev = e.assistantMessageEvent;
+    if (e.message.role !== "assistant" || !("delta" in ev)) return;
+    // 思考与正文分开入窗口：两段速度差一个数量级，混合平均没参考价值
+    pushSpeedDelta(ev.type === "thinking_delta" ? "r" : "o", ev.delta ?? "", Date.now());
+  });
   pi.on("session_shutdown", () => {
     // Pi invalidates session-bound ctx before the next footer render.
     activeCtx = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yalieny/pi-better-cost-display-footer",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "description": "pi extension: scriptable peak/off-peak tier rules per provider with an enhanced footer (tier label, cache-hit-rate precision, custom currency symbol)",
   "keywords": [
     "pi-package",
@@ -9,7 +9,7 @@
   "license": "MIT",
   "type": "module",
   "scripts": {
-    "test": "node --test test/tier.test.ts"
+    "test": "node --test test/tier.test.ts test/speed.test.ts"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",