dsh-token-use 0.1.1 → 0.2.0

package/cordis.patch.yml

@@ -5,3 +5,10 @@
       config:
         endpoint: /dsh-token-use
         scanAtBoot: true
+        # Official price book: one fetch per day at 12:00 local time, cached
+        # under $DSH_HOME/dsh-token-use/pricing.json. `enabled: false` keeps the
+        # plugin offline; `currency: USD` reads the English pricing page.
+        pricing:
+          enabled: true
+          currency: CNY
+          refreshHour: 12

package/lib/index.js

@@ -6,7 +6,9 @@
  * watches, no periodic writes. History is rebuilt once at boot by streaming
  * the zstd session logs with cooperative yields; from then on the fold only
  * moves forward through the live event bus. A per-session seq watermark makes
- * the boot scan and the live fold overlap-safe in either order.
+ * the boot scan and the live fold overlap-safe in either order. Every record
+ * is also priced at the DeepSeek rate of the moment it happened (see
+ * `pricing.js`), so each bucket carries an estimated amount alongside tokens.
  *
  * Queries: `GET /dsh-token-use` returns all-time buckets;
  * `?day=YYYY-MM-DD` and `?month=YYYY-MM` return the matching window,
@@ -20,6 +22,7 @@ import { readdir, readFile, stat } from 'node:fs/promises'
 import { join } from 'node:path'
 import { zstdDecompressSync } from 'node:zlib'
 import { scheduler } from 'node:timers/promises'
+import { PricingStore } from './pricing.js'
 
 export const name = 'dsh-token-use'
 
