dsh-mobile-plugin 0.4.8 → 0.5.0

package/lib/mobile/model-prices.cjs

@@ -0,0 +1,88 @@
+'use strict';
+
+/**
+ * 模型单价：把账本里那四个 token 桶折成一个金额（美元，估算值）。
+ *
+ * 价目来自 `model-prices-table.cjs`（models.dev 的快照，与宿主内置那套模型目录同源；
+ * 重新生成见 `scripts/build-model-prices.mjs`）。宿主自己有这份价，但它对外那两份模型清单
+ * 是逐字段拼的、价格被剪掉了，注释里也写着「没有任何消费者报账」—— 所以只能由插件带一份。
+ *
+ * ## 为什么先查「渠道 + 模型」再查「模型」
+ *
+ * 账本里的渠道 id 就是宿主的 provider id：官方渠道（`deepseek` / `anthropic` / `openai`…）
+ * 与表里的写法一致，能精确命中，同名不同价的那几个（同一个模型各家报不一样的价）也就不会串。
+ * 自建路由的 id 是用户自己起的（`route-model-a`），认不出时退到「同名模型各家同价」那一份；
+ * 各家报的价不一致时不猜 —— 一份错的钱比一个「未计价」还糟。
+ *
+ * ## 口径
+ *
+ * `cost = (未缓存输入 × 输入价 + 输出 × 输出价 + 缓存读 × 缓存读价 + 缓存写 × 缓存写价) / 1e6`
+ *
+ * 四档分开算，因为缓存读通常只有输入价的十分之一、缓存写反而更贵（Anthropic 是 1.25 倍），
+ * 合成一个均价会把最省钱的那一块算没。缺档按 0 计（见生成脚本的文件头）。
+ *
+ * 纯函数、不碰文件不碰网络（表在 require 时读一次），守卫直接跑真实现。
+ */
+
+const { AS_OF, BY_MODEL, BY_PROVIDER_MODEL } = require('./model-prices-table.cjs');
+
+/** 表里的价都是「每百万 token」，账本里是 token 数。 */
+const PER_MILLION = 1e6;
+
+/**
+ * 归一化：小写、只留字母与数字（汉字保留）。
+ *
+ * 必须与 `scripts/build-model-prices.mjs` 的 `foldKey` 逐字一致 —— 两边各写一套，
+ * 一改就整张表都查不到，而症状是「成本那一行突然没了」而不是报错。
+ * 与 `model-vendors.js` 的 `foldText` 同一条规则（`v4.1` / `v4-1` 落到同一个串上）。
+ */
+function foldKey(value) {
+  return typeof value === 'string' ? value.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '') : '';
+}
+
+function finite(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+/**
+ * 查一份四档价：`[输入, 输出, 缓存读, 缓存写]`（每百万 token 的美元）。
+ *
+ * 查不到返回 `null` —— 调用方据此**不画**这个数，而不是画一个 0。
+ *
+ * `table` 只在守卫里传：真表太大，测查找规则时喂一份假的就行。
+ */
+function priceOf(provider, model, table) {
+  const source = table || { byModel: BY_MODEL, byProviderModel: BY_PROVIDER_MODEL };
+  const modelKey = foldKey(model);
+  if (!modelKey) return null;
+  const providerKey = foldKey(provider);
+  if (providerKey) {
+    const exact = source.byProviderModel[`${providerKey}/${modelKey}`];
+    if (exact) return exact;
+  }
+  return source.byModel[modelKey] || null;
+}
+
+/**
+ * 一份用量折成金额（美元）。`price` 为空返回 `null`（＝这个模型没价，不算进合计）。
+ *
+ * 返回的是未取整的原值：合计由调用方加完再取整，逐行先取整再加会和合计差几个零头。
+ */
+function costOfUsage(usage, price) {
+  if (!price || !usage) return null;
+  const amount = (
+    finite(usage.uncachedInputTokens) * finite(price[0])
+    + finite(usage.outputTokens) * finite(price[1])
+    + finite(usage.cacheReadTokens) * finite(price[2])
+    + finite(usage.cacheWriteTokens) * finite(price[3])
+  ) / PER_MILLION;
+  return amount;
+}
+
+module.exports = {
+  AS_OF,
+  PER_MILLION,
+  foldKey,
+  priceOf,
+  costOfUsage,
+};

package/lib/mobile/plugin-update.js

@@ -18,7 +18,7 @@
 const path = require('node:path');
 const { sendJson, readJsonBody } = require('../shared/http-util');
 const { checkForUpdate } = require('../update-registry.cjs');
-const { declaredSource } = require('../update-install.cjs');
+const { declaredSource, profileRegistry } = require('../update-install.cjs');
 const { version: generationVersion } = require('../../package.json');
 
 /** apply 的请求体只有 `force` 一个布尔，给 4KB 都很宽。 */
@@ -113,9 +113,24 @@ async function handlePluginUpdateStatus(ctx, _req, res) {
 async function handlePluginUpdateCheck(ctx, _req, res) {
   const status = snapshot(ctx);
   try {
+    // 与装用同一个源：问这台机器上 pnpm 真正在用的注册表（镜像 / 私有源机器上，写死官方源
+    // 等于永远查不到）。问不到才退回官方源。
+    const runtime = runtimeOf(ctx);
+    const live = runtime && typeof runtime.status === 'function' ? runtime.status() : null;
+    let packageManager = null;
+    try {
+      packageManager = typeof ctx?.get === 'function' ? ctx.get('profileContext')?.packageManager ?? null : null;
+    } catch {
+      packageManager = null;
+    }
+    const registry = await profileRegistry({
+      profileNodeModules: typeof live?.profileNodeModules === 'string' ? live.profileNodeModules : null,
+      packageManager,
+    });
     const update = await checkForUpdate({
       installedVersion: status.installedVersion ?? status.runningVersion ?? generationVersion,
       source: status.source,
+      base: registry ?? undefined,
     });
     sendJson(res, 200, { ok: true, update, status });
   } catch (error) {

package/lib/mobile/session-cache.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * 会话侧的按 ctx 隔离状态：十四张表，一个入口。
+ * 会话侧的按 ctx 隔离状态：十五张表，一个入口。
  *
  * 这些表此前全是 sessions.js 的模块级 WeakMap。它们之所以必须按 ctx 隔离，是因为
  * 它们的值属于**宿主进程状态**（某个会话正在跑、某个列表刚构建完、某条发送已经
@@ -51,6 +51,11 @@ const workspaceShortcutStates = new WeakMap();
 // 只用来挡事件流重连的重放；续了几次由会话历史数出来，不放这里。
 const autoContinueTurns = new WeakMap();
 
+// 直播过程副本：还没落盘的那一轮里，推理增量、工具参数增量与工具结果先在内存里留一份，
+// 用户点开「正在读取文件」那一步时由 `/session/step` 就地答（见 mobile/live-steps.js）。
+// 它属于宿主进程状态（这一轮跑到哪了），所以按 ctx 隔离，和上面那些表放在一起。
+const liveStepTurns = new WeakMap();
+
 /** 设备维度：同一个 ctx 下多台手机各自一份，缺省用 'legacy'（未带 x-dsh-device 的调用）。 */
 function canonicalDeviceKey(req, fallback = 'legacy') {
   const value = req?.headers?.['x-dsh-device'];
@@ -385,8 +390,19 @@ function dropSessionListCache(ctx, deviceKey) {
   }
 }
 
+/** 直播过程副本的容器：`ctx → Map<sessionId, turn>`，换一轮就地覆盖（见 live-steps.js）。 */
+function liveStepTurnOf(ctx) {
+  let state = liveStepTurns.get(ctx);
+  if (!state) {
+    state = new Map();
+    liveStepTurns.set(ctx, state);
+  }
+  return state;
+}
+
 module.exports = {
   canonicalDeviceKey,
+  liveStepTurnOf,
   sessionModelsStateOf,
   invalidateSessionModels,
   dropSessionModelsForDevice,

package/lib/mobile/session-step.js

@@ -0,0 +1,226 @@
+'use strict';
+
+/**
+ * 一步的详情：`GET /api/mobile/v1/session/step`。
+ *
+ * 清单（`/session/messages` 里每条 `turnProcess.steps[]`）只带摘要与位置，正文不上线路；
+ * 用户点开清单里的某一步，才由这条路由把**那一步**的完整内容取回来：工具的参数 / 输出 /
+ * diff，或思考的全文。
+ *
+ * 两个数据源，先内存后历史：
+ *  - 还在跑的那一轮：直播流里的原始内容被 `live-steps.js` 留了一份副本，宿主历史里还没有
+ *    落盘，只有这里答得出来；
+ *  - 已经落定的轮：按清单给的 `seq` / `resultSeq` 向宿主回拉**一小窗**事件（宿主没有
+ *    「按 seq 取一条」的接口，只能 beforeSeq 窗口取，代价是两次宿主往返，用户点一下才付）。
+ *
+ * 取不到不是错误状态机的一部分：回 404 + 一句人话，App 那边给一次重试。
+ */
+
+const { sendJson } = require('../shared/http-util');
+const { unwrap } = require('./envelope.js');
+const { callSessions } = require('./rpc.js');
+const { liveStepOf } = require('./live-steps.js');
+const { textOfParts } = require('./step-index.js');
+
+/** 详情单段文本的上限（参数 / 输出 / 思考全文各自适用）。 */
+const DETAIL_MAX_CHARS = 200_000;
+
+/** 回拉窗口的条数上限：宿主 page 接口按消息条数算，这个量级覆盖一次调用到它的结果。 */
+const WINDOW_MAX_MESSAGES = 200;
+
+function intParam(url, name) {
+  const raw = url.searchParams.get(name);
+  if (raw === null || raw === '') return null;
+  if (!/^\d+$/.test(raw)) return null;
+  const value = Number(raw);
+  return Number.isSafeInteger(value) ? value : null;
+}
+
+function strParam(url, name) {
+  const raw = url.searchParams.get(name);
+  return typeof raw === 'string' && raw !== '' ? raw : null;
+}
+
+function capText(text) {
+  if (typeof text !== 'string' || text === '') return { text: '' };
+  if (text.length <= DETAIL_MAX_CHARS) return { text };
+  return { text: text.slice(0, DETAIL_MAX_CHARS), truncated: true };
+}
+
+function historyStatus(error) {
+  switch (error && error.code) {
+    case 'bad-request': return 400;
+    case 'session-not-found':
+    case 'subagent-not-found': return 404;
+    case 'subagent-unauthorized': return 403;
+    case 'host-unavailable': return 503;
+    default: return 502;
+  }
+}
+
+function normalizeError(error) {
+  return {
+    code: error && typeof error.code === 'string' ? error.code : 'host-call-failed',
+    message: error && typeof error.message === 'string' && error.message ? error.message : '取这一步的过程失败',
+  };
+}
+
+/** 向宿主回拉 `beforeSeq` 之前的一小窗事件（`beforeSeq` 是开区间，所以传 `seq + 1`）。 */
+async function fetchWindow(ctx, sessionId, beforeSeq, address) {
+  const payload = { sessionId, maxMessages: WINDOW_MAX_MESSAGES, beforeSeq };
+  const { value, error } = unwrap(await callSessions(ctx, 'history', { ...payload, ...address }));
+  if (error) throw error;
+  const events = (value && Array.isArray(value.events)) ? value.events : [];
+  return events.map((entry) => (entry && entry.event ? entry.event : entry)).filter(Boolean);
+}
+
+function toolBlocksOf(event, callId) {
+  if (!event || event.type !== 'assistant/message') return null;
+  const message = event.data && event.data.message;
+  const content = message && Array.isArray(message.content) ? message.content : null;
+  if (!content) return null;
+  for (const block of content) {
+    if (!block || block.type !== 'tool-call') continue;
+    if (block.id != null && String(block.id) === callId) return block;
+  }
+  return null;
+}
+
+function resultEventOf(events, callId) {
+  for (const event of events) {
+    if (!event || event.type !== 'tool/result') continue;
+    const message = event.data && event.data.message;
+    const src = message && message.source;
+    if (src && typeof src.callId === 'string' && src.callId === callId) return event;
+  }
+  return null;
+}
+
+/** 一步的详情（历史那条路）：按清单给的两个位置分别定位调用与结果。 */
+async function historyStep(ctx, { sessionId, kind, callId, seq, index, resultSeq, address }) {
+  const beforeSeq = Number.isSafeInteger(resultSeq) ? resultSeq + 1 : seq + 1;
+  let events = await fetchWindow(ctx, sessionId, beforeSeq, address);
+  if (kind === 'think') {
+    const target = events.find((event) => event.seq === seq && event.type === 'assistant/message')
+      || (await fetchWindow(ctx, sessionId, seq + 1, address)).find((event) => event.type === 'assistant/message');
+    const message = target && target.data && target.data.message;
+    const content = message && Array.isArray(message.content) ? message.content : [];
+    const block = content[index];
+    const text = block && block.type === 'reasoning' && typeof block.text === 'string' ? block.text : '';
+    if (!text) return null;
+    const capped = capText(text);
+    return { kind: 'think', state: 'ok', text: capped.text, ...(capped.truncated ? { truncated: true } : {}) };
+  }
+  // 工具：调用块给出参数，结果事件给出输出与 diff。两者常常挨着，先在同一次窗口里找，
+  // 找不到再单独补一次（长回合里中间可能夹着别的步骤）。
+  let call = null;
+  for (const event of events) {
+    const block = toolBlocksOf(event, callId);
+    if (block) {
+      call = { block, event };
+      break;
+    }
+  }
+  if (!call && Number.isSafeInteger(seq)) {
+    const again = await fetchWindow(ctx, sessionId, seq + 1, address);
+    for (const event of again) {
+      const block = toolBlocksOf(event, callId);
+      if (block) {
+        call = { block, event };
+        events = again;
+        break;
+      }
+    }
+  }
+  if (!call) return null;
+  const result = resultEventOf(events, callId);
+  const rawArgs = typeof call.block.arguments === 'string'
+    ? call.block.arguments
+    : (call.block.arguments != null ? JSON.stringify(call.block.arguments) : '');
+  const args = capText(rawArgs);
+  let output = '';
+  let diffs;
+  let state = 'running';
+  if (result) {
+    const message = result.data && result.data.message;
+    const direct = message && Array.isArray(message.content) ? message.content : [];
+    const envelope = direct.length === 1 && direct[0] && typeof direct[0] === 'object'
+      && typeof direct[0].type !== 'string' ? direct[0] : null;
+    const parts = envelope ? (Array.isArray(envelope.content) ? envelope.content : []) : direct;
+    const failed = (envelope ? envelope.isError === true : false) || (message && message.isError === true);
+    const code = result.data && result.data.error && typeof result.data.error.code === 'string'
+      ? result.data.error.code : undefined;
+    state = failed ? (code === 'interrupted' ? 'stopped' : 'error') : 'ok';
+    const text = capText(textOfParts(parts));
+    output = text.text;
+    if (text.truncated) diffs = undefined;
+    const meta = result.data && result.data.meta;
+    if (meta && Array.isArray(meta.diffs) && meta.diffs.length > 0) diffs = meta.diffs;
+  }
+  return {
+    kind: 'tool',
+    ...(typeof call.block.name === 'string' && call.block.name ? { name: call.block.name } : {}),
+    state,
+    ...(args.text ? { argsRaw: args.text } : {}),
+    ...(output ? { output } : {}),
+    ...(Array.isArray(diffs) && diffs.length > 0 ? { diffs } : {}),
+    ...(args.truncated ? { truncated: true } : {}),
+  };
+}
+
+/**
+ * 取一步的详情。
+ *
+ * 参数：`sessionId` 必填；`kind` = `tool` | `think`；`callId`（工具）/ `index`（思考）
+ * 用于直播副本；`seq` / `resultSeq` 是清单里带的位置，用于回落历史。
+ * 子代理会话要额外带 `parentSessionId` + `mode`。
+ */
+async function handleSessionStep(ctx, req, res) {
+  const url = new URL(req.url, 'http://x');
+  const sessionId = strParam(url, 'sessionId');
+  if (!sessionId) return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '缺少 sessionId' } });
+  const kind = url.searchParams.get('kind') === 'think' ? 'think' : 'tool';
+  const callId = strParam(url, 'callId');
+  const index = intParam(url, 'index');
+  const seq = intParam(url, 'seq');
+  const resultSeq = intParam(url, 'resultSeq');
+  const parentSessionId = url.searchParams.get('parentSessionId');
+  const mode = url.searchParams.get('mode');
+  const hasSubagentAddress = parentSessionId !== null || mode !== null;
+  if (hasSubagentAddress && (
+    typeof parentSessionId !== 'string' || parentSessionId.trim() === ''
+    || (mode !== 'one-shot' && mode !== 'continuable')
+  )) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '子代理会话需要 parentSessionId 和有效 mode' } });
+  }
+  if (kind === 'tool' && !callId) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '缺少 callId' } });
+  }
+  // 还在跑的那一轮：直播副本里就有，不必去问宿主（那边还没落盘），也就不必要求位置 ——
+  // 跑到一半的调用只有 `callId`、思考只有块序号。
+  const live = liveStepOf(ctx, sessionId, { kind, callId, index });
+  if (live) return sendJson(res, 200, { ok: true, step: live });
+  if (kind === 'think' && (index === null || seq === null)) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '缺少这一步的位置' } });
+  }
+  if (kind === 'tool' && seq === null && resultSeq === null) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '缺少这一步的位置' } });
+  }
+
+  const address = hasSubagentAddress ? { parentSessionId, mode } : {};
+  try {
+    const step = await historyStep(ctx, { sessionId, kind, callId, seq, index, resultSeq, address });
+    if (!step) {
+      return sendJson(res, 404, {
+        ok: false,
+        error: { code: 'step-not-found', message: '这一步的过程已经不在电脑上了' },
+      });
+    }
+    return sendJson(res, 200, { ok: true, step });
+  } catch (error) {
+    const normalized = normalizeError(error);
+    return sendJson(res, historyStatus(normalized), { ok: false, error: normalized });
+  }
+}
+
+module.exports = { handleSessionStep, DETAIL_MAX_CHARS };

