dsh-model-billing 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.3.2] - 2026-11-05
+
+### 变更
+
+- 费用统计改为读取 Session 投影，不再调用已弃用的同步会话事件读取接口（DSH 0.2.2 起标记弃用，后续大版本可能移除）；费用数字与直接折叠会话日志的结果一致。
+- 切换模型或推理强度被拒绝时，改为菜单内浮层提示并自动消失，菜单不再因错误信息被撑高；模型目录本身加载失败时仍保留内联错误与「重新加载」按钮。
+
+### Changed
+
+- Cost estimation now reads a Session projection instead of the deprecated synchronous session-event readers (deprecated since DSH 0.2.2 and removable in a later major version); the reported cost matches folding the session log directly.
+- A rejected model or reasoning-effort switch now shows a self-dismissing overlay inside the picker instead of an inline error that grew the menu; a failed model-catalog load still shows the inline error with its retry button.
+
+## [0.3.1] - 2026-11-05
+
+### 变更
+
+- 只对 DeepSeek 独立的 Search / Fetch API（`deepseek-search-api` / `deepseek-fetch-api`）计入按次费；Messages 搜索（`deepseek-official`）的检索在模型回合内完成，费用已随该次请求的 token 计入，不再重复按次收费。
+
+### Changed
+
+- Per-request Search/Fetch fees now apply only to DeepSeek's standalone Search / Fetch APIs (`deepseek-search-api` / `deepseek-fetch-api`). Messages search (`deepseek-official`) runs inside a model turn, so its cost already arrives as that turn's tokens and is no longer charged per request.
+
 ## [0.3.0] - 2026-11-02
 
 ### 新增

package/README.md

@@ -34,7 +34,7 @@
 - **逐轮费用与使用模型**：每轮结束后在轮尾显示这一轮使用的模型，以及该轮费用和缓存命中率。
 - **可配置轮尾**：在设置中总开关轮尾显示，并可分别开关使用模型、模型提供商、费用、token、缓存命中率、文字标签，调整字号、间距和字重；也可以关闭选择器接管，恢复 DSH 内置模型选择器。输入框下方的费用估算另有独立开关。
 - **本会话费用**：输入框下方显示本会话累计估算、最近一轮费用和缓存命中率；展开后可查看按轮次和按模型的明细。
-- **DeepSeek Search/Fetch 按次费**：当 DSH 的 Web 搜索或抓取使用 DeepSeek 自带 provider 时，按官方 ¥5 / 1,000 次成功请求计入合计，并在费用明细里单独列出搜索、抓取的计费次数。
+- **DeepSeek Search/Fetch 按次费**：当 DSH 的 Web 搜索或抓取使用 DeepSeek 独立的 Search / Fetch API 时，按官方 ¥5 / 1,000 次成功请求计入合计，并在费用明细里单独列出搜索、抓取的计费次数。
 - **历史价格与未定价路由**：设置页的“历史价格”区可以为已移出配置的模型补价、改价或删除，不必把模型加回列表；从模型列表删除模型不会删除它的价格，历史调用仍按保存的价格计算，查不到名称时显示原始模型 id。缺价时显示统一提示，可在设置里关闭这条提示。
 - **DeepSeek 也计入金额**：每条 usage 按事件发生时的北京时间自动选择高峰或空闲价，与第三方模型一起进入统计。
 
@@ -133,7 +133,7 @@ npm 包和 GitHub Release 使用相同版本号，两个渠道分别发布：
 - 一轮里的多次模型尝试（重试、失败等）会分别计入；失败调用如果 provider 没有返回 usage，则无法计入。
 - 只统计当前载入 Host 的会话；未打开的历史会话在进入后按需计算。
 - provider 返回的 `totalTokens` 与三档明细不一致时，保留三档明细并把该轮标为“部分未定价/不完整”，不再整条丢弃，避免大幅少报。
