@goodandready/dsh-cost-meter 0.8.0 → 0.8.2

package/lib/index.js

@@ -13,6 +13,7 @@
 //
 // No agent hooks: the widget only reads, so it cannot corrupt a session.
 
+import { createHash } from 'node:crypto'
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { dirname, join } from 'node:path'
@@ -24,6 +25,7 @@ export const inject = ['webServer']
 
 const NS = 'dsh-cost-meter'
 const STATE_PATH = '/dsh-cost-meter/state'
+const REFRESH_PATH = '/dsh-cost-meter/refresh'
 const CATALOG_URL = 'https://openrouter.ai/api/v1/models'
 const CACHE_FILE = join(process.env.DSH_HOME || join(homedir(), '.dsh'), 'storages', 'dsh-cost-meter-catalog.json')
 
@@ -48,10 +50,21 @@ const DEEPSEEK_PEAK_RATES = {
 }
 const DEEPSEEK_PEAK_WINDOWS = [{ start: 60, end: 240 }, { start: 360, end: 600 }]
 
-// ponytail: a DeepSeek model reached THROUGH OpenRouter is still priced from
-// this table, though the bill comes from OpenRouter. Fix by classifying the
-// route (provider id / baseURL) before the model, and for a `:floor` slug take
-// the minimum over /models/{id}/endpoints rather than the base listing.
+/** Common provider / vendor aliases for seamless catalog matching. */
+export const VENDOR_ALIASES = {
+  'z-ai': 'zai',
+  'zai': 'zai',
+  'google': 'google',
+  'gemini': 'google',
+  'deepseek-ai': 'deepseek',
+  'deepseek-official': 'deepseek',
+  'deepseek': 'deepseek',
+  'anthropic-ai': 'anthropic',
+  'anthropic': 'anthropic',
+  'openai': 'openai',
+  'meta-llama': 'meta-llama',
+  'meta': 'meta-llama',
+}
 
 export const Config = z.object({
   currency: z.string().description('Currency symbol shown in the widget.').default('$'),
@@ -60,6 +73,10 @@ export const Config = z.object({
     .string()
     .description('IANA zone the widget shows tariff hours in.')
     .default('Europe/Moscow'),
+  budgetThreshold: z
+    .number()
+    .description('Optional session budget threshold in USD. 0 disables threshold warnings.')
+    .default(0),
   deepseekPeakPrices: z
     .dict(PriceRow)
     .description('Override the built-in DeepSeek peak rates, by model id.')
@@ -146,9 +163,8 @@ function scheduleOf(entry) {
 }
 
 /**
- * Map a harness route onto an OpenRouter id. Exact id first, then the vendor
- * suffix (`deepseek-official/deepseek-v4-flash` -> `deepseek/deepseek-v4-flash`),
- * which is what the shared model names make possible.
+ * Map a harness route onto an OpenRouter id. Exact id first, then normalized
+ * vendor alias + model, then vendor suffix.
  */
 export function matchModel(index, route, modelMap) {
   if (!route || !index) return undefined
@@ -157,6 +173,15 @@ export function matchModel(index, route, modelMap) {
   if (mapped && index.byId && index.byId[mapped]) return mapped
   if (index.byId && index.byId[key]) return key
   if (index.byId && index.byId[route.model]) return route.model
+
+  // Provider alias check (e.g. z-ai -> zai, deepseek-official -> deepseek)
+  const prov = String(route.provider || '').toLowerCase()
+  const aliasProv = VENDOR_ALIASES[prov]
+  if (aliasProv && route.model) {
+    const aliasKey = (aliasProv + '/' + route.model).toLowerCase()
+    if (index.byLowerId && index.byLowerId[aliasKey]) return index.byLowerId[aliasKey]
+  }
+
   // Harness routes name models in their own casing (`MiniMax-M3`), the catalog
   // is lower-case (`minimax/minimax-m3`), so matching is case-insensitive.
   const lower = String(route.model).toLowerCase()
@@ -188,23 +213,10 @@ export function indexCatalog(models) {
 
 // ---------------------------------------------------------------------------
 // Per-model usage projection
-//
-// `tokenUsage` from dsh-token-meter totals the whole session, which prices
-// wrongly the moment the model changes mid-session. The log has what is
-// needed: `request/header` carries `header.config = {provider, model}`, and
-// usage arrives afterwards for that same step. So this unit keeps the last
-// header's route and files every usage sample under it.
-//
-// The replace-if-same-step guard mirrors token-meter: a streamed usage chunk
-// and the finalized assistant message report the same numbers for one step.
 // ---------------------------------------------------------------------------
 
 const ZERO = { uncachedInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 }
 
-// Projection schemas are validated with ZOD, not schemastery: the registry
-// calls `schema.parse(view)` at the boundary, and a schemastery schema has no
-// `.parse`, which fails every history read with
-// "registration.def.schema.parse is not a function".
 const bucketSchema = zod.object({
   uncachedInputTokens: zod.number().nonnegative(),
   outputTokens: zod.number().nonnegative(),
@@ -246,10 +258,7 @@ function usageOf(event) {
 }
 
 /**
- * Half-hour slot of the UTC day an event falls into (0..47). Tariff windows are
- * expressed in UTC clock time, and every real schedule so far lands on a whole
- * or half hour, so 48 slots reproduce the rate exactly while keeping the state
- * small enough to ship on every projection frame.
+ * Half-hour slot of the UTC day an event falls into (0..47).
  */
 export function slotOf(timeMs) {
   let ms = typeof timeMs === 'number' && Number.isFinite(timeMs) ? timeMs : NaN
@@ -270,9 +279,6 @@ const usageByModelProjection = {
     models: zod.array(zod.object({
       provider: zod.string(),
       model: zod.string(),
-      // Usage split by the half-hour of the UTC day it was spent in. Spend is
-      // priced at the rate in force THEN; a later tariff switch must not
-      // reprice tokens that are already paid for.
       slots: zod.record(zod.string(), bucketSchema),
     })),
   }).strict(),
@@ -292,8 +298,6 @@ const usageByModelProjection = {
     const key = route.provider + '/' + route.model
     const slot = String(slotOf(event.time))
     const buckets = bucketsFromUsage(sample.usage)
-    // A streamed usage chunk and the finalized assistant message report the
-    // same step twice; the second one replaces the first instead of adding.
     const previous =
       state.last !== null &&
       state.last.turn === sample.turn &&
@@ -344,12 +348,11 @@ function defaultRoute(ctx) {
 
 /**
  * Resolve one route's tariff: manual config wins, then DeepSeek's own table,
- * then the OpenRouter catalog. Returns `schedule: null` when nothing knows it,
- * so the widget can say so instead of pricing at zero.
+ * then the OpenRouter catalog.
  */
 export function resolveTariff(cfg, index, route) {
   if (!route) return { schedule: null, source: 'none', matchedId: null }
-  const key = route.provider + '/' + route.model
+  const key = route.provider ? route.provider + '/' + route.model : route.model
   const prices = cfg.prices || {}
   const manual = prices[key] || prices[route.model] || prices['*']
 
@@ -380,15 +383,10 @@ export function resolveTariff(cfg, index, route) {
     return { schedule, source: 'manual', matchedId: key }
   }
 
-  // Keyed by MODEL, not provider: a DeepSeek model is billed at DeepSeek's
-  // published rate whoever routes it (deepseek-official, opencode-go, ollama).
-  // Date/variant suffixes (`deepseek-v4-flash:0731`) name the same product.
-  const providerLower = String(route.provider || "").toLowerCase();
-  // #3: Provider-aware routing: if routed explicitly through OpenRouter,
-  // consult OpenRouter catalog first to honor actual provider billing.
-  if (providerLower === "openrouter" && cfg.useOpenRouter !== false) {
-    const matchedId = matchModel(index, route, cfg.modelMap);
-    if (matchedId) return { schedule: index.byId[matchedId], source: "openrouter", matchedId };
+  const providerLower = String(route.provider || '').toLowerCase()
+  if (providerLower === 'openrouter' && cfg.useOpenRouter !== false) {
+    const matchedId = matchModel(index, route, cfg.modelMap)
+    if (matchedId) return { schedule: index.byId[matchedId], source: 'openrouter', matchedId }
   }
 
   const base = String(route.model).toLowerCase().split(':')[0]
@@ -434,6 +432,25 @@ export function splitRoute(key) {
 export function apply(ctx, config) {
   let current = config
   let catalog = { index: { byId: {}, byLowerId: {}, bySuffix: {} }, fetchedAt: 0, error: null }
+  let lastManualRefreshAt = 0
+
+  // Server-side cache for resolved tariffs: key -> { schedule, source, matchedId }
+  const resolveCache = new Map()
+
+  function getCachedTariff(cfg, route) {
+    if (!route) return resolveTariff(cfg, catalog.index, route)
+    const cacheKey = (route.provider || '') + '/' + (route.model || '')
+    if (resolveCache.has(cacheKey)) return resolveCache.get(cacheKey)
+    const res = resolveTariff(cfg, catalog.index, route)
+    // Limit cache size to prevent runaway memory
+    if (resolveCache.size >= 500) resolveCache.clear()
+    resolveCache.set(cacheKey, res)
+    return res
+  }
+
+  function clearResolveCache() {
+    resolveCache.clear()
+  }
 
   // Disk cache survives restarts, so a boot without network still prices.
   try {
@@ -445,11 +462,11 @@ export function apply(ctx, config) {
     // absent or unreadable cache is normal on first run
   }
 
-  async function refresh(signal) {
+  async function refresh(signal, force = false) {
     const cfg = current ?? config
     if (cfg.useOpenRouter === false) return
     const ageMs = Date.now() - catalog.fetchedAt
-    if (catalog.fetchedAt && ageMs < (Number(cfg.refreshHours) || 24) * 3600e3) return
+    if (!force && catalog.fetchedAt && ageMs < (Number(cfg.refreshHours) || 24) * 3600e3) return
     try {
       const timeoutSignal = AbortSignal.timeout(15000)
       const combinedSignal = signal ? (AbortSignal.any ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal) : timeoutSignal
@@ -458,9 +475,9 @@ export function apply(ctx, config) {
       const body = await response.json()
       const models = Array.isArray(body && body.data) ? body.data : []
       if (models.length === 0) throw new Error('empty catalog')
-      // Keep only what pricing needs — the raw payload is mostly prose.
       const slim = models.map((m) => ({ id: m.id, pricing: m.pricing }))
       catalog = { index: indexCatalog(slim), fetchedAt: Date.now(), error: null }
+      clearResolveCache()
       try {
         mkdirSync(dirname(CACHE_FILE), { recursive: true })
         writeFileSync(CACHE_FILE, JSON.stringify({ fetchedAt: catalog.fetchedAt, models: slim }))
@@ -478,16 +495,17 @@ export function apply(ctx, config) {
     current = scope.get() ?? config
     const stop = scope.watch(() => {
       current = scope.get() ?? config
+      clearResolveCache()
       void refresh()
     })
     sctx.effect(() => () => {
       stop()
       current = config
+      clearResolveCache()
     })
   })
 
-  // Optional capability: headless assemblies without the registry keep working,
-  // the widget just falls back to the session-wide tokenUsage projection.
+  // Optional capability: headless assemblies without the registry keep working
   ctx.inject(['sessionProjections'], (pctx) => {
     pctx.sessionProjections.register(usageByModelProjection)
   })
@@ -502,6 +520,46 @@ export function apply(ctx, config) {
     }
   }, 'dsh-cost-meter: catalog refresh')
 
+  // Route 1: POST /dsh-cost-meter/refresh (manual on-demand sync with 30s cooldown)
+  ctx.effect(
+    () =>
+      ctx.webServer.register({
+        kind: 'exact',
+        path: REFRESH_PATH,
+        handler: async (req, res) => {
+          if (req.method !== 'POST') {
+            res.writeHead(405, { 'Content-Type': 'application/json' })
+            res.end(JSON.stringify({ error: 'method not allowed' }))
+            return
+          }
+          const now = Date.now()
+          const COOLDOWN_MS = 30000
+          if (now - lastManualRefreshAt < COOLDOWN_MS) {
+            const retryAfter = Math.ceil((COOLDOWN_MS - (now - lastManualRefreshAt)) / 1000)
+            res.writeHead(429, {
+              'Content-Type': 'application/json',
+              'Retry-After': String(retryAfter),
+            })
+            res.end(JSON.stringify({ error: 'rate limit exceeded', retryAfter }))
+            return
+          }
+          lastManualRefreshAt = now
+          const controller = new AbortController()
+          await refresh(controller.signal, true)
+          const modelsCount = Object.keys((catalog.index && catalog.index.byId) || {}).length
+          res.writeHead(200, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify({
+            ok: !catalog.error,
+            fetchedAt: catalog.fetchedAt,
+            modelsCount,
+            error: catalog.error,
+          }))
+        },
+      }),
+    'dsh-cost-meter: refresh route',
+  )
+
+  // Route 2: GET /dsh-cost-meter/state (with ETag and 304 Not Modified)
   ctx.effect(
     () =>
       ctx.webServer.register({
@@ -515,10 +573,8 @@ export function apply(ctx, config) {
           }
           const cfg = current ?? config
           const route = defaultRoute(ctx) ?? null
-          const own = resolveTariff(cfg, catalog.index, route)
+          const own = getCachedTariff(cfg, route)
 
-          // The client asks for every model the session actually used, so a
-          // session that switched models can price each part on its own tariff.
           const schedules = {}
           const asked = new URL(req.url, 'http://localhost').searchParams.get('models')
           for (const key of (asked ? asked.split(',') : []).slice(0, 24)) {
@@ -526,7 +582,7 @@ export function apply(ctx, config) {
             if (!trimmed || trimmed.length > 128) continue
             const parsed = splitRoute(trimmed)
             if (!parsed) continue
-            const resolved = resolveTariff(cfg, catalog.index, parsed)
+            const resolved = getCachedTariff(cfg, parsed)
             schedules[trimmed] = {
               schedule: resolved.schedule,
               source: resolved.source,
@@ -534,11 +590,11 @@ export function apply(ctx, config) {
             }
           }
 
-          res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' })
-          res.end(JSON.stringify({
+          const payloadObj = {
             currency: cfg.currency,
             usdRate: cfg.usdRate,
             displayTimeZone: cfg.displayTimeZone || 'Europe/Moscow',
+            budgetThreshold: Number(cfg.budgetThreshold) || 0,
             route,
             source: own.source,
             matchedId: own.matchedId,
@@ -547,7 +603,26 @@ export function apply(ctx, config) {
             catalogError: catalog.error,
             catalogModelsCount: Object.keys((catalog.index && catalog.index.byId) || {}).length,
             schedule: own.schedule,
-          }))
+          }
+
+          const serialized = JSON.stringify(payloadObj)
+          const etag = 'W/"' + createHash('sha1').update(serialized).digest('base64url').slice(0, 16) + '"'
+
+          if (req.headers['if-none-match'] === etag) {
+            res.writeHead(304, {
+              'ETag': etag,
+              'Cache-Control': 'no-cache',
+            })
+            res.end()
+            return
+          }
+
+          res.writeHead(200, {
+            'Content-Type': 'application/json',
+            'Cache-Control': 'no-cache',
+            'ETag': etag,
+          })
+          res.end(serialized)
         },
       }),
     'dsh-cost-meter: state route',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cost-meter",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "DeepSeek Harness plugin: a session cost chip in the conversation header - live token usage by bucket, peak/off-peak tariff, and a countdown to the next tariff switch.",
   "type": "module",
   "main": "lib/index.js",