package/lib/mobile/stats-collect.cjs

@@ -29,6 +29,16 @@ const ledger = require('./stats-ledger.cjs');
 /** 同一条会话两次采集之间的最小间隔（打开页面时的重复请求直接复用上一轮结果）。 */
 const COLLECT_INTERVAL_MS = 60_000;
 
+/**
+ * 老记录补模型的重试间隔。
+ *
+ * 「模型维度」上线之前记过的会话没有模型这一栏，之后再没动静就一直补不上 —— 而统计页的成本
+ * 是按模型桶折算的，缺一条就少一整块钱。补法是读一次宿主的当前模型（很便宜的读），顺手做在
+ * 跳过分支里；读不到（会话没了 / 渠道卸了）也把尝试时间记下，一天最多问一次，否则空闲那几轮
+ * 会被几百条老记录拖成每轮几百次宿主调用，把「没变动就不花钱」那条设计作废。
+ */
+const MODEL_BACKFILL_RETRY_MS = 24 * 3600_000;
+
 /** 并发读投影的条数：宿主那侧是内存里读缓存，四条并行不会把它压住。 */
 const CONCURRENCY = 4;
 
@@ -208,6 +218,34 @@ async function readSessionModel(ctx, sessionId) {
   }
 }
 
+/**
+ * 老记录补模型：这条会话在「模型维度」上线之前就记过量、之后一直没动静，模型卡里永远没有
+ * 它那一份 —— 而统计页的成本是按模型桶折算的，缺一条就少一整块钱。
+ *
+ * 只做一件事：读一次宿主的当前模型（不碰投影、不碰水位），把这条会话的**累计量**复制进模型桶，
+ * 与升级当天那次回填同一个口径（`record.model` 一旦有了，之后的增量就照常记）。读不到也把
+ * 尝试时间记下 —— 试过这件事本身要落盘，否则下一轮还会为同一条再问一次。
+ *
+ * @returns 账本有没有改动（改了就落盘）。
+ */
+async function backfillModel(ctx, book, sessionId, record, at) {
+  if (!record || record.gone || record.model) return false;
+  if (billedOf(record.billed) <= 0) return false;
+  const tried = num(record.modelTriedAt);
+  if (tried > 0 && at - tried < MODEL_BACKFILL_RETRY_MS) return false;
+  record.modelTriedAt = at;
+  const model = await readSessionModel(ctx, sessionId);
+  if (model) {
+    ledger.applyModelUsage(book, {
+      model,
+      day: ledger.dayKeyOf(num(record.lastAt) || at),
+      usage: record.billed,
+    });
+    record.model = model;
+  }
+  return true;
+}
+
 /**
  * 采集串行化：同一时刻只跑一轮。
  *
@@ -300,12 +338,14 @@ async function collectOnce(ctx, options = {}) {
       if (!options.force && record && record.collectedAt && now - record.collectedAt < COLLECT_INTERVAL_MS) {
         // 还没到下一次采集的点：只把可能变了的名字补上，数字一个字不动。
         renameIfNeeded();
+        if (await backfillModel(ctx, book, sessionId, record, now)) touched = true;
         continue;
       }
       // 宿主摘要的 `updatedAt` 与上次读到的一模一样 = 这条一点没动过，水位差必然是 0。
       // 定期采集每几分钟一轮，靠这一条把空闲那几轮压成「一次列表调用」。
       if (!options.force && record && record.seenUpdatedAt && num(summary.updatedAt) <= num(record.seenUpdatedAt)) {
         renameIfNeeded();
+        if (await backfillModel(ctx, book, sessionId, record, now)) touched = true;
         continue;
       }
 

package/lib/mobile/stats-ledger.cjs

@@ -16,6 +16,10 @@
  * 会话正在用的那个选择（见 stats-collect.cjs 文件头），会话中途换模型的那一段整体归到换后的
  * 那个名下。这是水位法本来就有的近似，不是这里另加的简化。
  *
+ * 金额（`cost`）是**估算**，不落盘：折算时按模型桶的四个 token 桶乘单价（`model-prices.cjs`），
+ * 价格变了下次出数就跟着变，账本里不留一份会过期的钱。模型归属的近似照旧继承下来；查不到单价
+ * 的那一截 token 由 `unpricedBilled` 明说，不摊进合计。
+ *
  * 只做纯数据（读写 + 折算），不碰网络；采集在 stats-collect.cjs，路由在 stats.js。
  */
 