-- 当 DSH 的 Web 搜索或抓取使用 DeepSeek 自带的 `deepseek-official` / `deepseek-search-api` / `deepseek-fetch-api` 时，按 DeepSeek 官方价把 **Search/Fetch 按次费**（¥5 / 1,000 次成功请求，2026-11-01 00:00 北京时间起）计入合计；DuckDuckGo、Tavily、普通 HTTP 抓取等不收费的 provider 不会被计费。一次 `web_search` 含多个 query 时按一次成功工具调用计，可能低估其中多个 query 各自的按次费。
+- 当 DSH 的 Web 搜索或抓取使用 DeepSeek 独立的 `deepseek-search-api` / `deepseek-fetch-api` 时，按 DeepSeek 官方价把 **Search/Fetch 按次费**（¥5 / 1,000 次成功请求，2026-11-01 00:00 北京时间起）计入合计；Messages 搜索（`deepseek-official`）在模型回合内完成，费用已随该次请求的 token 计入，因此不再重复收按次费。DuckDuckGo、Tavily、普通 HTTP 抓取等不收费的 provider 不会被计费。一次 `web_search` 含多个 query 时按一次成功工具调用计，可能低估其中多个 query 各自的按次费。
 - 第三方价格是静态配置，不会自动跟随官网调价；内置节假日表目前只覆盖 2026 年，2027 年起需更新 `DEEPSEEK_HOLIDAYS`。
 
 ### 开发
@@ -164,7 +164,7 @@ node --test test/*.test.mjs
 - **Per-turn model and amount** at the end of each turn, together with the turn's cache-hit rate.
 - **Configurable turn tail**: a master switch for the turn tail, plus individual toggles for models, provider names, cost, tokens, cache-hit rate, and text labels; adjust font size, spacing, and weight; or disable the picker takeover to restore the built-in DSH picker. The composer cost estimate has its own switch.
 - **Session summary** below the composer plus a detail panel grouped by turn and by model.
-- **DeepSeek Search/Fetch per-request fees**: when DSH web search or fetch runs on DeepSeek's own providers, the official fee of ¥5 per 1,000 successful requests is included, with search and fetch billed counts shown separately in the detail panel.
+- **DeepSeek Search/Fetch per-request fees**: when DSH web search or fetch runs on DeepSeek's standalone Search / Fetch APIs, the official fee of ¥5 per 1,000 successful requests is included, with search and fetch billed counts shown separately in the detail panel.
 - **Historical prices and unpriced routes**: the "Historical prices" section in Settings lets you add, edit, or remove prices for models no longer in your order without re-adding them. Removing a model from the list keeps its price, so historical calls still bill correctly; when the name is unknown, the raw model id is shown. Unpriced calls share one notice that can be switched off.
 - **DeepSeek is billed too**, using the same three-price formula and the event's timestamp.
 
@@ -235,7 +235,7 @@ Order and prices live in `~/.dsh/model-billing.json` (or `$DSH_HOME/model-billin
 - Multiple attempts within a turn are counted separately; failed calls without provider usage cannot be counted.
 - Only sessions loaded by the current Host are counted.
 - When a provider's `totalTokens` disagrees with its three buckets, the buckets are kept and the turn is marked partial instead of being dropped, which avoids large under-reporting.
-- When DSH web search or fetch runs on DeepSeek's own `deepseek-official`, `deepseek-search-api`, or `deepseek-fetch-api` providers, the DeepSeek **Search/Fetch per-request fee** (¥5 per 1,000 successful requests, from 2026-11-01 00:00 Beijing time) is included. Free providers such as DuckDuckGo, Tavily, and plain HTTP fetch are never charged. A `web_search` call containing several queries is counted as one successful tool call, so the per-query part may be understated.
+- When DSH web search or fetch runs on DeepSeek's standalone `deepseek-search-api` / `deepseek-fetch-api` providers, the DeepSeek **Search/Fetch per-request fee** (¥5 per 1,000 successful requests, from 2026-11-01 00:00 Beijing time) is included. Messages search (`deepseek-official`) runs inside a model turn, so its cost already arrives as that turn's tokens and is not charged again per request. Free providers such as DuckDuckGo, Tavily, and plain HTTP fetch are never charged. A `web_search` call containing several queries is counted as one successful tool call, so the per-query part may be understated.
 - Third-party prices are static and are not refreshed automatically. The bundled holiday table covers 2026 only; update `DEEPSEEK_HOLIDAYS` for 2027 onward.
 
 ### Development

package/client.js

@@ -751,7 +751,12 @@ window.__ModuleLoader__.load({
       .mb-picker-search::placeholder { color: var(--dsw-alias-label-caption, var(--dsw-alias-label-secondary)); }
       .mb-picker-search:focus { border-color: var(--dsw-alias-state-business-primary); outline: none; }
       .mb-picker-list { min-height: 0; overflow-y: auto; padding: 0 2px; display: flex; flex-direction: column; }
-      .mb-picker-group { color: var(--dsw-alias-label-tertiary, var(--dsw-alias-label-secondary)); background: var(--dsw-alias-menu-group-header-fill, var(--dsw-menu-surface-fill, var(--dsw-alias-bg-layer-1))); position: sticky; top: 0; z-index: 1; margin-top: 2px; padding: 10px 10px 6px; font-size: 11px; font-weight: 500; line-height: 16px; }
+      .mb-picker-group { color: var(--dsw-alias-label-tertiary, var(--dsw-alias-label-secondary)); background: var(--dsw-alias-menu-group-header-fill, var(--dsw-menu-surface-fill, var(--dsw-alias-bg-layer-1))); position: sticky; top: 0; z-index: 1; margin-top: 2px; padding: 5px 10px; font-size: 11px; font-weight: 500; line-height: 16px; }
+      /* The first group header opens the list, so the menu's own padding already
+         separates it from the top edge; it only drops the inter-group lead-in.
+         A negative margin cannot do this: the list is a scroll container, and the
+         overflow clip eats any lead-in that leaves its scrollport. */
+      .mb-picker-group:first-child { margin-top: 0; }
       .mb-picker-row { box-sizing: border-box; border-radius: var(--dsw-radius-md); width: auto; min-width: 100%; color: inherit; text-align: left; cursor: pointer; background: 0 0; border: none; outline: none; align-items: center; gap: 8px; padding: 10px; font: inherit; display: flex; }
       .mb-picker-row + .mb-picker-row { margin-top: 2px; }
       .mb-picker-row:hover:not(:disabled), .mb-picker-row:focus-visible { background: var(--dsw-alias-interactive-bg-hover); }
