@linxin666/dsh-usage 0.3.7 → 0.3.9

package/src/client/index.ts

@@ -27,8 +27,14 @@ interface UsageHttpApi {
   refresh(): Promise<UsageOverviewView>
 }
 
+/** Hard ceiling for one usage API call; a stalled host must not pile up requests. */
+const USAGE_FETCH_TIMEOUT_MS = 20_000
+
 async function usageFetch<T>(path: string, method: 'GET' | 'POST'): Promise<T> {
-  const response = await fetch(path, method === 'POST' ? { method: 'POST' } : {})
+  const response = await fetch(path, {
+    ...(method === 'POST' ? { method: 'POST' } : {}),
+    signal: AbortSignal.timeout(USAGE_FETCH_TIMEOUT_MS),
+  })
   if (!response.ok) throw new Error('usage ' + path + ' failed: ' + response.status)
   return (await response.json()) as T
 }
@@ -97,11 +103,14 @@ export function apply(ctx: ClientContext): void {
       store.actions.setState('error', 'usage.overview transport error')
     })
   }
+  // The refresh response is authoritative: it reflects the completed probe
+  // cycle, so it applies even when a faster section poll already bumped the
+  // sequence past it (the poll's pre-cycle snapshot is the stale one).
   const refresh = (): void => {
     const seq = pollSeq + 1
     pollSeq = seq
     usageApi.refresh().then((snapshot) => {
-      if (seq !== pollSeq) return
+      pollSeq = seq
       store.actions.setSnapshot(snapshot)
     }, () => {
       if (seq !== pollSeq) return

package/src/client/locales.ts

@@ -19,6 +19,9 @@ export const zh = {
   'usage.error': '加载失败：{error}',
   'usage.current': '当前',
   'usage.today': '今日用量',
+  'usage.today.cost': '今日消费（估算）',
+  'usage.peak.on': 'DeepSeek 高峰时段：计价 ×2，{time} 结束',
+  'usage.peak.off': 'DeepSeek 空闲时段：计价为高峰一半，{time} 进入高峰',
   'usage.calls': '{n} 次调用',
   'usage.tokens.total': '总 tokens',
   'usage.tokens.input': '输入',
@@ -33,6 +36,7 @@ export const zh = {
   'usage.oauth': 'OAuth 凭据，不做余额查询',
   'usage.plan.reset': '{date} 重置',
   'usage.plan.noPlan': '未检测到套餐数据',
+  'usage.plan.noneConfigured': '没有已配置的套餐类 provider（如 Kimi、GLM、OpenCode Go、MiniMax、Codex 订阅）',
   'usage.plan.windows.5h': '5 小时',
   'usage.plan.windows.week': '每周',
   'usage.plan.windows.month': '每月',
@@ -58,6 +62,9 @@ export const en: Record<UsageKey, string> = {
   'usage.error': 'Failed to load: {error}',
   'usage.current': 'Current',
   'usage.today': 'Today',
+  'usage.today.cost': 'Today spend (estimated)',
+  'usage.peak.on': 'DeepSeek peak hours: 2x pricing, ends {time}',
+  'usage.peak.off': 'DeepSeek off-peak: half of peak pricing, peak returns {time}',
   'usage.calls': '{n} calls',
   'usage.tokens.total': 'Total tokens',
   'usage.tokens.input': 'Input',
@@ -72,6 +79,7 @@ export const en: Record<UsageKey, string> = {
   'usage.oauth': 'OAuth credential, no balance query',
   'usage.plan.reset': 'resets {date}',
   'usage.plan.noPlan': 'No plan data detected',
+  'usage.plan.noneConfigured': 'No plan-capable provider configured (such as Kimi, GLM, OpenCode Go, MiniMax, Codex subscription)',
   'usage.plan.windows.5h': '5 hours',
   'usage.plan.windows.week': 'Weekly',
   'usage.plan.windows.month': 'Monthly',

package/src/client/usage.module.css

@@ -168,23 +168,82 @@
   flex: none;
 }
 
-.trend {
+/* 近 30 天提供方/模型条形图：provider 行主导（条宽按窗口内最大 provider
+   归一），模型子行缩进细条（行内归一）。 */
+.chart {
   display: flex;
-  align-items: flex-end;
-  gap: 3px;
-  height: 56px;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.chartProvider {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.chartHead {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 10px;
+  font-size: 13px;
+}
+
+.chartTokens {
+  font-variant-numeric: tabular-nums;
+  opacity: 0.65;
+  font-size: 11px;
+  white-space: nowrap;
 }
 
-.trendBar {
-  flex: 1 1 0;
-  min-width: 4px;
-  border-radius: 3px 3px 0 0;
-  background: color-mix(in srgb, currentColor 30%, transparent);
-  min-height: 2px;
+.chartBar {
+  display: block;
+  height: 8px;
+  border-radius: 999px;
+  background: color-mix(in srgb, currentColor 8%, transparent);
+  overflow: hidden;
 }
 
-.trendBarToday {
-  background: color-mix(in srgb, currentColor 65%, transparent);
+.chartFill {
+  display: block;
+  height: 100%;
+  border-radius: 999px;
+  background: color-mix(in srgb, currentColor 55%, transparent);
+  transition: width 300ms ease;
+}
+
+.chartModel {
+  display: grid;
+  grid-template-columns: minmax(80px, 180px) 1fr auto;
+  align-items: center;
+  gap: 8px;
+  padding-left: 14px;
+  font-size: 11px;
+  opacity: 0.8;
+}
+
+.chartModelName {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  opacity: 0.8;
+}
+
+.chartModelBar {
+  display: block;
+  height: 4px;
+  border-radius: 999px;
+  background: color-mix(in srgb, currentColor 6%, transparent);
+  overflow: hidden;
+}
+
+.chartModelFill {
+  display: block;
+  height: 100%;
+  border-radius: 999px;
+  background: color-mix(in srgb, currentColor 35%, transparent);
+  transition: width 300ms ease;
 }
 
 .trendAxis {

package/src/core/adapters.ts

@@ -18,8 +18,10 @@ export interface ProbeSpec {
 
 /** Inputs an adapter may use to build a probe. */
 export interface AdapterProbeContext {
-  /** Resolved credential value (the raw key; env refs are resolved upstream). */
+  /** Resolved credential value: a raw API key, or an OAuth access token for the oauth-aware adapters. */
   apiKey: string
+  /** Provider account id riding a dedicated header, when the credential carries one (Codex). */
+  accountId?: string
 }
 
 /** A parsed balance fact. */
@@ -79,8 +81,13 @@ function toIso(value: unknown): string | undefined {
   }
   const text = str(value)
   if (text === undefined) return undefined
+  // Epoch instants also arrive as strings ("1756428000"); route them through
+  // the numeric branch instead of letting Date() reject them.
+  if (/^\d+$/.test(text)) return toIso(Number(text))
   const date = new Date(text)
-  return Number.isNaN(date.getTime()) ? text : date.toISOString()
+  // The contract is "normalized ISO 8601, else undefined": returning the raw
+  // text would render as "Invalid Date" downstream.
+  return Number.isNaN(date.getTime()) ? undefined : date.toISOString()
 }
 
 /** Used-percent helper guarding zero/absent limits. */
@@ -95,8 +102,14 @@ function bearer(apiKey: string): Record<string, string> {
   return { authorization: `Bearer ${apiKey}` }
 }
 
+/**
+ * The official pay-as-you-go balance. `deepseek` is the configurable-catalog
+ * route key; `deepseek-official` is the live provider route the llm-deepseek
+ * adapter registers (sessions and agent-default-model carry it), so both ids
+ * must resolve here or the current provider would never be probed.
+ */
 const DEEPSEEK: ProviderAdapter = {
-  ids: ['deepseek'],
+  ids: ['deepseek', 'deepseek-official'],
   displayName: 'DeepSeek',
   balance: {
     build: ({ apiKey }) => ({ url: 'https://api.deepseek.com/user/balance', headers: bearer(apiKey) }),
@@ -328,6 +341,63 @@ const ZENMUX: ProviderAdapter = {
   },
 }
 
+/**
+ * OpenAI Codex (ChatGPT subscription) quota over the OAuth access token the
+ * pi-ai grant stores — the one plan adapter whose credential is an OAuth
+ * token rather than an API key. A 401 here means the stored access token has
+ * expired; it refreshes when the harness next runs a Codex request, so the
+ * error line tells the user to use Codex once and refresh.
+ */
+const OPENAI_CODEX: ProviderAdapter = {
+  ids: ['openai-codex'],
+  displayName: 'Codex (ChatGPT 订阅)',
+  plan: {
+    build: ({ apiKey, accountId }) => ({
+      url: 'https://chatgpt.com/backend-api/wham/usage',
+      headers: {
+        authorization: `Bearer ${apiKey}`,
+        'user-agent': 'codex-cli',
+        accept: 'application/json',
+        ...(accountId !== undefined ? { 'chatgpt-account-id': accountId } : {}),
+      },
+    }),
+    parse: (status, body) => {
+      if (status !== 200 || typeof body !== 'object' || body === null) return undefined
+      const rateLimit = (body as Record<string, unknown>).rate_limit
+      if (typeof rateLimit !== 'object' || rateLimit === null) return undefined
+      const windows: PlanWindowView[] = []
+      const rows = (rateLimit as Record<string, unknown>).primary_window !== undefined || (rateLimit as Record<string, unknown>).secondary_window !== undefined
+        ? [(rateLimit as Record<string, unknown>).primary_window, (rateLimit as Record<string, unknown>).secondary_window]
+        : []
+      for (const entry of rows) {
+        if (typeof entry !== 'object' || entry === null) continue
+        const row = entry as Record<string, unknown>
+        const percent = toNum(row.used_percent)
+        if (percent === undefined) continue
+        const seconds = toNum(row.limit_window_seconds)
+        windows.push({
+          key: codexWindowKey(seconds),
+          percent: Math.max(0, Math.min(100, percent)),
+          // reset_at is unix seconds; toIso scales sub-millisecond-epoch values.
+          resetsAt: toIso(row.reset_at),
+        })
+      }
+      if (windows.length === 0) return undefined
+      return { windows }
+    },
+  },
+}
+
+/** Map a Codex window length in seconds onto the shared window key vocabulary. */
+function codexWindowKey(seconds: number | undefined): string {
+  if (seconds === undefined) return 'window'
+  if (seconds === 18000) return '5h'
+  if (seconds === 604800) return 'week'
+  if (seconds === 2_592_000) return 'month'
+  const hours = seconds / 3600
+  return hours >= 24 ? `${Math.round(hours / 24)}_day` : `${Math.round(hours)}_hour`
+}
+
 /**
  * The adapter registry, in no particular order. Route keys come from the
  * pi-ai provider catalog plus the routes this deployment observed in user
@@ -343,6 +413,7 @@ export const PROVIDER_ADAPTERS: readonly ProviderAdapter[] = [
   OPENCODE_GO,
   minimaxPlan('api.minimaxi.com', ['minimax-cn']),
   minimaxPlan('api.minimax.io', ['minimax']),
+  OPENAI_CODEX,
   OPENROUTER,
   siliconFlow('api.siliconflow.cn', ['siliconflow', 'siliconflow-cn'], 'CNY'),
   siliconFlow('api.siliconflow.com', ['siliconflow-intl'], 'USD'),
@@ -354,6 +425,16 @@ export function adapterFor(provider: string): ProviderAdapter | undefined {
   return PROVIDER_ADAPTERS.find((adapter) => adapter.ids.includes(provider))
 }
 
+/**
+ * Whether a provider route belongs to the official DeepSeek family: the only
+ * family with a spend price book and a settings-section-owned env credential
+ * (llm-deepseek) rather than a pi-ai profile. Drives the env fallback in
+ * credential resolution and the fold-time cost stamping.
+ */
+export function isDeepSeekProviderRoute(provider: string): boolean {
+  return adapterFor(provider) === DEEPSEEK
+}
+
 /**
  * Best-effort human message from a provider error body, for the per-provider
  * error line. Never throws; truncated to one short sentence.

package/src/core/ledger.ts

@@ -5,7 +5,7 @@
  * @module @linxin666/dsh-usage/core/ledger
  */
 
-import { addTotals, emptyTotals, type UsageLedgerDocument, type UsageTokenTotals } from './types.ts'
+import { addTotals, emptyTotals, type UsageLedgerDocument, type UsageProviderSummary, type UsageTokenTotals } from './types.ts'
 
 /** Local-date key (`YYYY-MM-DD`) for an epoch ms timestamp. */
 export function localDateKey(ms: number): string {
@@ -20,9 +20,20 @@ export function createLedgerDocument(): UsageLedgerDocument {
   return { version: 1, days: {} }
 }
 
+/**
+ * Bucket keys come from untrusted directions (persisted JSON, provider and
+ * model ids out of session events), so they must never collide with
+ * `Object.prototype` plumbing: assigning `day['__proto__']` or reading
+ * `day['constructor']` would pollute every object in the host process.
+ */
+function isSafeBucketKey(key: string): boolean {
+  return key !== '__proto__' && key !== 'constructor' && key !== 'prototype'
+}
+
 /**
  * Fold one usage report into the ledger in place. `provider` is the route key
- * and `model` the provider-owned model id the step ran under.
+ * and `model` the provider-owned model id the step ran under. Reports keyed
+ * by prototype-plumbing names are dropped.
  */
 export function foldUsage(
   doc: UsageLedgerDocument,
@@ -31,6 +42,7 @@ export function foldUsage(
   model: string,
   usage: Readonly<UsageTokenTotals>,
 ): void {
+  if (!isSafeBucketKey(provider) || !isSafeBucketKey(model)) return
   if (usage.calls <= 0 && usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheWriteTokens <= 0) return
   const dayKey = localDateKey(atMs)
   const day = doc.days[dayKey] ?? {}
@@ -47,6 +59,50 @@ export function totalTokens(totals: Readonly<UsageTokenTotals>): number {
   return totals.inputTokens + totals.cacheReadTokens + totals.cacheWriteTokens + totals.outputTokens
 }
 
+/** How many model rows one summarized provider keeps. */
+export const SUMMARY_MODEL_CAP = 12
+
+/**
+ * Aggregate whole per-day maps (each `provider -> model -> totals`) into the
+ * per-provider/per-model summary the overview serves for one day or a range:
+ * disjoint bucket sums per provider, per-model rows heaviest first, and the
+ * grand total. Pure: reads its inputs, allocates fresh buckets.
+ */
+export function summarizeDays(days: ReadonlyArray<Record<string, Record<string, UsageTokenTotals>>>): {
+  totals: UsageTokenTotals
+  providers: UsageProviderSummary[]
+} {
+  const merged = new Map<string, Map<string, UsageTokenTotals>>()
+  for (const day of days) {
+    for (const [provider, models] of Object.entries(day)) {
+      if (!isSafeBucketKey(provider) || typeof models !== 'object' || models === null) continue
+      let modelMap = merged.get(provider)
+      if (modelMap === undefined) {
+        modelMap = new Map()
+        merged.set(provider, modelMap)
+      }
+      for (const [model, totals] of Object.entries(models)) {
+        if (typeof totals !== 'object' || totals === null) continue
+        const bucket = modelMap.get(model) ?? emptyTotals()
+        addTotals(bucket, totals)
+        modelMap.set(model, bucket)
+      }
+    }
+  }
+  const providers: UsageProviderSummary[] = []
+  const totals = emptyTotals()
+  for (const [provider, modelMap] of merged) {
+    const providerTotals = emptyTotals()
+    const modelRows = [...modelMap].map(([model, modelTotals]) => ({ model, totals: modelTotals }))
+    for (const row of modelRows) addTotals(providerTotals, row.totals)
+    modelRows.sort((a, b) => totalTokens(b.totals) - totalTokens(a.totals))
+    providers.push({ provider, totals: providerTotals, models: modelRows.slice(0, SUMMARY_MODEL_CAP) })
+  }
+  providers.sort((a, b) => totalTokens(b.totals) - totalTokens(a.totals))
+  for (const row of providers) addTotals(totals, row.totals)
+  return { totals, providers }
+}
+
 /** All local-date keys in the ledger, ascending. */
 export function ledgerDayKeys(doc: Readonly<UsageLedgerDocument>): string[] {
   return Object.keys(doc.days).sort()
@@ -81,6 +137,7 @@ function reviveTotals(value: unknown): UsageTokenTotals | undefined {
     cacheWriteTokens: num('cacheWriteTokens'),
     reasoningTokens: num('reasoningTokens'),
     calls: num('calls'),
+    cost: num('cost'),
   }
 }
 
@@ -96,11 +153,16 @@ export function deserializeLedger(value: unknown): UsageLedgerDocument {
   if (typeof days !== 'object' || days === null) return doc
   for (const [dateKey, providers] of Object.entries(days as Record<string, unknown>)) {
     if (!/^\d{4}-\d{2}-\d{2}$/.test(dateKey) || typeof providers !== 'object' || providers === null) continue
+    // Round-trip the date key: an impossible date (9999-99-99) parses to NaN
+    // and a rollover (2026-02-30) lands on another day; both would otherwise
+    // fold into a bogus, never-pruned bucket.
+    const atMs = new Date(dateKey + 'T12:00:00').getTime()
+    if (!Number.isFinite(atMs) || localDateKey(atMs) !== dateKey) continue
     for (const [provider, models] of Object.entries(providers as Record<string, unknown>)) {
       if (typeof models !== 'object' || models === null) continue
       for (const [model, totals] of Object.entries(models as Record<string, unknown>)) {
         const revived = reviveTotals(totals)
-        if (revived !== undefined) foldUsage(doc, new Date(dateKey + 'T12:00:00').getTime(), provider, model, revived)
+        if (revived !== undefined) foldUsage(doc, atMs, provider, model, revived)
       }
     }
   }

package/src/core/pricing.ts

@@ -0,0 +1,109 @@
+/**
+ * DeepSeek official peak/off-peak pricing: the published V4 price book plus
+ * the peak-window clock, folded into a per-call spend estimate the ledger
+ * stamps at fold time (the provider bills each request in the period the
+ * request ran in, so pricing at the fold is the honest estimate).
+ *
+ * Policy (api-docs.deepseek.com pricing page, effective 2026-08-17): peak
+ * hours are Beijing time Monday-Friday 09:00-12:00 and 14:00-18:00; every
+ * other hour (nights, weekends) is off-peak and billed at half the peak
+ * price. All prices here are CNY per million tokens.
+ * @module @linxin666/dsh-usage/core/pricing
+ */
+
+import type { UsageTokenTotals } from './types.ts'
+
+/** One peak window in minutes-of-day, Beijing time. */
+interface PeakWindow {
+  /** Inclusive start, minutes since midnight. */
+  from: number
+  /** Exclusive end, minutes since midnight. */
+  to: number
+}
+
+/** The published peak windows: weekday 09:00-12:00 and 14:00-18:00. */
+const PEAK_WINDOWS: readonly PeakWindow[] = [
+  { from: 9 * 60, to: 12 * 60 },
+  { from: 14 * 60, to: 18 * 60 },
+]
+
+/** Beijing is UTC+8 year-round (no DST), so a fixed shift is exact. */
+const BEIJING_UTC_OFFSET_MS = 8 * 3_600_000
+
+/** One price row in CNY per million tokens, split by billing period. */
+interface ModelPrice {
+  /** Input served from the provider prompt cache. */
+  cacheHit: { offPeak: number; peak: number }
+  /** Uncached input (DeepSeek reports no separate cache-write class). */
+  inputMiss: { offPeak: number; peak: number }
+  /** Output; reasoning tokens bill as output. */
+  output: { offPeak: number; peak: number }
+}
+
+/** deepseek-v4-flash (and the flash-class vision experiment). */
+const FLASH_PRICE: ModelPrice = {
+  cacheHit: { offPeak: 0.05, peak: 0.1 },
+  inputMiss: { offPeak: 1.5, peak: 3.0 },
+  output: { offPeak: 4.5, peak: 9.0 },
+}
+
+/** deepseek-v4-pro. */
+const PRO_PRICE: ModelPrice = {
+  cacheHit: { offPeak: 0.15, peak: 0.3 },
+  inputMiss: { offPeak: 4.5, peak: 9.0 },
+  output: { offPeak: 13.5, peak: 27.0 },
+}
+
+function withinWindow(minuteOfDay: number): PeakWindow | undefined {
+  return PEAK_WINDOWS.find((window) => minuteOfDay >= window.from && minuteOfDay < window.to)
+}
+
+/**
+ * The DeepSeek billing period at `ms`, plus when it next flips. The clock is
+ * Beijing time regardless of the host timezone (UTC+8 has no DST, so a fixed
+ * shift is exact). `boundaryMs` is the instant the current period ends — the
+ * window's close while peaking, the next window's open otherwise.
+ */
+export function deepseekPeriodAt(ms: number): { peak: boolean; boundaryMs: number } {
+  const shifted = new Date(ms + BEIJING_UTC_OFFSET_MS)
+  const weekday = shifted.getUTCDay()
+  const minuteOfDay = shifted.getUTCHours() * 60 + shifted.getUTCMinutes()
+  const current = weekday >= 1 && weekday <= 5 ? withinWindow(minuteOfDay) : undefined
+  if (current !== undefined) {
+    return { peak: true, boundaryMs: ms + (current.to - minuteOfDay) * 60_000 - shifted.getUTCSeconds() * 1000 - shifted.getUTCMilliseconds() }
+  }
+  // Next window start: later today (weekday only), else the following days'
+  // first morning window; the scan bound makes a malformed clock terminate.
+  for (let dayOffset = 0; dayOffset < 8; dayOffset += 1) {
+    const day = new Date(ms + BEIJING_UTC_OFFSET_MS + dayOffset * 86_400_000)
+    if (day.getUTCDay() < 1 || day.getUTCDay() > 5) continue
+    const realDayStart = Date.UTC(day.getUTCFullYear(), day.getUTCMonth(), day.getUTCDate()) - BEIJING_UTC_OFFSET_MS
+    for (const window of PEAK_WINDOWS) {
+      if (dayOffset === 0 && window.from <= minuteOfDay) continue
+      return { peak: false, boundaryMs: realDayStart + window.from * 60_000 }
+    }
+  }
+  // Unreachable (the scan covers a full week); a conservative off-peak answer.
+  return { peak: false, boundaryMs: ms + 86_400_000 }
+}
+
+/** The price row for a model id; unknown ids take the flash-class row (documented estimate). */
+function priceFor(model: string): ModelPrice {
+  return model.includes('v4-pro') ? PRO_PRICE : FLASH_PRICE
+}
+
+/**
+ * Estimate one call's DeepSeek spend in CNY from its token totals, priced in
+ * the billing period at `atMs`. Uncatalogued model ids take the flash-class
+ * row; ids from other providers never reach this function (the service gates
+ * by route family). Rounded to micro-CNY so the ledger stays readable.
+ */
+export function deepseekModelSpend(model: string, totals: Readonly<UsageTokenTotals>, atMs: number): number {
+  const price = priceFor(model)
+  const period = deepseekPeriodAt(atMs)
+  const column = period.peak ? 'peak' : 'offPeak'
+  const spend = (totals.cacheReadTokens * price.cacheHit[column]
+    + (totals.inputTokens + totals.cacheWriteTokens) * price.inputMiss[column]
+    + totals.outputTokens * price.output[column]) / 1_000_000
+  return Math.round(spend * 1e6) / 1e6
+}

package/src/core/types.ts

@@ -20,11 +20,18 @@ export interface UsageTokenTotals {
   reasoningTokens: number
   /** Provider calls that reported usage. */
   calls: number
+  /**
+   * Spend estimate stamped at fold time, in the priced provider's billing
+   * currency (currently DeepSeek official only, CNY); every other provider
+   * stays 0 = unpriced, so the sum is never a mixed-currency total. Persisted
+   * buckets recorded before a price-book change keep the old pricing.
+   */
+  cost: number
 }
 
 /** A zeroed totals bucket. */
 export function emptyTotals(): UsageTokenTotals {
-  return { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, reasoningTokens: 0, calls: 0 }
+  return { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, reasoningTokens: 0, calls: 0, cost: 0 }
 }
 
 /** Add `right` into `left` in place. */
@@ -35,6 +42,7 @@ export function addTotals(left: UsageTokenTotals, right: Readonly<UsageTokenTota
   left.cacheWriteTokens += right.cacheWriteTokens
   left.reasoningTokens += right.reasoningTokens
   left.calls += right.calls
+  left.cost += right.cost
   return left
 }
 
@@ -99,8 +107,12 @@ export interface ProviderSnapshotView {
   /** Display name from the LLM runtime, else the adapter's, else the route key. */
   displayName: string
   credential: CredentialKind
-  /** Whether a balance/plan adapter exists for this route. */
+  /** Whether any balance/plan adapter exists for this route. */
   supported: boolean
+  /** A balance adapter exists for this route (the Usage tab's balance card). */
+  balanceSupported?: boolean
+  /** A coding-plan adapter exists for this route — the Plans tab lists these only. */
+  planSupported?: boolean
   balance?: BalanceView
   plan?: PlanView
   /** Last probe failure, cleared on the next success. */
@@ -123,5 +135,28 @@ export interface UsageOverviewView {
     today: { date: string; totals: UsageTokenTotals; providers: UsageProviderSummary[] }
     /** Last N local days ascending, including today. */
     days: UsageDaySummary[]
+    /**
+     * The same window aggregated per provider and model — the trend card's
+     * bar-chart data. Optional so an older host document still renders.
+     */
+    range?: {
+      from: string
+      to: string
+      totals: UsageTokenTotals
+      providers: UsageProviderSummary[]
+    }
   }
 }
+
+/**
+ * Host-side snapshot state: the wire view plus one error slot per probed
+ * fact. A probe half only clears its own slot, so a plan success can no
+ * longer mask a failing balance probe (and vice versa); the overview
+ * collapses them into the single wire `error` line, balance first.
+ */
+export interface ProviderSnapshotState extends ProviderSnapshotView {
+  /** Last balance-probe failure; cleared on the next balance success. */
+  balanceError?: string
+  /** Last plan-probe failure; cleared on the next plan success. */
+  planError?: string
+}