@@ -24,6 +28,7 @@ const path = require('node:path');
 
 const paths = require('../shared/paths');
 const { identifyVendor, vendorLogoOf } = require('./model-vendors.js');
+const { AS_OF, costOfUsage, priceOf } = require('./model-prices.cjs');
 
 /** 账本格式版本：将来改结构时据此决定是丢弃还是迁移。 */
 const VERSION = 1;
@@ -263,6 +268,9 @@ function sanitizeLedger(raw) {
         composition: readComposition(value.composition),
         // 采集那一刻这条会话用的渠道 + 模型。升级前的老记录没有这一栏，当没有。
         model: sanitizeModelSelection(value.model),
+        // 上一次为这条老记录补模型的时间（见 stats-collect 的 `backfillModel`）：读不到也记，
+        // 否则每一轮都会再问一次宿主，把「空闲时不花钱」那条设计作废。
+        modelTriedAt: num(value.modelTriedAt),
         // 水位是「宿主那边这条会话的累计值」，缺省为 null 表示还没采过（首采全量入账）。
         watermark: value.watermark && typeof value.watermark === 'object' ? sanitizeUsage(value.watermark) : null,
       };
@@ -413,6 +421,7 @@ function emptySession(at) {
     daily: {},
     composition: null,
     model: null,
+    modelTriedAt: 0,
     watermark: null,
   };
 }