@@ -773,6 +778,9 @@ window.__ModuleLoader__.load({
       .mb-picker-error { border-radius: var(--dsw-radius-md); background: var(--dsw-alias-interactive-bg-hover-danger); color: var(--dsw-alias-state-error-primary); margin-bottom: 3px; padding: 6px 7px; font-size: 11px; line-height: 16px; }
       .mb-picker-retry { align-self: flex-start; margin: 0 4px 2px; }
       .mb-picker-status { color: var(--dsw-alias-label-tertiary, var(--dsw-alias-label-secondary)); padding: 4px 7px; font-size: 11px; line-height: 16px; }
+      .mb-picker-dot { width: 12px; height: 12px; border: 2px solid var(--dsw-alias-state-business-primary); border-right-color: transparent; border-radius: 50%; flex: none; animation: mb-picker-spin .7s linear infinite; }
+      @keyframes mb-picker-spin { to { transform: rotate(360deg); } }
+      .mb-picker-toast { position: absolute; left: 8px; right: 8px; bottom: 8px; z-index: 3; border-radius: var(--dsw-radius-md); background: var(--dsw-alias-state-error-primary); color: #fff; padding: 7px 9px; font-size: 12px; line-height: 16px; box-shadow: var(--dsw-elevation-prominent); }
       .mb-fatal { border: 1px solid var(--dsw-alias-state-error-primary); color: var(--dsw-alias-state-error-primary); border-radius: 8px; padding: 12px; }
       @media (max-width: 720px) {
         .mb-price-grid { grid-template-columns: 1fr; }
@@ -1758,7 +1766,10 @@ window.__ModuleLoader__.load({
       const [open, setOpen] = useState(false)
       const [query, setQuery] = useState('')
       const [selecting, setSelecting] = useState(false)
-      const [failure, setFailure] = useState(null)
+      // The route being submitted, so its row can show a pending spinner, and a
+      // transient rejection message that must not push the list around.
+      const [pending, setPending] = useState(null)
+      const [toast, setToast] = useState(null)
       const [menuPos, setMenuPos] = useState(null)
       // Roving cursor for arrow-key navigation inside the model list.
       const [activeIndex, setActiveIndex] = useState(0)
@@ -1816,6 +1827,13 @@ window.__ModuleLoader__.load({
         if (locked && open) setOpen(false)
       }, [locked, open])
 
+      // A rejection toast clears itself; the menu is not blocked while it shows.
+      useEffect(() => {
+        if (toast === null) return undefined
+        const timer = setTimeout(() => setToast(null), 4200)
+        return () => clearTimeout(timer)
+      }, [toast])
+
       const rank = useMemo(() => {
         const map = new Map()
         for (const model of catalogSnap.data?.models ?? []) {
@@ -1952,14 +1970,15 @@ window.__ModuleLoader__.load({
       const close = (restoreFocus) => {
         setOpen(false)
         setQuery('')
-        setFailure(null)
+        setToast(null)
         if (restoreFocus) queueMicrotask(() => triggerRef.current?.focus())
       }
 
       const submit = async (selection) => {
         if (busy) return
         setSelecting(true)
-        setFailure(null)
+        setToast(null)
+        setPending(selection)
         try {
           const result = directory !== null
             ? await directory.select(selection)
@@ -1969,14 +1988,16 @@ window.__ModuleLoader__.load({
               body: JSON.stringify({ sessionId, ...selection }),
             })
           if (result?.ok === false) {
-            setFailure(result.error?.message ?? translate('pickerEmpty'))
+            // A refusal is a toast: the list stays where the user left it.
+            setToast(result.error?.message ?? translate('pickerEmpty'))
             return
           }
           close(true)
         } catch (error) {
-          setFailure(error instanceof Error ? error.message : String(error))
+          setToast(error instanceof Error ? error.message : String(error))
         } finally {
           setSelecting(false)
+          setPending(null)
         }
       }
 
@@ -2006,7 +2027,7 @@ window.__ModuleLoader__.load({
           close(true)
           return
         }
-        setFailure(null)
+        setToast(null)
         // Open the cursor on the row the user is already using, when there is one.
         const selectedAt = filtered.findIndex((entry) => entry.group.id === current?.provider && entry.model.id === current?.model)
         setActiveIndex(selectedAt < 0 ? 0 : selectedAt)
@@ -2022,7 +2043,6 @@ window.__ModuleLoader__.load({
           maxHeight: menuPos.maxHeight,
           ...menuPos.top === undefined ? { bottom: menuPos.bottom } : { top: menuPos.top },
         }
-      const errorText = failure ?? (state?.status === 'error' ? state.error : null)
 
       // Arrow keys move a roving cursor through the list. Enter and Space are
       // left to the focused row itself, so a <button> keeps its native
@@ -2123,18 +2143,20 @@ window.__ModuleLoader__.load({
                     h('span', { className: 'mb-picker-model' }, entry.model.name),
                     h(PriceLines, { pricing: price, translate })),
                   h('span', { className: 'mb-picker-check' },
-                    selected
-                      ? h('svg', {
-                        viewBox: '0 0 16 16',
-                        width: 14,
-                        height: 14,
-                        fill: 'none',
-                        stroke: 'currentColor',
-                        strokeWidth: 1.7,
-                        'aria-hidden': true,
-                      },
-                        h('path', { d: 'M3.5 8.5l3 3 6-7' }))
-                      : null)))
+                    pending !== null && pending.provider === entry.group.id && pending.model === entry.model.id
+                      ? h('span', { className: 'mb-picker-dot', 'aria-hidden': true })
+                      : selected
+                        ? h('svg', {
+                          viewBox: '0 0 16 16',
+                          width: 14,
+                          height: 14,
+                          fill: 'none',
+                          stroke: 'currentColor',
+                          strokeWidth: 1.7,
+                          'aria-hidden': true,
+                        },
+                          h('path', { d: 'M3.5 8.5l3 3 6-7' }))
+                        : null)))
             })),
         effortChoices.length === 0 ? null : h(Fragment, null,
           h('div', { className: 'mb-picker-divider' }),
@@ -2149,13 +2171,15 @@ window.__ModuleLoader__.load({
               onClick: () => chooseEffort(choice.effort),
             }, choice.label)))),
         busy ? h('div', { className: 'mb-picker-status' }, translate('switching')) : null,
-        errorText === null ? null : h('div', { className: 'mb-picker-error' }, errorText),
+        toast === null ? null : h('div', { className: 'mb-picker-toast', role: 'status', 'aria-live': 'polite' }, toast),
+        state?.status === 'error'
+          ? h('div', { className: 'mb-picker-error' }, state.error)
+          : null,
         state?.status === 'error'
           ? h('button', {
             type: 'button',
             className: 'mb-btn mb-picker-retry',
             onClick: () => {
-              setFailure(null)
               directory.load().catch(() => {})
             },
           }, translate('pickerRetry'))
@@ -2260,7 +2284,10 @@ window.__ModuleLoader__.load({
         ctx.slots.inject('settings.section', () => ctx.slots.register({
           name: 'settings.section',
           id: 'model-billing',
-          order: 12,
+          // Native sections run -10..20 (account, general, models, plugins,
+          // agent presets); third-party pages start at 25 so they sit below
+          // the native group instead of splitting it.
+          order: 25,
           label: () => t('nav'),
         }, SettingsSection))
 

package/host.js

@@ -30,7 +30,11 @@ const KEY_SEPARATOR = '\u0000'
 // tool/result per invocation, so the fee can be folded from the session log.
 const DEEPSEEK_WEB_TOOL_START = Date.parse('2026-11-01T00:00:00+08:00')
 const DEEPSEEK_WEB_TOOL_PRICE = 0.005
-const DEEPSEEK_SEARCH_PROVIDERS = new Set(['deepseek-official', 'deepseek-search-api'])
+// Only the standalone Search/Fetch APIs are billed per request. The Messages
+// search provider (`deepseek-official`) runs Anthropic's `web_search_20250305`
+// server tool inside a model turn, so its cost already arrives as prompt and
+// completion tokens; charging ¥0.005 there would bill the same call twice.
+const DEEPSEEK_SEARCH_PROVIDERS = new Set(['deepseek-search-api'])
 const DEEPSEEK_FETCH_PROVIDERS = new Set(['deepseek-fetch-api'])
 const DISPLAY_DEFAULTS = Object.freeze({
   showTurnTail: true,
@@ -1135,6 +1139,9 @@ export function apply(ctx) {
   const onSelect = (request, response) => {
     void serveSelect(ctx, request, response).catch((error) => fail(ctx, response, error))
   }
+  // Register the samples projection before the routes: the unit folds lazily for
+  // sessions that already existed, and drives every later event eagerly.
+  void billingProjectionHandle(ctx)
   ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: CATALOG_PATH, handler: onCatalog }), 'model-billing: catalog route')
   ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: USAGE_PATH, handler: onUsage }), 'model-billing: usage route')
   ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: SAVE_PATH, handler: onSave }), 'model-billing: save route')
