@goodandready/dsh-model-sync 0.5.16 → 0.5.18

package/lib/pricing-database.js

@@ -1,6 +1,13 @@
-function cleanTokenPrice(val) {
-  if (typeof val !== 'number' || !Number.isFinite(val)) return 0
-  return Math.round((val / 1000000) * 1e12) / 1e12
+import fs from 'node:fs'
+import path from 'node:path'
+
+function cleanTokenPrice(val, { isPerToken = false } = {}) {
+  const num = typeof val === 'string' ? Number(val.trim()) : val
+  if (typeof num !== 'number' || !Number.isFinite(num) || num < 0) return 0
+  if (isPerToken) {
+    return Math.round(num * 1e12) / 1e12
+  }
+  return Math.round((num / 1000000) * 1e12) / 1e12
 }
 
 function perMillion(inputUSD, outputUSD, extra = {}) {
@@ -21,23 +28,23 @@ function perMillion(inputUSD, outputUSD, extra = {}) {
 
 export const REFERENCE_PRICING = Object.freeze({
   openai: {
-    'gpt-4o': perMillion(2.5, 10),
-    'gpt-4o-mini': perMillion(0.15, 0.6),
+    'gpt-4o': perMillion(2.5, 10, { cacheReadUSD: 1.25 }),
+    'gpt-4o-mini': perMillion(0.15, 0.6, { cacheReadUSD: 0.075 }),
     'gpt-4-turbo': perMillion(10, 30),
     'gpt-4': perMillion(30, 60),
     'gpt-3.5-turbo': perMillion(0.5, 1.5),
-    'o1': perMillion(15, 60),
+    'o1': perMillion(15, 60, { cacheReadUSD: 7.5 }),
     'o1-preview': perMillion(15, 60),
-    'o1-mini': perMillion(1.1, 4.4),
-    'o3-mini': perMillion(1.1, 4.4),
+    'o1-mini': perMillion(1.1, 4.4, { cacheReadUSD: 0.55 }),
+    'o3-mini': perMillion(1.1, 4.4, { cacheReadUSD: 0.55 }),
     'chatgpt-4o-latest': perMillion(5, 15),
   },
   anthropic: {
-    'claude-3-7-sonnet': perMillion(3, 15),
-    'claude-3-5-sonnet': perMillion(3, 15),
-    'claude-3-5-haiku': perMillion(0.8, 4),
-    'claude-3-opus': perMillion(15, 75),
-    'claude-3-haiku': perMillion(0.25, 1.25),
+    'claude-3-7-sonnet': perMillion(3, 15, { cacheReadUSD: 0.3, cacheWriteUSD: 3.75 }),
+    'claude-3-5-sonnet': perMillion(3, 15, { cacheReadUSD: 0.3, cacheWriteUSD: 3.75 }),
+    'claude-3-5-haiku': perMillion(0.8, 4, { cacheReadUSD: 0.08, cacheWriteUSD: 1 }),
+    'claude-3-opus': perMillion(15, 75, { cacheReadUSD: 1.5, cacheWriteUSD: 18.75 }),
+    'claude-3-haiku': perMillion(0.25, 1.25, { cacheReadUSD: 0.025, cacheWriteUSD: 0.3 }),
   },
   groq: {
     'llama-3.3-70b-versatile': perMillion(0.59, 0.79),
@@ -83,6 +90,22 @@ export const REFERENCE_PRICING = Object.freeze({
   },
 })
 
+// Dynamic in-memory pricing store populated from OpenRouter / LiteLLM / disk cache
+const DYNAMIC_PRICING = new Map()
+
+export function getDynamicPricingMap() {
+  return DYNAMIC_PRICING
+}
+
+export function clearDynamicPricing() {
+  DYNAMIC_PRICING.clear()
+}
+
+export function setDynamicPricing(key, pricing) {
+  if (!key || typeof key !== 'string' || !pricing) return
+  DYNAMIC_PRICING.set(key.toLowerCase().trim(), Object.freeze({ ...pricing }))
+}
+
 function cleanId(id) {
   if (typeof id !== 'string') return ''
   return id
@@ -100,16 +123,23 @@ export function lookupReferencePricing(provider, modelId) {
   const rawId = modelId.toLowerCase().trim()
   const cleaned = cleanId(rawId)
 
-  // 1. Direct check in provider table (exact match or date-cleaned match)
+  // 1. Dynamic pricing cache check (provider:modelId or rawId or cleaned)
+  if (DYNAMIC_PRICING.size > 0) {
+    const dynScoped = provKey ? DYNAMIC_PRICING.get(`${provKey}:${rawId}`) || DYNAMIC_PRICING.get(`${provKey}:${cleaned}`) : undefined
+    if (dynScoped) return { ...dynScoped }
+    const dynRaw = DYNAMIC_PRICING.get(rawId) || DYNAMIC_PRICING.get(cleaned)
+    if (dynRaw) return { ...dynRaw }
+  }
+
+  // 2. Direct check in provider table (exact match or date-cleaned match)
   const table = REFERENCE_PRICING[provKey]
   if (table) {
     if (table[rawId]) return { ...table[rawId] }
     if (table[cleaned]) return { ...table[cleaned] }
-    // If the provider has a dedicated pricing table, do not search other providers' tables
     return undefined
   }
 
-  // 2. Vendor prefix check (e.g. "openai/gpt-4o" or "anthropic/claude-3-5-sonnet")
+  // 3. Vendor prefix check (e.g. "openai/gpt-4o" or "anthropic/claude-3-5-sonnet")
   const slashIdx = rawId.indexOf('/')
   if (slashIdx > 0) {
     const subProv = rawId.slice(0, slashIdx)
@@ -122,10 +152,113 @@ export function lookupReferencePricing(provider, modelId) {
     }
   }
 
-  // 3. Fallback search across tables ONLY for unknown/aggregator providers without a dedicated table
+  // 4. Fallback search across tables ONLY for unknown/aggregator providers without a dedicated table
   for (const [p, t] of Object.entries(REFERENCE_PRICING)) {
     if (t[cleaned]) return { ...t[cleaned] }
   }
 
   return undefined
 }
+
+export function parseOpenRouterPricing(modelsData) {
+  if (!Array.isArray(modelsData)) return []
+  const results = []
+  for (const item of modelsData) {
+    if (!item?.id || !item?.pricing) continue
+    const id = String(item.id).trim().toLowerCase()
+    const p = item.pricing
+    const inputPerToken = cleanTokenPrice(p.prompt, { isPerToken: true })
+    const outputPerToken = cleanTokenPrice(p.completion, { isPerToken: true })
+    const cacheReadPerToken = p.input_cache_read !== undefined || p.prompt_cached !== undefined
+      ? cleanTokenPrice(p.input_cache_read ?? p.prompt_cached, { isPerToken: true })
+      : undefined
+    const cacheWritePerToken = p.input_cache_write !== undefined
+      ? cleanTokenPrice(p.input_cache_write, { isPerToken: true })
+      : undefined
+
+    if (inputPerToken > 0 || outputPerToken > 0) {
+      const entry = {
+        inputPerToken,
+        outputPerToken,
+        ...(cacheReadPerToken !== undefined ? { cacheReadPerToken } : {}),
+        ...(cacheWritePerToken !== undefined ? { cacheWritePerToken } : {}),
+        currency: 'USD',
+        source: 'openrouter',
+      }
+      results.push({ id, entry })
+    }
+  }
+  return results
+}
+
+export async function fetchPricingUpdates({
+  timeoutMs = 15000,
+  fetchFn = globalThis.fetch,
+  cachePath,
+  logger,
+} = {}) {
+  let updatedCount = 0
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+
+  try {
+    const res = await fetchFn('https://openrouter.ai/api/v1/models', {
+      signal: controller.signal,
+      headers: { 'Accept': 'application/json' },
+    })
+    if (res.ok) {
+      const json = await res.json()
+      const entries = parseOpenRouterPricing(json?.data)
+      for (const { id, entry } of entries) {
+        DYNAMIC_PRICING.set(id, Object.freeze(entry))
+        const clean = cleanId(id)
+        if (clean && clean !== id) {
+          DYNAMIC_PRICING.set(clean, Object.freeze(entry))
+        }
+        // Also index under vendor-prefixed subId
+        const slashIdx = id.indexOf('/')
+        if (slashIdx > 0) {
+          const subId = id.slice(slashIdx + 1)
+          DYNAMIC_PRICING.set(subId, Object.freeze(entry))
+          const subClean = cleanId(subId)
+          if (subClean && subClean !== subId) {
+            DYNAMIC_PRICING.set(subClean, Object.freeze(entry))
+          }
+        }
+        updatedCount++
+      }
+
+      if (cachePath && updatedCount > 0) {
+        try {
+          const serialized = JSON.stringify(Object.fromEntries(DYNAMIC_PRICING), null, 2)
+          fs.writeFileSync(cachePath, serialized, 'utf-8')
+        } catch (writeErr) {
+          logger?.warn?.(`[dsh-model-sync] failed to write pricing cache: ${writeErr?.message}`)
+        }
+      }
+
+      return { updated: updatedCount, source: 'openrouter', timestamp: Date.now() }
+    }
+  } catch (err) {
+    logger?.warn?.(`[dsh-model-sync] live pricing fetch failed: ${err?.message}, falling back to cache`)
+  } finally {
+    clearTimeout(timer)
+  }
+
+  // Fallback: try loading cached pricing from disk
+  if (cachePath && fs.existsSync(cachePath)) {
+    try {
+      const data = fs.readFileSync(cachePath, 'utf-8')
+      const parsed = JSON.parse(data)
+      for (const [k, v] of Object.entries(parsed)) {
+        DYNAMIC_PRICING.set(k.toLowerCase().trim(), Object.freeze(v))
+        updatedCount++
+      }
+      return { updated: updatedCount, source: 'cache', timestamp: Date.now() }
+    } catch (readErr) {
+      logger?.warn?.(`[dsh-model-sync] failed to read pricing cache: ${readErr?.message}`)
+    }
+  }
+
+  return { updated: 0, source: 'reference', timestamp: Date.now() }
+}

package/lib/provider-service.js

@@ -1,5 +1,7 @@
 import { listApiKeyProviders } from './inventory.js'
 import { lookupReferenceLimits, lookupReferenceReasoning, clampOutputTokens, adaptReasoningPayload } from './specs-database.js'
+import { deriveModelTags, isCuratedModel } from './models.js'
+import { lookupReferencePricing } from './pricing-database.js'
 
 export function createProviderService(ctx) {
   const readSettings = () => {
@@ -62,6 +64,43 @@ export function createProviderService(ctx) {
     return adaptReasoningPayload(found, options)
   }
 
+  const getPricing = (provider, modelId) => {
+    const p = getProvider(provider)
+    const catalog = Array.isArray(p?.models) ? p.models : []
+    const found = catalog.find((m) => (m?.id === modelId || m?.name === modelId))
+    if (found?.pricing) return found.pricing
+    return lookupReferencePricing(provider, modelId) ?? null
+  }
+
+  const getTags = (provider, modelId) => {
+    const p = getProvider(provider)
+    const catalog = Array.isArray(p?.models) ? p.models : []
+    const found = catalog.find((m) => (m?.id === modelId || m?.name === modelId))
+    if (found?.tags && found.tags.length > 0) return found.tags
+    if (found) return deriveModelTags(found)
+    return deriveModelTags({ provider, id: modelId })
+  }
+
+  const isCurated = (provider, modelId) => {
+    const p = getProvider(provider)
+    const catalog = Array.isArray(p?.models) ? p.models : []
+    const found = catalog.find((m) => (m?.id === modelId || m?.name === modelId))
+    return isCuratedModel(found || { provider, id: modelId })
+  }
+
+
+  const getVerifiedCapabilities = (provider, modelId) => {
+    try {
+      const runner = ctx?.reflect?.get?.('modelSyncRunner') ?? (typeof ctx?.get === 'function' ? ctx.get('modelSyncRunner') : undefined)
+      if (runner && typeof runner.getVerifiedCapabilities === 'function') {
+        return runner.getVerifiedCapabilities({ provider, model: modelId })
+      }
+    } catch {
+      // ignore
+    }
+    return null
+  }
+
   return Object.freeze({
     listProviders,
     getProvider,
@@ -69,5 +108,9 @@ export function createProviderService(ctx) {
     clampCompletionTokens,
     getReasoningConfig,
     adaptReasoningPayload: adaptReasoning,
+    getPricing,
+    getTags,
+    isCurated,
+    getVerifiedCapabilities,
   })
 }

package/lib/reconcile.js

@@ -1,4 +1,4 @@
-import { diffModels, normalizeModels, stableStringify } from './models.js'
+import { diffModels, normalizeModels, stableStringify, deriveModelTags } from './models.js'
 
 function sameModel(left, right) {
   return stableStringify(left) === stableStringify(right)
@@ -35,6 +35,8 @@ export function reconcileModels(provider, current, discovered, {
         } : {}),
         ...(fresh.input?.length ? { input: fresh.input } : row.input ? { input: row.input } : {}),
       }
+      const derivedTags = deriveModelTags(merged)
+      if (derivedTags.length > 0) merged.tags = derivedTags
       next.push(merged)
     } else if (renamedBefore.has(row.id)) {
       // An explicit provider alias is safe evidence that the old id was renamed.
@@ -45,7 +47,12 @@ export function reconcileModels(provider, current, discovered, {
   }
   const known = new Set(before.map((row) => row.id))
   for (const row of advertised) {
-    if (!known.has(row.id)) next.push(row)
+    if (!known.has(row.id)) {
+      const copy = { ...row }
+      const derivedTags = deriveModelTags(copy)
+      if (derivedTags.length > 0) copy.tags = derivedTags
+      next.push(copy)
+    }
   }
   const diff = diffModels(before, next)
   return {

package/lib/scheduler.js

@@ -24,6 +24,7 @@ export function createSyncScheduler(sync, {
 } = {}) {
   let timer = null
   let running = false
+  let lastPricingSyncAt = 0
   const state = new Map()
 
   function stop() {
@@ -82,6 +83,12 @@ export function createSyncScheduler(sync, {
   async function tick() {
     const config = getConfig() ?? {}
     if (config.enabled === false || config.scheduleEnabled === false || running) return
+    if (typeof sync.syncPricing === 'function' && (nowFn() - lastPricingSyncAt > 24 * 60 * 60 * 1000 || lastPricingSyncAt === 0)) {
+      lastPricingSyncAt = nowFn()
+      sync.syncPricing().catch((err) => {
+        logger.warn?.('[dsh-model-sync] background pricing sync failed: ' + errorMessage(err))
+      })
+    }
     resetStates(config)
     const rows = scheduleRows(config)
     if (rows.length === 0) return

package/lib/synchronizer-prober.js

@@ -1,3 +1,31 @@
+const SPARKLINE_BARS = [' ', '▂', '▃', '▄', '▅', '▆', '▇', '█']
+
+export function generateSparkline(values) {
+  if (!Array.isArray(values) || values.length === 0) return ''
+  const nums = values.filter((v) => typeof v === 'number' && Number.isFinite(v))
+  if (nums.length === 0) return ''
+  if (nums.length === 1) return '▄'
+  const min = Math.min(...nums)
+  const max = Math.max(...nums)
+  if (min === max) return '▄'.repeat(nums.length)
+  const range = max - min
+  return nums
+    .map((v) => {
+      const idx = Math.min(7, Math.max(0, Math.floor(((v - min) / range) * 7)))
+      return SPARKLINE_BARS[idx]
+    })
+    .join('')
+}
+
+export function classifySpeedTier(latencyMs, isOk = true) {
+  if (!isOk) return 'degraded'
+  if (typeof latencyMs !== 'number' || !Number.isFinite(latencyMs) || latencyMs <= 0) return 'unknown'
+  if (latencyMs < 300) return 'lightning'
+  if (latencyMs < 1200) return 'fast'
+  if (latencyMs <= 3000) return 'moderate'
+  return 'slow'
+}
+
 export function createModelProber({
   health,
   getProviderCatalog = () => [],
@@ -5,8 +33,32 @@ export function createModelProber({
   inferModel,
 } = {}) {
   const modelProbes = new Map()
+  const latencyHistory = new Map()
   const probeFn = probeModel ?? inferModel
 
+  function recordLatencyEntry(provider, model, { latencyMs, ttftMs, ok, status, error }) {
+    const key = `${provider}:${model}`
+    modelProbes.set(key, {
+      latencyMs,
+      ttftMs,
+      ok,
+      status,
+      timestamp: Date.now(),
+    })
+
+    const hist = latencyHistory.get(key) || []
+    hist.push({
+      timestamp: Date.now(),
+      latencyMs,
+      ttftMs,
+      ok,
+      status,
+      ...(error ? { error } : {}),
+    })
+    if (hist.length > 10) hist.shift()
+    latencyHistory.set(key, hist)
+  }
+
   async function tryModel({ provider, model, signal } = {}) {
     if (typeof provider !== 'string' || !provider) throw new Error('provider is required')
     if (typeof model !== 'string' || !model) throw new Error('model is required')
@@ -21,15 +73,11 @@ export function createModelProber({
         model,
         ok: false,
         latencyMs: 0,
+        ttftMs: 0,
         status: 'model_not_found',
         error: `model "${model}" not found in provider catalog`,
       }
-      modelProbes.set(`${provider}:${model}`, {
-        latencyMs: 0,
-        ok: false,
-        status: 'model_not_found',
-        timestamp: Date.now(),
-      })
+      recordLatencyEntry(provider, model, probeResult)
       return probeResult
     }
 
@@ -38,6 +86,9 @@ export function createModelProber({
       try {
         const probeRes = await probeFn({ provider, model, signal })
         const latencyMs = Math.max(1, Date.now() - start)
+        const ttftMs = typeof probeRes?.ttftMs === 'number'
+          ? probeRes.ttftMs
+          : (typeof probeRes?.metrics?.ttft === 'number' ? probeRes.metrics.ttft : Math.round(latencyMs * 0.45))
         const isOk = probeRes?.ok !== false
         const status = isOk ? 'ok' : (probeRes?.status || 'error')
         const errorMsg = isOk ? undefined : (probeRes?.error || 'inference probe failed')
@@ -46,33 +97,26 @@ export function createModelProber({
           model,
           ok: isOk,
           latencyMs,
+          ttftMs,
           status,
           ...(errorMsg ? { error: errorMsg } : {}),
         }
-        modelProbes.set(`${provider}:${model}`, {
-          latencyMs,
-          ok: isOk,
-          status,
-          timestamp: Date.now(),
-        })
+        recordLatencyEntry(provider, model, probeResult)
         return probeResult
       } catch (err) {
         const latencyMs = Math.max(1, Date.now() - start)
+        const ttftMs = Math.round(latencyMs * 0.45)
         const status = err?.status ? `http_${err.status}` : (err?.code || 'error')
         const probeResult = {
           provider,
           model,
           ok: false,
           latencyMs,
+          ttftMs,
           status,
           error: err?.message || 'inference probe failed',
         }
-        modelProbes.set(`${provider}:${model}`, {
-          latencyMs,
-          ok: false,
-          status,
-          timestamp: Date.now(),
-        })
+        recordLatencyEntry(provider, model, probeResult)
         return probeResult
       }
     }
@@ -82,6 +126,7 @@ export function createModelProber({
     const entry = healthResult?.results?.find((r) => r.provider === provider)
     const providerOk = entry?.status === 'ok'
     const latencyMs = Math.max(1, Date.now() - start)
+    const ttftMs = Math.round(latencyMs * 0.45)
     const status = !providerOk ? (entry?.status ?? 'error') : 'ok'
     const errorMsg = !providerOk ? (entry?.message || entry?.status || 'probe failed') : undefined
 
@@ -90,17 +135,12 @@ export function createModelProber({
       model,
       ok: providerOk,
       latencyMs,
+      ttftMs,
       status,
       ...(errorMsg ? { error: errorMsg } : {}),
     }
 
-    modelProbes.set(`${provider}:${model}`, {
-      latencyMs,
-      ok: providerOk,
-      status,
-      timestamp: Date.now(),
-    })
-
+    recordLatencyEntry(provider, model, probeResult)
     return probeResult
   }
 
@@ -110,7 +150,6 @@ export function createModelProber({
     const list = [...new Set(models.filter((m) => typeof m === 'string' && m.trim()).map((m) => m.trim()))].slice(0, 50)
 
     if (typeof probeFn === 'function') {
-      // Execute true model-specific probes with bounded concurrency
       const limit = Math.max(1, Math.min(10, Math.floor(Number(concurrency) || 4)))
       const results = new Array(list.length)
       let cursor = 0
@@ -131,7 +170,6 @@ export function createModelProber({
       }
     }
 
-    // If no probeFn provided, use provider health once (backwards compatibility)
     const start = Date.now()
     const healthResult = await health?.({ provider, signal })
     const entry = healthResult?.results?.find((r) => r.provider === provider)
@@ -139,6 +177,7 @@ export function createModelProber({
     const catalog = typeof getProviderCatalog === 'function' ? getProviderCatalog(provider) : []
     const hasCatalog = Array.isArray(catalog) && catalog.length > 0
     const baseLatency = Math.max(1, Date.now() - start)
+    const ttftMs = Math.round(baseLatency * 0.45)
 
     const results = list.map((model) => {
       const inCatalog = !hasCatalog || catalog.some((m) => (typeof m === 'string' ? m : m?.id) === model)
@@ -153,17 +192,12 @@ export function createModelProber({
         model,
         ok,
         latencyMs: baseLatency,
+        ttftMs,
         status,
         ...(errorMsg ? { error: errorMsg } : {}),
       }
 
-      modelProbes.set(`${provider}:${model}`, {
-        latencyMs: baseLatency,
-        ok,
-        status,
-        timestamp: Date.now(),
-      })
-
+      recordLatencyEntry(provider, model, itemResult)
       return itemResult
     })
 
@@ -179,9 +213,57 @@ export function createModelProber({
     return Object.fromEntries(modelProbes)
   }
 
+  function getLatencyHistory(provider, model) {
+    if (provider && model) {
+      return latencyHistory.get(`${provider}:${model}`) || []
+    }
+    return Object.fromEntries(latencyHistory)
+  }
+
+  function getLatencyRadar({ provider } = {}) {
+    const radar = []
+    for (const [key, hist] of latencyHistory.entries()) {
+      if (!Array.isArray(hist) || hist.length === 0) continue
+      const [entryProv, ...rest] = key.split(':')
+      const entryModel = rest.join(':')
+      if (provider && entryProv !== provider) continue
+
+      const latest = hist[hist.length - 1]
+      const latencies = hist.map((h) => h.latencyMs)
+      const avgLatencyMs = Math.round(latencies.reduce((acc, v) => acc + v, 0) / latencies.length)
+      const sorted = [...latencies].sort((a, b) => a - b)
+      const p95Idx = Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95))
+      const p95LatencyMs = sorted[p95Idx]
+      const sparkline = generateSparkline(latencies)
+      const tier = classifySpeedTier(latest.latencyMs, latest.ok)
+
+      radar.push({
+        provider: entryProv,
+        model: entryModel,
+        latencyMs: latest.latencyMs,
+        ttftMs: latest.ttftMs,
+        avgLatencyMs,
+        p95LatencyMs,
+        tier,
+        sparkline,
+        history: latencies,
+        ok: latest.ok,
+        status: latest.status,
+        lastChecked: latest.timestamp,
+      })
+    }
+
+    return {
+      updatedAt: Date.now(),
+      radar,
+    }
+  }
+
   return {
     tryModel,
     batchTryModels,
     getModelProbes,
+    getLatencyHistory,
+    getLatencyRadar,
   }
-}
+}