@@ -36,6 +39,25 @@ const USAGE_FIELDS = [
 
 const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1'])
 
+/**
+ * Days of per-day buckets the snapshot carries for the trend chart. The client
+ * slices this down to its 7/30/90-day range switcher, so the widest range is
+ * served without another round trip.
+ */
+const TREND_DAYS = 90
+
+/**
+ * Auxiliary LLM calls that DeepSeek bills but that persist no `usage` record:
+ * session-title generation and the web-search tool's own model call. They are
+ * counted — so the dashboard can say how many calls the amount leaves out —
+ * but never priced, because their token counts exist only in the platform's
+ * ledger, not in the session log.
+ */
+const AUXILIARY_EVENTS = {
+  'session/title-llm-request': 'title',
+  'web/deepseek-search-llm-request': 'search',
+}
+
 /**
  * Session artifact names: `session.jsonl[.zstd]` for the original generation
  * and `session.v<N>.jsonl[.zstd]` for a versioned re-encoding of the same log.
@@ -103,11 +125,12 @@ function sessionParent(session) {
 }
 
 function emptyBucket() {
-  return { calls: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 }
+  return { calls: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, cost: 0 }
 }
 
-function addUsage(bucket, usage) {
+function addUsage(bucket, usage, cost = 0) {
   bucket.calls += 1
+  bucket.cost += cost
   for (const [field, key] of USAGE_FIELDS) {
     const value = usage[field]
     if (typeof value === 'number' && Number.isFinite(value)) bucket[key] += value
@@ -116,7 +139,7 @@ function addUsage(bucket, usage) {
 
 function mergeInto(target, source) {
   target.calls += source.calls
-  for (const key of ['input', 'output', 'cacheRead', 'cacheWrite', 'reasoning']) target[key] += source[key]
+  for (const key of ['input', 'output', 'cacheRead', 'cacheWrite', 'reasoning', 'cost']) target[key] += source[key]
 }
 
 /**
@@ -228,6 +251,7 @@ export class UsageTracker {
   constructor(dshHome = resolveDshHome(), options = {}) {
     this.dshHome = dshHome
     this.allowRemote = options.allowRemote === true
+    this.pricing = options.pricing ?? new PricingStore(dshHome, options.pricingOptions ?? {})
     this.startedAt = Date.now()
     this.totals = emptyBucket()
     this.byModel = new Map()
@@ -236,6 +260,7 @@ export class UsageTracker {
     this.dayModel = new Map()
     this.dayProject = new Map()
     this.dayModelProject = new Map()
+    this.dayAuxiliary = new Map()
     this.lastModel = new Map()
     this.seen = new Map()
     this.scanning = false
@@ -273,10 +298,35 @@ export class UsageTracker {
     return this.nestedBucket(second, secondKey, thirdKey)
   }
 
+  /** Counters for auxiliary calls (title/search) on one day. */
+  auxiliaryBucket(day) {
+    let counts = this.dayAuxiliary.get(day)
+    if (counts === undefined) {
+      counts = { title: 0, search: 0, total: 0 }
+      this.dayAuxiliary.set(day, counts)
+    }
+    return counts
+  }
+
+  /** Auxiliary-call counters summed over the given days. */
+  auxiliaryOver(days) {
+    const counts = { title: 0, search: 0, total: 0 }
+    for (const day of days) {
+      const found = this.dayAuxiliary.get(day)
+      if (found === undefined) continue
+      counts.title += found.title
+      counts.search += found.search
+      counts.total += found.total
+    }
+    return counts
+  }
+
   /**
    * Fold one decoded session event. `request/header` only updates the
-   * per-session model attribution; `assistant/message` with a usage record is
-   * counted once. @returns true when the event was counted.
+   * per-session model attribution; an auxiliary request is counted (its usage
+   * is never persisted, so it cannot be priced); `assistant/message` with a
+   * usage record is counted once, priced with the rate in effect right then.
+   * @returns true when the event was counted.
    */
   fold(session, event) {
     if (event === null || typeof event !== 'object' || session === null || typeof session !== 'object') return false
@@ -289,31 +339,42 @@ export class UsageTracker {
       if (typeof model === 'string' && model.length > 0) this.lastModel.set(session.id, model)
       return false
     }
-    if (event.type !== 'assistant/message') return false
-    const usage = event.data?.usage
-    if (usage === null || typeof usage !== 'object') return false
+    const auxiliary = AUXILIARY_EVENTS[event.type]
+    if (auxiliary === undefined && event.type !== 'assistant/message') return false
+    const usage = auxiliary === undefined ? event.data?.usage : undefined
+    if (auxiliary === undefined && (usage === null || typeof usage !== 'object')) return false
     const seq = event.seq
     const seen = this.seen.get(session.id)
     if (typeof seen === 'number' && typeof seq === 'number' && seq <= seen) return false
     if (typeof seq === 'number') this.seen.set(session.id, Math.max(seen ?? 0, seq))
-    addUsage(this.totals, usage)
+    const time = typeof event.time === 'number' ? event.time : undefined
+    if (auxiliary !== undefined) {
+      if (time !== undefined) {
+        const counts = this.auxiliaryBucket(localDay(time))
+        counts[auxiliary] += 1
+        counts.total += 1
+      }
+      return false
+    }
     const model = this.lastModel.get(session.id) ?? 'unknown'
-    addUsage(this.bucket(this.byModel, model), usage)
+    const cost = this.pricing.costOf(usage, model, time)
+    addUsage(this.totals, usage, cost)
+    addUsage(this.bucket(this.byModel, model), usage, cost)
     const project = this.projectFor(session)
     if (project === undefined) {
       // The session's project is not known yet: hold the project-side usage
       // until it resolves (a later event or the parent's resolution).
-      this.holdOrphan(session.id, usage, typeof event.time === 'number' ? localDay(event.time) : undefined, model)
+      this.holdOrphan(session.id, usage, cost, time === undefined ? undefined : localDay(time), model)
     } else {
-      addUsage(this.bucket(this.byProject, project), usage)
+      addUsage(this.bucket(this.byProject, project), usage, cost)
     }
-    if (typeof event.time === 'number') {
-      const day = localDay(event.time)
-      addUsage(this.bucket(this.byDay, day), usage)
-      addUsage(this.nestedBucket(this.dayModel, day, model), usage)
+    if (time !== undefined) {
+      const day = localDay(time)
+      addUsage(this.bucket(this.byDay, day), usage, cost)
+      addUsage(this.nestedBucket(this.dayModel, day, model), usage, cost)
       if (project !== undefined) {
-        addUsage(this.nestedBucket(this.dayProject, day, project), usage)
-        addUsage(this.nestedBucket3(this.dayModelProject, day, model, project), usage)
+        addUsage(this.nestedBucket(this.dayProject, day, project), usage, cost)
+        addUsage(this.nestedBucket3(this.dayModelProject, day, model, project), usage, cost)
       }
     }
     return true
@@ -347,7 +408,9 @@ export class UsageTracker {
     this.scanning = true
     try {
       const result = await new Promise((resolve, reject) => {
-        const worker = new WorkerCtor(new URL('./scan-worker.js', import.meta.url), { workerData: { dshHome: this.dshHome } })
+        const worker = new WorkerCtor(new URL('./scan-worker.js', import.meta.url), {
+          workerData: { dshHome: this.dshHome, pricing: { snapshots: this.pricing.snapshots ?? [], currency: this.pricing.currency } },
+        })
         worker.once('message', (message) => {
           worker.terminate().catch(() => {})
           resolve(message)
@@ -442,22 +505,22 @@ export class UsageTracker {
   }
 
   /** Attribute usage that arrived before its session's project was known. */
-  holdOrphan(sessionId, usage, day, model) {
+  holdOrphan(sessionId, usage, cost, day, model) {
     let held = this.orphans.get(sessionId)
     if (held === undefined) {
       held = { totals: emptyBucket(), days: new Map(), dayModels: new Map(), since: Date.now() }
       this.orphans.set(sessionId, held)
     }
-    addUsage(held.totals, usage)
+    addUsage(held.totals, usage, cost)
     if (day !== undefined) {
-      addUsage(this.bucket(held.days, day), usage)
+      addUsage(this.bucket(held.days, day), usage, cost)
       if (model !== undefined) {
         let byModel = held.dayModels.get(day)
         if (byModel === undefined) {
           byModel = new Map()
           held.dayModels.set(day, byModel)
         }
-        addUsage(this.bucket(byModel, model), usage)
+        addUsage(this.bucket(byModel, model), usage, cost)
       }
     }
   }
@@ -516,6 +579,7 @@ export class UsageTracker {
       dayModel: pairs(this.dayModel).map(([day, inner]) => [day, pairs(inner)]),
       dayProject: pairs(this.dayProject).map(([day, inner]) => [day, pairs(inner)]),
       dayModelProject: pairs(this.dayModelProject).map(([day, inner]) => [day, pairs(inner).map(([model, byProject]) => [model, pairs(byProject)])]),
+      dayAuxiliary: pairs(this.dayAuxiliary).map(([day, counts]) => [day, { ...counts }]),
       lastModel: pairs(this.lastModel),
       projectOf: pairs(this.projectOf),
       parentOf: pairs(this.parentOf),
@@ -541,6 +605,12 @@ export class UsageTracker {
     for (const [key, project] of part.projectOf) this.rememberProject(key, project)
     for (const [key, parent] of part.parentOf) this.parentOf.set(key, parent)
     for (const [key, seq] of part.seen) this.seen.set(key, Math.max(this.seen.get(key) ?? 0, seq))
+    for (const [day, counts] of part.dayAuxiliary ?? []) {
+      const bucket = this.auxiliaryBucket(day)
+      bucket.title += counts.title
+      bucket.search += counts.search
+      bucket.total += counts.total
+    }
     this.scan = { ...this.scan, ...part.scan }
   }
 
@@ -557,7 +627,7 @@ export class UsageTracker {
     if (filter === null) {
       const sortedDays = [...this.byDay.keys()].sort()
       const trendEnd = sortedDays.length > 0 ? sortedDays[sortedDays.length - 1] : localDay(Date.now())
-      const trendStart = shiftDay(trendEnd, -29)
+      const trendStart = shiftDay(trendEnd, -(TREND_DAYS - 1))
       const trendDays = []
       for (let day = trendStart; day <= trendEnd; day = shiftDay(day, 1)) {
         const bucket = this.byDay.get(day)
@@ -569,10 +639,11 @@ export class UsageTracker {
         byProject: this.sorted(this.byProject),
         byDay: Object.fromEntries([...this.byDay.entries()].sort()),
         trend: { from: trendStart, to: trendEnd, days: Object.fromEntries(trendDays) },
+        auxiliary: this.auxiliaryOver([...this.dayAuxiliary.keys()].sort()),
       }
     }
     const model = filter.model
-    const allDays = [...this.byDay.keys()].sort()
+    const allDays = [...new Set([...this.byDay.keys(), ...this.dayAuxiliary.keys()])].sort()
     const days = filter.kind === 'all'
       ? allDays
       : allDays.filter((day) => (filter.kind === 'day' ? day === filter.value : day.startsWith(filter.value)))
@@ -598,7 +669,7 @@ export class UsageTracker {
     const trendEnd = filter.kind === 'day'
       ? filter.value
       : (lastDataDay ?? localDay(Date.now()))
-    const trendStart = shiftDay(trendEnd, -29)
+    const trendStart = shiftDay(trendEnd, -(TREND_DAYS - 1))
     for (let day = trendStart; day <= trendEnd; day = shiftDay(day, 1)) {
       const bucket = model === undefined ? this.byDay.get(day) : this.dayModel.get(day)?.get(model)
       trendDays.push([day, bucket === undefined ? emptyBucket() : { ...bucket }])
@@ -609,6 +680,7 @@ export class UsageTracker {
       byProject: this.sorted(projects),
       byDay,
       trend: { from: trendStart, to: trendEnd, days: Object.fromEntries(trendDays) },
+      auxiliary: this.auxiliaryOver(days),
     }
   }
 
@@ -616,15 +688,27 @@ export class UsageTracker {
     this.flushStaleOrphans()
     const view = this.view(filter)
     const withTotal = (bucket) => ({ ...bucket, total: bucket.input + bucket.output + bucket.cacheRead + bucket.cacheWrite })
+    const now = Date.now()
+    const names = new Set([...Object.keys(view.byModel), ...this.byModel.keys()])
+    const modelPricing = {}
+    for (const model of names) {
+      const resolved = this.pricing.priceFor(model, now)
+      modelPricing[model] = resolved.status === 'priced'
+        ? { status: resolved.status, id: resolved.id, label: resolved.label, hit: resolved.hit, miss: resolved.miss, out: resolved.out }
+        : { status: resolved.status, reason: resolved.reason }
+    }
     return {
       ok: true,
       name,
       version: VERSION,
       startedAt: this.startedAt,
-      updatedAt: Date.now(),
+      updatedAt: now,
       dshHome: this.dshHome,
       filter: filter === null ? null : { kind: filter.kind, value: filter.value ?? null, model: filter.model ?? null },
       models: this.models(),
+      modelPricing,
+      pricing: this.pricing.describe(now),
+      auxiliary: view.auxiliary,
       scan: { ...this.scan },
       totals: withTotal(view.totals),
       byModel: Object.fromEntries(Object.entries(view.byModel).map(([k, v]) => [k, withTotal(v)])),
@@ -700,13 +784,20 @@ export class UsageTracker {
 /**
  * Register the tracker once the profile's webServer service exists.
  * @param ctx - host context from the cordis loader.
- * @param config - loader config: `endpoint` and `scanAtBoot`.
+ * @param config - loader config: `endpoint`, `scanAtBoot`, `allowRemote` and
+ * `pricing` (`enabled`, `currency`, `refreshHour`, `url`, `timeoutMs`).
  */
 export function apply(ctx, config = {}) {
   const endpoint = typeof config.endpoint === 'string' && config.endpoint.length > 0 ? config.endpoint : '/dsh-token-use'
   const scanAtBoot = config.scanAtBoot !== false
   ctx.inject(['webServer'], (host) => {
-    const tracker = new UsageTracker(resolveDshHome(), { allowRemote: config.allowRemote === true })
+    const dshHome = resolveDshHome()
+    const pricing = new PricingStore(dshHome, config.pricing ?? {})
+    const tracker = new UsageTracker(dshHome, { allowRemote: config.allowRemote === true, pricing })
+    host.effect(() => {
+      pricing.start()
+      return () => pricing.stop()
+    }, 'dsh-token-use: daily price refresh')
     host.on('session/event', (session, event) => {
       tracker.fold(session, event)
     }, { global: true })