@@ -1157,6 +1164,156 @@ function wantsRefresh(request) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Billing samples
+//
+// `session.ownEvents()` / `snapshotEvents()` are synchronous log reads that
+// 0.2.2 deprecates for production use, so the fold is fed by a session
+// projection instead: the registry drives it per committed event, folds the log
+// lazily for sessions that predate the registration, and checkpoints it with
+// every other unit. The state keeps a trimmed copy of each billing-relevant
+// event rather than the durable log, because the fold only reads a few fields.
+// ---------------------------------------------------------------------------
+
+const BILLING_SAMPLES_KEY = 'model-billing/samples'
+const BILLING_SAMPLES_VERSION = 1
+
+/** The last usage chunk of a durable assistant stream, kept alone. */
+function usageStreamRecord(stream) {
+  if (!Array.isArray(stream)) return undefined
+  for (let index = stream.length - 1; index >= 0; index -= 1) {
+    const record = stream[index]
+    if (record?.type === 'chunk' && record.chunk?.type === 'usage') {
+      return { type: 'chunk', time: record.time, chunk: { type: 'usage', usage: record.chunk.usage } }
+    }
+  }
+  return undefined
+}
+
+/** One committed event trimmed to the fields `computeSessionUsage` reads. */
+function billingSample(event) {
+  const seq = event?.seq
+  const time = event?.time
+  switch (event?.type) {
+    case 'turn/start':
+    case 'turn/end':
+      return { type: event.type, seq, time, data: { turn: event.data?.turn } }
+    case 'user/message': {
+      const content = Array.isArray(event.data?.content)
+        ? event.data.content.filter((block) => block?.type === 'text').map((block) => ({ type: 'text', text: block.text }))
+        : []
+      return { type: 'user/message', seq, time, data: { content } }
+    }
+    case 'request/header': {
+      const config = event.data?.header?.config
+      return { type: 'request/header', seq, time, data: { header: { config: { provider: config?.provider, model: config?.model } } } }
+    }
+    case 'assistant/message': {
+      const source = event.data?.message?.source
+      const usage = event.data?.usage
+      const record = usageStreamRecord(event.data?.stream)
+      return {
+        type: 'assistant/message',
+        seq,
+        time,
+        data: {
+          turn: event.data?.turn,
+          message: { source: { provider: source?.provider, model: source?.model } },
+          ...usage === undefined || usage === null ? {} : { usage },
+          ...record === undefined ? {} : { stream: [record] },
+        },
+      }
+    }
+    case 'assistant/attempt': {
+      const record = usageStreamRecord(event.data?.stream)
+      return {
+        type: 'assistant/attempt',
+        seq,
+        time,
+        // `turn` is what the fold keys the attempt on; without it the sample is dropped.
+        data: { turn: event.data?.turn, step: event.data?.step, ...record === undefined ? {} : { stream: [record] } },
+      }
+    }
+    case 'tool/call':
+      return { type: 'tool/call', seq, time, data: { turn: event.data?.turn, callId: event.data?.callId, name: event.data?.name } }
+    case 'tool/result': {
+      const message = event.data?.message
+      const error = event.data?.error
+      const meta = event.data?.meta
+      return {
+        type: 'tool/result',
+        seq,
+        time,
+        data: {
+          turn: event.data?.turn,
+          ...message === undefined ? {} : { message: { toolCallId: message?.toolCallId, isError: message?.isError } },
+          ...error === undefined ? {} : { error },
+          ...meta === undefined ? {} : { meta },
+        },
+      }
+    }
+    default:
+      return undefined
+  }
+}
+
+/** Shape check for checkpoint restores; the plugin ships no zod, so it is hand-rolled. */
+const billingSamplesSchema = {
+  parse(value) {
+    if (value === null || typeof value !== 'object' || !Array.isArray(value.samples)) {
+      throw new TypeError('model-billing: unexpected samples projection state')
+    }
+    return value
+  },
+}
+
+const billingSamplesProjection = {
+  key: BILLING_SAMPLES_KEY,
+  stateVersion: BILLING_SAMPLES_VERSION,
+  stateSchema: billingSamplesSchema,
+  init(header, inheritedEventCount) {
+    return { inheritedCut: Number(inheritedEventCount) || 0, samples: [] }
+  },
+  apply(state, event) {
+    // A fork child owns only the events after its inherited prefix; the prefix
+    // was already billed in the session it came from.
+    if (typeof event?.seq === 'number' && event.seq < state.inheritedCut) return state
+    const sample = billingSample(event)
+    if (sample === undefined) return state
+    return { inheritedCut: state.inheritedCut, samples: [...state.samples, sample] }
+  },
+}
+
+const billingProjectionPromises = new WeakMap()
+
+/**
+ * The billing projection handle for one Host context, or null on a Harness that
+ * predates `sessionProjections`. Registration is memoized per context.
+ */
+function billingProjectionHandle(ctx) {
+  const cached = billingProjectionPromises.get(ctx)
+  if (cached !== undefined) return cached
+  let service
+  try {
+    service = ctx?.get?.('sessionProjections')
+  } catch {
+    service = undefined
+  }
+  const promise = service?.register === undefined
+    ? Promise.resolve(null)
+    : Promise.resolve(service.register(billingSamplesProjection)).catch(() => null)
+  billingProjectionPromises.set(ctx, promise)
+  return promise
+}
+
+/** The billing samples of one session, from the projection or the log on old hosts. */
+async function sessionBillingSamples(ctx, session) {
+  const handle = await billingProjectionHandle(ctx)
+  if (handle !== null && handle !== undefined) return handle.stateOf(session).samples
+  if (typeof session.snapshotEvents === 'function') return session.snapshotEvents(session.inheritedEventCount)
+  return session.ownEvents()
+}
+
 const USAGE_CACHE_LIMIT = 50
 const usageCache = new Map()
 
@@ -1199,7 +1356,7 @@ async function serveUsage(ctx, request, response) {
     return sendJson(response, 404, { ok: false, code: 'session-not-found', message: 'this Session is not loaded in the Host' })
   }
   const state = await loadState(ctx)
-  const events = session.ownEvents()
+  const events = await sessionBillingSamples(ctx, session)
   const lastSeq = Array.isArray(events) && events.length > 0 ? events[events.length - 1]?.seq : undefined
   const billing = webToolBilling(ctx)
   const webKey = `${billing.search ?? 'free'}:${billing.fetch ?? 'free'}:${billing.start}`
@@ -1358,6 +1515,8 @@ function messageOf(error) {
 export const __test = {
   applySavedOrder,
   authorityOf,
+  billingSample,
+  billingSamplesProjection,
   builtinRatesFor,
   buildCatalog,
   catalogPricing,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-model-billing",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "description": "Reorder models in the DSH composer picker, store three per-million-token prices, and estimate per-turn and session cost with built-in DeepSeek peak/off-peak rates.",
   "keywords": [