@@ -496,6 +505,16 @@ function billedOf(usage) {
   return num(usage.uncachedInputTokens) + num(usage.cacheReadTokens) + num(usage.cacheWriteTokens) + num(usage.outputTokens);
 }
 
+/**
+ * 金额取到六位小数。
+ *
+ * 逐行先取整再加会和合计对不上（一条几十万 token 的行差几厘，几十行就有分位上的差），
+ * 所以行与合计都从原值算、最后各自取整；六位是「十万 token 的一档价」还看得见的精度。
+ */
+function moneyOf(value) {
+  return Math.round(num(value) * 1e6) / 1e6;
+}
+
 /**
  * 一条会话在 [startDay, today] 里的用量。
  *
@@ -633,6 +652,10 @@ function summarize(ledger, range, now) {
   // 这一份里认出来的厂商，只带**用到的那几个**图标（`icon` 是一段 SVG 标记，App 用 SvgXml
   // 直接画）：一次响应几十条模型行各自背一份图标没有意义。
   const vendors = {};
+  /** 有价的那几行加起来：金额、它们覆盖的 token、行数（0 行就整项不给，页面不画）。 */
+  let costTotal = 0;
+  let costPricedBilled = 0;
+  let costPricedRows = 0;
   for (const bucket of Object.values(ledger.models || {})) {
     if (!bucket || typeof bucket !== 'object') continue;
     const usage = usageInRange(bucket, startDay, today);
@@ -645,6 +668,13 @@ function summarize(ledger, range, now) {
     const vendor = identifyVendor(bucket);
     const logo = vendor ? vendorLogoOf(vendor) : null;
     if (logo) vendors[vendor] = logo;
+    // 金额只在查得到单价时给：查不到不画 0，那一截 token 由下面的 `unpricedBilled` 交代。
+    const cost = costOfUsage(usage, priceOf(bucket.provider, bucket.model));
+    if (cost !== null) {
+      costTotal += cost;
+      costPricedBilled += billedTokens;
+      costPricedRows += 1;
+    }
     models.push({
       provider: bucket.provider || '',
       providerName: bucket.providerName || '',
@@ -660,6 +690,7 @@ function summarize(ledger, range, now) {
       // 请求数取 `usage.steps`，与按天账同一个口径（见 applyDelta 里的那条注释）。
       requests: num(usage.steps),
       lastAt: num(bucket.lastAt),
+      ...(cost === null ? {} : { cost: moneyOf(cost) }),
     });
   }
   models.sort((a, b) => (b.billedTokens !== a.billedTokens ? b.billedTokens - a.billedTokens : b.lastAt - a.lastAt));
@@ -678,6 +709,20 @@ function summarize(ledger, range, now) {
     models,
     // 一个厂商都没认出来时整项不出：老 App 不认识这个字段，新 App 缺它就是「没有图标」。
     ...(Object.keys(vendors).length > 0 ? { vendors } : {}),
+    // 成本合计只加「查得到单价」的那几行：一行都没有就整项不给 —— 缺这个字段，页面就不画
+    // 这一条（与 `models` 同一条规矩），比画一个 $0 强。`unpricedBilled` 是第 4 档：
+    // 范围内有量、但这台机器没有价（自建路由 / 免费渠道 / 老账本）的那一截。
+    ...(costPricedRows > 0
+      ? {
+        cost: {
+          currency: 'USD',
+          total: moneyOf(costTotal),
+          pricedBilled: costPricedBilled,
+          unpricedBilled: Math.max(0, rangeBilled - costPricedBilled),
+          asOf: AS_OF,
+        },
+      }
+      : {}),
   };
 }
 

package/lib/mobile/step-index.js

@@ -0,0 +1,108 @@
+'use strict';
+
+/**
+ * 过程清单的一步：手机端只拿「一行摘要 + 状态 + 位置」，正文（推理全文、工具参数、
+ * 输出、diff）一律走 `/session/step` 按需取。
+ *
+ * 这里只有纯函数：摘要怎么算、状态怎么判、参数里的路径怎么取。投影层（history-derive）
+ * 与详情端点（session-step）都从这里取，避免「清单里写一种说法、详情里又是另一种」。
+ */
+
+/** 一步摘要的字数上限：清单是一行省略，再长也看不见，白白占线路。 */
+const STEP_SUMMARY_MAX = 72;
+
+/** 摘要里保留的第一个非空行（推理正文常带 markdown，去掉粗体标记与多余空白）。 */
+function firstLine(text) {
+  const line = String(text || '').replace(/\r\n/g, '\n').split('\n').find((part) => part.trim() !== '') || '';
+  return line.replace(/\*\*/g, '').trim();
+}
+
+/** 截断到上限，超出用一个省略号收尾。 */
+function clampSummary(text, max = STEP_SUMMARY_MAX) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+  if (value.length <= max) return value;
+  return `${value.slice(0, max - 1)}…`;
+}
+
+/** 推理正文的一行摘要。 */
+function reasoningStepSummary(text) {
+  return clampSummary(firstLine(text));
+}
+
+/** 参数 JSON → 对象；解析不了就返回空对象（畸形参数不该让清单少一条）。 */
+function parseArgs(raw) {
+  if (raw && typeof raw === 'object') return raw;
+  if (typeof raw !== 'string' || raw.trim() === '') return {};
+  try {
+    const value = JSON.parse(raw);
+    return value && typeof value === 'object' ? value : {};
+  } catch {
+    return {};
+  }
+}
+
+/** 参数里第一个像路径/命令/查询词的字段（桌面各工具卡片也是这么挑的）。 */
+function firstStringArg(args, keys) {
+  for (const key of keys) {
+    const value = args[key];
+    if (typeof value === 'string' && value.trim() !== '') return value.trim();
+  }
+  return '';
+}
+
+/**
+ * 工具调用的一行摘要：读/写/改给路径，命令给命令，搜索给查询词，其余退回描述或工具名。
+ *
+ * 摘要必须带信息量：用户是看着这一行决定「值不值得点开」的，只写「读取文件」等于没写。
+ */
+function toolStepSummary(name, rawArgs) {
+  const args = parseArgs(rawArgs);
+  switch (name) {
+    case 'bash':
+    case 'pwsh':
+    case 'terminal_send':
+      return clampSummary(firstStringArg(args, ['command', 'cmd']) || firstStringArg(args, ['description']));
+    case 'write':
+    case 'edit':
+    case 'str_replace_editor':
+    case 'read':
+    case 'read_image':
+      return clampSummary(firstStringArg(args, ['file_path', 'path']) || firstStringArg(args, ['description']));
+    case 'grep':
+    case 'glob':
+      return clampSummary(firstStringArg(args, ['pattern', 'query']) || firstStringArg(args, ['path']));
+    case 'web_fetch':
+      return clampSummary(firstStringArg(args, ['url']));
+    case 'web_search':
+      return clampSummary(firstStringArg(args, ['query']) || firstStringArg(args, ['q']));
+    default:
+      return clampSummary(firstStringArg(args, ['description', 'path', 'file_path', 'command', 'query']));
+  }
+}
+
+/** 工具结果的成败 → 一步的状态（与 App 那份 UI 用同一套词）。 */
+function toolStepState(result) {
+  if (!result) return 'running';
+  if (result.isError) return result.code === 'interrupted' ? 'stopped' : 'error';
+  return 'ok';
+}
+
+/** 内容块里那段文本（工具结果两种形状都认，见 history-derive 的 toolResultParts）。 */
+function textOfParts(parts) {
+  if (!Array.isArray(parts)) return '';
+  return parts
+    .map((part) => (part && typeof part.text === 'string' ? part.text : ''))
+    .filter(Boolean)
+    .join('');
+}
+
+module.exports = {
+  STEP_SUMMARY_MAX,
+  firstLine,
+  clampSummary,
+  reasoningStepSummary,
+  parseArgs,
+  toolStepSummary,
+  toolStepState,
+  textOfParts,
+};