dsh-all-usage 1.0.9 → 1.1.2

package/lib/pricing.js

@@ -0,0 +1,645 @@
+import { createHash } from 'node:crypto'
+
+const PRICING_SCHEMA_VERSION = 1
+const COST_SCHEMA_VERSION = 1
+const MODEL_CATALOG_URL = 'https://models.dev/api.json'
+const DEFAULT_SYNC_INTERVAL_MS = 6 * 60 * 60 * 1000
+const MAX_CATALOG_BYTES = 24 * 1024 * 1024
+const MAX_PRICE_ENTRIES = 10000
+const MAX_OVERRIDES = 500
+const MAX_MAPPINGS = 500
+const RATE_KEYS = ['input', 'output', 'cacheRead', 'cacheWrite']
+const INPUT_SEMANTICS = ['legacy', 'total', 'fresh']
+const COST_STATUSES = ['priced', 'unpriced', 'ambiguous', 'unsupported']
+const OFFICIAL_PROVIDER_RULES = [
+  { providers: ['openai'], prefixes: ['gpt-', 'o1', 'o3', 'o4', 'o5'] },
+  { providers: ['anthropic'], prefixes: ['claude-'] },
+  { providers: ['google'], prefixes: ['gemini-', 'gemma-'] },
+  { providers: ['xai'], prefixes: ['grok-'] },
+  { providers: ['deepseek'], prefixes: ['deepseek-'] },
+  { providers: ['moonshotai', 'moonshot'], prefixes: ['kimi-', 'moonshot-'] },
+  { providers: ['qwen', 'alibaba'], prefixes: ['qwen'] },
+  { providers: ['zai', 'zhipuai', 'zhipu'], prefixes: ['glm-', 'chatglm-'] },
+  { providers: ['minimax'], prefixes: ['minimax-'] },
+  { providers: ['mistral'], prefixes: ['mistral-', 'mixtral-'] },
+  { providers: ['meta'], prefixes: ['llama-', 'meta-llama'] },
+  { providers: ['cohere'], prefixes: ['command-'] },
+  { providers: ['ai21'], prefixes: ['jamba-'] },
+  { providers: ['baidu'], prefixes: ['ernie-'] },
+]
+const MAX_DECIMAL_DIGITS = 40
+const MAX_DECIMAL_EXPONENT = 24
+
+function isRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function finiteNumber(value) {
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+  if (typeof value === 'string' && value.trim() !== '') {
+    const parsed = Number(value)
+    if (Number.isFinite(parsed)) return parsed
+  }
+  return null
+}
+
+function decimalParts(value) {
+  const raw = typeof value === 'number' ? String(value) : typeof value === 'string' ? value.trim().toLowerCase() : ''
+  const match = raw.match(/^(\d+)(?:\.(\d+))?(?:e([+-]?\d+))?$/)
+  if (!match) return null
+  let digits = (match[1] || '') + (match[2] || '')
+  const exponent = match[3] ? Number(match[3]) : 0
+  if (!Number.isSafeInteger(exponent) || Math.abs(exponent) > MAX_DECIMAL_EXPONENT) return null
+  let scale = (match[2] || '').length - exponent
+  digits = digits.replace(/^0+(?=\d)/, '')
+  if (scale < 0) {
+    digits += '0'.repeat(-scale)
+    scale = 0
+  }
+  if (scale > digits.length) digits = '0'.repeat(scale - digits.length + 1) + digits
+  if (digits.length > MAX_DECIMAL_DIGITS) return null
+  while (scale > 0 && digits.length > 1 && digits.endsWith('0')) {
+    digits = digits.slice(0, -1)
+    scale -= 1
+  }
+  digits = digits.replace(/^0+(?=\d)/, '')
+  return { digits: BigInt(digits || '0'), scale }
+}
+
+function decimalText(value) {
+  const parts = decimalParts(value)
+  if (parts === null) return null
+  if (parts.digits === 0n) return '0'
+  const raw = parts.digits.toString()
+  if (parts.scale === 0) return raw
+  const padded = raw.padStart(parts.scale + 1, '0')
+  const split = padded.length - parts.scale
+  return padded.slice(0, split) + '.' + padded.slice(split)
+}
+
+function decimalAdd(left, right) {
+  const a = decimalParts(left) || { digits: 0n, scale: 0 }
+  const b = decimalParts(right) || { digits: 0n, scale: 0 }
+  const scale = Math.max(a.scale, b.scale)
+  const value = a.digits * 10n ** BigInt(scale - a.scale) + b.digits * 10n ** BigInt(scale - b.scale)
+  return decimalText(value.toString() + (scale > 0 ? 'e-' + scale : '')) || '0'
+}
+
+function decimalMultiply(left, right) {
+  const a = decimalParts(left) || { digits: 0n, scale: 0 }
+  const b = decimalParts(right) || { digits: 0n, scale: 0 }
+  return decimalText((a.digits * b.digits).toString() + ((a.scale + b.scale) > 0 ? 'e-' + (a.scale + b.scale) : '')) || '0'
+}
+
+function decimalSubtract(left, right) {
+  const a = decimalParts(left) || { digits: 0n, scale: 0 }
+  const b = decimalParts(right) || { digits: 0n, scale: 0 }
+  const scale = Math.max(a.scale, b.scale)
+  const value = a.digits * 10n ** BigInt(scale - a.scale) - b.digits * 10n ** BigInt(scale - b.scale)
+  if (value <= 0n) return '0'
+  return decimalText(value.toString() + (scale > 0 ? 'e-' + scale : '')) || '0'
+}
+
+function decimalGreaterThanZero(value) {
+  const parts = decimalParts(value)
+  return parts !== null && parts.digits > 0n
+}
+
+function nonNegativeDecimal(value, fallback = '0') {
+  const parsed = decimalText(value)
+  if (parsed === null || !decimalParts(parsed) || decimalParts(parsed).digits < 0n) return fallback
+  return parsed
+}
+
+function normalizeModelId(value) {
+  if (typeof value !== 'string') return ''
+  let normalized = value.trim()
+  const slash = normalized.lastIndexOf('/')
+  if (slash >= 0) normalized = normalized.slice(slash + 1)
+  normalized = normalized.split(':', 1)[0].trim().replace(/@/g, '-').toLowerCase()
+  normalized = normalized.replace(/\[1m\]$/i, '').trim()
+  return normalized
+}
+
+function pushUnique(list, value) {
+  if (typeof value === 'string' && value !== '' && !list.includes(value)) list.push(value)
+}
+
+function stripKnownNamespace(value) {
+  const claude = value.lastIndexOf('claude-')
+  if (claude > 0) return value.slice(claude)
+  for (const marker of ['openai.', 'anthropic.', 'google.', 'moonshot.', 'moonshotai.', 'bedrock.', 'global.']) {
+    if (value.startsWith(marker)) return value.slice(marker.length)
+  }
+  return null
+}
+
+function stripClaudeDesktopPrefix(value) {
+  const markers = ['abab', 'ark-code', 'arctic', 'astron', 'codex', 'command-r', 'deepseek', 'doubao', 'ernie', 'gemini', 'gemma', 'glm', 'gpt', 'grok', 'hermes', 'hy3', 'hunyuan', 'jamba', 'kimi', 'lfm', 'llama', 'longcat', 'mercury', 'mimo', 'minimax', 'mistral', 'mixtral', 'moonshot', 'nemotron', 'nova-', 'openai', 'qianfan', 'qwen', 'seed-', 'solar', 'stepfun']
+  if (!value.startsWith('claude-')) return null
+  const rest = value.slice('claude-'.length)
+  return markers.some((marker) => rest.startsWith(marker)) ? rest : null
+}
+
+function stripBedrockSuffix(value) {
+  const match = value.match(/^(.+)-v(\d+)$/)
+  return match ? match[1] : null
+}
+
+function stripDateSuffix(value) {
+  let match = value.match(/^(.+)-(\d{4}-\d{2}-\d{2})$/)
+  if (match) return match[1]
+  match = value.match(/^(.+)-(\d{8})$/)
+  if (match) return match[1]
+  match = value.match(/^(.+)-(\d{6})$/)
+  if (!match) return null
+  const month = Number(match[2].slice(2, 4))
+  const day = Number(match[2].slice(4, 6))
+  return month >= 1 && month <= 12 && day >= 1 && day <= 31 ? match[1] : null
+}
+
+function stripReasoningSuffix(value) {
+  for (const suffix of ['-minimal', '-low', '-medium', '-high', '-xhigh']) {
+    if (value.endsWith(suffix) && value.length > suffix.length) return value.slice(0, -suffix.length)
+  }
+  return null
+}
+
+function shouldTryPrefix(value) {
+  const dashCount = (value.match(/-/g) || []).length
+  if (value.startsWith('claude-')) return dashCount >= 3
+  if (['o1', 'o3', 'o4', 'o5'].some((prefix) => value.startsWith(prefix))) return dashCount >= 1
+  return ['gpt-', 'gemini-', 'deepseek-', 'qwen-', 'glm-', 'kimi-', 'minimax-'].some((prefix) => value.startsWith(prefix)) && dashCount >= 2
+}
+
+function modelPricingCandidates(value) {
+  const cleaned = normalizeModelId(value)
+  if (cleaned === '') return []
+  const candidates = []
+  const queue = [cleaned]
+  while (queue.length > 0) {
+    const candidate = queue.pop()
+    if (candidates.includes(candidate)) continue
+    pushUnique(candidates, candidate)
+    for (const next of [stripKnownNamespace(candidate), stripClaudeDesktopPrefix(candidate), stripBedrockSuffix(candidate), stripDateSuffix(candidate), stripReasoningSuffix(candidate)]) {
+      if (next !== null) queue.push(next)
+    }
+    if (candidate.startsWith('claude-') && candidate.includes('.')) queue.push(candidate.replace(/\./g, '-'))
+  }
+  return candidates
+}
+
+function normalizeProvider(value) {
+  return typeof value === 'string' ? value.trim().toLowerCase() : ''
+}
+
+function officialProviderIds(modelId) {
+  const providers = new Set()
+  for (const candidate of modelPricingCandidates(modelId)) {
+    for (const rule of OFFICIAL_PROVIDER_RULES) if (rule.prefixes.some((prefix) => candidate.startsWith(prefix))) for (const provider of rule.providers) providers.add(provider)
+  }
+  return providers
+}
+
+function identityModels(identity) {
+  const value = isRecord(identity) ? identity : {}
+  const result = []
+  for (const candidate of [value.actualModel, value.requestedModel, value.model, value.label]) {
+    const normalized = normalizeModelId(candidate)
+    if (normalized !== '' && !result.includes(normalized)) result.push(normalized)
+  }
+  return result
+}
+
+function identityKeyOf(identity) {
+  return isRecord(identity) && typeof identity.identityKey === 'string' ? identity.identityKey : ''
+}
+
+function priceEntryKey(entry) {
+  return normalizeProvider(entry.providerId) + '\0' + normalizeModelId(entry.modelId)
+}
+
+function normalizePriceEntry(raw, sourceDefault = 'models.dev') {
+  if (!isRecord(raw)) return null
+  const modelId = normalizeModelId(raw.modelId || raw.id)
+  if (modelId === '') return null
+  const input = decimalText(raw.input !== undefined ? raw.input : raw.inputPerMillion)
+  const output = decimalText(raw.output !== undefined ? raw.output : raw.outputPerMillion)
+  if (input === null || output === null || decimalParts(input).digits < 0n || decimalParts(output).digits < 0n) return null
+  const optionalDecimal = (primary, secondary) => {
+    const value = primary !== undefined ? primary : secondary
+    if (value === undefined || value === null || value === '') return '0'
+    return decimalText(value)
+  }
+  const cacheRead = optionalDecimal(raw.cacheRead, raw.cacheReadPerMillion)
+  const cacheWrite = optionalDecimal(raw.cacheWrite !== undefined ? raw.cacheWrite : raw.cacheCreation, raw.cacheWritePerMillion)
+  if (cacheRead === null || cacheWrite === null || decimalParts(cacheRead).digits < 0n || decimalParts(cacheWrite).digits < 0n) return null
+  return {
+    providerId: typeof raw.providerId === 'string' ? raw.providerId.trim() : '',
+    providerName: typeof raw.providerName === 'string' ? raw.providerName.trim().slice(0, 200) : '',
+    modelId,
+    displayName: typeof raw.displayName === 'string' && raw.displayName.trim() !== '' ? raw.displayName.trim().slice(0, 200) : modelId,
+    currency: typeof raw.currency === 'string' && raw.currency.trim() !== '' ? raw.currency.trim().toUpperCase() : 'USD',
+    input,
+    output,
+    cacheRead,
+    cacheWrite,
+    source: raw.source === 'manual' ? 'manual' : sourceDefault,
+    tiered: raw.tiered === true || raw.tiers !== undefined,
+    reasoningRateAvailable: raw.reasoningRateAvailable === true || raw.reasoning !== undefined,
+    fetchedAt: Number.isFinite(raw.fetchedAt) ? raw.fetchedAt : 0,
+  }
+}
+
+function parseModelsDevCatalog(raw, fetchedAt = Date.now()) {
+  if (!isRecord(raw)) return { ok: false, error: 'catalog-not-object' }
+  const entries = []
+  const seen = new Set()
+  for (const [providerKey, provider] of Object.entries(raw)) {
+    if (!isRecord(provider) || !isRecord(provider.models)) continue
+    const providerId = typeof provider.id === 'string' && provider.id.trim() !== '' ? provider.id.trim() : providerKey
+    const providerName = typeof provider.name === 'string' ? provider.name : providerId
+    for (const [modelKey, model] of Object.entries(provider.models)) {
+      if (!isRecord(model)) continue
+      const entry = normalizePriceEntry({
+        providerId,
+        providerName,
+        modelId: typeof model.id === 'string' ? model.id : modelKey,
+        displayName: model.name,
+        currency: 'USD',
+        input: model.cost && model.cost.input,
+        output: model.cost && model.cost.output,
+        cacheRead: model.cost && model.cost.cache_read,
+        cacheWrite: model.cost && model.cost.cache_write,
+        tiered: model.cost && model.cost.tiers !== undefined || model.cost && model.cost.context_over_200k !== undefined,
+        reasoningRateAvailable: model.cost && model.cost.reasoning !== undefined,
+        source: 'models.dev',
+        fetchedAt,
+      })
+      if (entry === null || entry.currency !== 'USD') continue
+      const key = priceEntryKey(entry)
+      if (seen.has(key)) continue
+      seen.add(key)
+      entries.push(entry)
+      if (entries.length >= MAX_PRICE_ENTRIES) break
+    }
+    if (entries.length >= MAX_PRICE_ENTRIES) break
+  }
+  if (entries.length === 0) return { ok: false, error: 'catalog-has-no-priced-models' }
+  const canonical = JSON.stringify(entries)
+  return {
+    ok: true,
+    catalog: {
+      schemaVersion: PRICING_SCHEMA_VERSION,
+      sourceUrl: MODEL_CATALOG_URL,
+      fetchedAt,
+      catalogHash: createHash('sha256').update(canonical).digest('hex'),
+      entries,
+    },
+  }
+}
+
+function normalizePricingState(raw) {
+  const value = isRecord(raw) ? raw : {}
+  const sync = isRecord(value.sync) ? value.sync : {}
+  const source = isRecord(value.source) ? value.source : {}
+  const normalizeEntries = (items, sourceDefault, limit) => (Array.isArray(items) ? items.slice(0, limit) : []).map((item) => normalizePriceEntry(item, sourceDefault)).filter((item) => item !== null)
+  const catalogEntries = normalizeEntries(value.catalogEntries || value.entries, 'models.dev', MAX_PRICE_ENTRIES)
+  const overrides = normalizeEntries(value.overrides, 'manual', MAX_OVERRIDES).map((entry) => ({ ...entry, source: 'manual' }))
+  const mappings = (Array.isArray(value.mappings) ? value.mappings : []).slice(0, MAX_MAPPINGS).map((mapping) => {
+    if (!isRecord(mapping)) return null
+    const provider = typeof mapping.provider === 'string' ? mapping.provider.trim() : ''
+    const model = normalizeModelId(mapping.model || mapping.modelId)
+    const catalogProviderId = typeof mapping.catalogProviderId === 'string' ? mapping.catalogProviderId.trim() : ''
+    const catalogModelId = normalizeModelId(mapping.catalogModelId || mapping.catalogModel)
+    if (provider === '' && model === '' && catalogProviderId === '' && catalogModelId === '') return null
+    return {
+      identityKey: typeof mapping.identityKey === 'string' ? mapping.identityKey.slice(0, 1024) : '',
+      provider,
+      model,
+      catalogProviderId,
+      catalogModelId,
+      inputTokenSemantics: INPUT_SEMANTICS.includes(mapping.inputTokenSemantics) ? mapping.inputTokenSemantics : 'fresh',
+      multiplier: decimalText(mapping.multiplier === undefined ? '1' : mapping.multiplier) || '1',
+    }
+  }).filter((mapping) => mapping !== null)
+  const providerAliases = {}
+  if (isRecord(value.providerAliases)) {
+    for (const [from, to] of Object.entries(value.providerAliases).slice(0, MAX_MAPPINGS)) {
+      if (typeof from === 'string' && typeof to === 'string' && from.trim() !== '' && to.trim() !== '') providerAliases[from.trim()] = to.trim()
+    }
+  }
+  const normalized = {
+    schemaVersion: PRICING_SCHEMA_VERSION,
+    source: {
+      url: typeof source.url === 'string' && source.url !== '' ? source.url : MODEL_CATALOG_URL,
+      fetchedAt: Number.isFinite(source.fetchedAt) ? source.fetchedAt : 0,
+      catalogHash: typeof source.catalogHash === 'string' ? source.catalogHash.slice(0, 128) : '',
+      lastError: typeof source.lastError === 'string' ? source.lastError.slice(0, 500) : '',
+    },
+    sync: {
+      autoEnabled: sync.autoEnabled === true,
+      intervalMs: Number.isFinite(sync.intervalMs) && sync.intervalMs >= 60 * 60 * 1000 ? sync.intervalMs : DEFAULT_SYNC_INTERVAL_MS,
+      lastAttemptAt: Number.isFinite(sync.lastAttemptAt) ? sync.lastAttemptAt : 0,
+      lastSuccessAt: Number.isFinite(sync.lastSuccessAt) ? sync.lastSuccessAt : 0,
+      lastError: typeof sync.lastError === 'string' ? sync.lastError.slice(0, 500) : '',
+    },
+    catalogEntries,
+    overrides,
+    mappings,
+    providerAliases,
+  }
+  const entries = normalized.overrides.concat(normalized.catalogEntries)
+  const exactIndex = new Map()
+  for (const entry of entries) {
+    const list = exactIndex.get(entry.modelId) || []
+    list.push(entry)
+    exactIndex.set(entry.modelId, list)
+  }
+  Object.defineProperty(normalized, '_entries', { value: entries, enumerable: false })
+  Object.defineProperty(normalized, '_exactIndex', { value: exactIndex, enumerable: false })
+  Object.defineProperty(normalized, '_normalized', { value: true, enumerable: false })
+  return normalized
+}
+
+function createEmptyPricingState() {
+  return normalizePricingState({})
+}
+
+function serializePricingState(state) {
+  const normalized = normalizePricingState(state)
+  return {
+    schemaVersion: normalized.schemaVersion,
+    source: { ...normalized.source },
+    sync: { ...normalized.sync },
+    catalogEntries: normalized.catalogEntries.map((entry) => ({ ...entry })),
+    overrides: normalized.overrides.map((entry) => ({ ...entry })),
+    mappings: normalized.mappings.map((mapping) => ({ ...mapping })),
+    providerAliases: { ...normalized.providerAliases },
+  }
+}
+
+function sameRates(left, right) {
+  return left.input === right.input && left.output === right.output && left.cacheRead === right.cacheRead && left.cacheWrite === right.cacheWrite && left.currency === right.currency
+}
+
+function mappingMatches(mapping, identity) {
+  const models = identityModels(identity)
+  return mapping.model !== '' && models.includes(mapping.model)
+}
+
+function findMappedEntry(mapping, state) {
+  if (mapping.catalogProviderId !== '' && mapping.catalogModelId !== '') {
+    return state.overrides.find((entry) => normalizeProvider(entry.providerId) === normalizeProvider(mapping.catalogProviderId) && entry.modelId === mapping.catalogModelId) || state.catalogEntries.find((entry) => normalizeProvider(entry.providerId) === normalizeProvider(mapping.catalogProviderId) && entry.modelId === mapping.catalogModelId) || null
+  }
+  if (mapping.catalogModelId !== '') {
+    const matches = state.overrides.concat(state.catalogEntries).filter((entry) => entry.modelId === mapping.catalogModelId)
+    return matches.length === 1 ? matches[0] : null
+  }
+  return null
+}
+
+function resolvePricing(identity, rawState) {
+  const state = rawState && rawState._normalized === true ? rawState : normalizePricingState(rawState)
+  const mapped = state.mappings.find((mapping) => mappingMatches(mapping, identity))
+  const mappedEntry = mapped === undefined ? null : findMappedEntry(mapped, state)
+  if (mapped !== undefined && mappedEntry === null && (mapped.catalogModelId !== '' || mapped.catalogProviderId !== '')) {
+    return { status: 'unpriced', reason: 'mapping-target-not-found', pricingModel: mapped.catalogModelId || null, providerId: mapped.catalogProviderId || null }
+  }
+  const models = mappedEntry === null ? identityModels(identity) : [mappedEntry.modelId]
+  const pool = state._entries || state.overrides.concat(state.catalogEntries)
+  const exactIndex = state._exactIndex || new Map()
+  const officialProviders = new Set(models.flatMap((model) => Array.from(officialProviderIds(model))))
+  const choose = (entries, model, candidate, exact) => entries.filter((entry) => {
+    if (mappedEntry !== null && entry !== mappedEntry) return false
+    if (entry.currency !== 'USD') return false
+    if (entry.source === 'manual') return true
+    return officialProviders.has(normalizeProvider(entry.providerId))
+  }).map((entry) => ({ entry, model, candidate, exact }))
+  for (const model of models) {
+    const manualMatches = []
+    const officialMatches = []
+    for (const [index, id] of modelPricingCandidates(model).entries()) {
+      const exactMatches = choose(exactIndex.get(id) || [], model, id, true)
+      manualMatches.push(...exactMatches.filter((match) => match.entry.source === 'manual').map((match) => ({ ...match, rank: index * 2 })))
+      officialMatches.push(...exactMatches.filter((match) => match.entry.source !== 'manual').map((match) => ({ ...match, rank: index * 2 })))
+      if (shouldTryPrefix(id)) {
+        const prefixMatches = choose(pool.filter((entry) => entry.modelId.startsWith(id + '-')), model, id, false)
+        manualMatches.push(...prefixMatches.filter((match) => match.entry.source === 'manual').map((match) => ({ ...match, rank: index * 2 + 1 })))
+        officialMatches.push(...prefixMatches.filter((match) => match.entry.source !== 'manual').map((match) => ({ ...match, rank: index * 2 + 1 })))
+      }
+    }
+    const matches = manualMatches.length > 0 ? manualMatches : officialMatches
+    if (matches.length === 0) continue
+    matches.sort((a, b) => a.rank - b.rank || a.entry.modelId.length - b.entry.modelId.length)
+    const best = matches[0]
+    const sameRank = matches.filter((match) => match.rank === best.rank)
+    const unique = []
+    for (const match of sameRank) if (!unique.some((entry) => sameRates(entry, match.entry))) unique.push(match.entry)
+    if (unique.length > 1) return { status: 'ambiguous', reason: 'multiple-official-prices', pricingModel: best.entry.modelId, providerId: null, candidates: unique.map((entry) => ({ providerId: entry.providerId, modelId: entry.modelId })) }
+    const entry = unique[0] || best.entry
+    return {
+      status: 'priced',
+      reason: '',
+      pricingModel: entry.modelId,
+      providerId: entry.providerId || null,
+      providerName: entry.providerName || null,
+      displayName: entry.displayName,
+      currency: entry.currency,
+      rates: { input: entry.input, output: entry.output, cacheRead: entry.cacheRead, cacheWrite: entry.cacheWrite },
+      source: entry.source,
+      tiered: entry.tiered,
+      reasoningRateAvailable: entry.reasoningRateAvailable,
+      inputTokenSemantics: mapped && INPUT_SEMANTICS.includes(mapped.inputTokenSemantics) ? mapped.inputTokenSemantics : 'fresh',
+      multiplier: mapped ? mapped.multiplier : '1',
+    }
+  }
+  const model = models[0] || null
+  if (officialProviders.size === 0) return { status: 'unsupported', reason: 'official-provider-unknown', pricingModel: model, providerId: null }
+  return { status: 'unpriced', reason: 'official-price-not-found', pricingModel: model, providerId: null }
+}
+
+function tokenCount(value) {
+  const parsed = finiteNumber(value)
+  if (parsed === null || parsed <= 0) return 0n
+  return BigInt(Math.trunc(parsed))
+}
+
+function costPerMillion(tokens, rate) {
+  const tokenValue = tokenCount(tokens)
+  const rateParts = decimalParts(rate) || { digits: 0n, scale: 0 }
+  const numerator = tokenValue * rateParts.digits
+  const scale = rateParts.scale + 6
+  return decimalText(numerator.toString() + (scale > 0 ? 'e-' + scale : '')) || '0'
+}
+
+function calculateCost(values, resolved) {
+  const input = finiteNumber(values && values.input) || 0
+  const output = finiteNumber(values && values.output) || 0
+  const cacheRead = finiteNumber(values && values.cacheRead) || 0
+  const cacheWrite = finiteNumber(values && values.cacheWrite) || 0
+  const inputSemantics = INPUT_SEMANTICS.includes(resolved && resolved.inputTokenSemantics) ? resolved.inputTokenSemantics : 'fresh'
+  const billableInput = inputSemantics === 'total' ? Math.max(0, input - cacheRead - cacheWrite) : inputSemantics === 'legacy' ? Math.max(0, input - cacheRead) : input
+  const billableOutput = output
+  const base = {
+    schemaVersion: COST_SCHEMA_VERSION,
+    pricingMode: 'official-model',
+    status: resolved && COST_STATUSES.includes(resolved.status) ? resolved.status : 'unpriced',
+    currency: resolved && resolved.currency ? resolved.currency : 'USD',
+    source: resolved && resolved.source ? resolved.source : 'none',
+    pricingModel: resolved && resolved.pricingModel ? resolved.pricingModel : null,
+    providerId: resolved && resolved.providerId ? resolved.providerId : null,
+    inputTokenSemantics: inputSemantics,
+    multiplier: decimalText(resolved && resolved.multiplier !== undefined ? resolved.multiplier : '1') || '1',
+    billableInputTokens: Math.trunc(billableInput),
+    billableOutputTokens: Math.trunc(billableOutput),
+    rates: resolved && resolved.rates ? { ...resolved.rates } : { input: '0', output: '0', cacheRead: '0', cacheWrite: '0' },
+    breakdown: { input: '0', output: '0', cacheRead: '0', cacheWrite: '0' },
+    baseTotal: '0',
+    total: '0',
+    reason: resolved && typeof resolved.reason === 'string' ? resolved.reason : 'model-not-found',
+    tiered: resolved && resolved.tiered === true,
+    reasoningRateAvailable: resolved && resolved.reasoningRateAvailable === true,
+  }
+  if (base.status !== 'priced') return base
+  base.breakdown.input = costPerMillion(base.billableInputTokens, base.rates.input)
+  base.breakdown.output = costPerMillion(base.billableOutputTokens, base.rates.output)
+  base.breakdown.cacheRead = costPerMillion(cacheRead, base.rates.cacheRead)
+  base.breakdown.cacheWrite = costPerMillion(cacheWrite, base.rates.cacheWrite)
+  base.baseTotal = decimalAdd(decimalAdd(base.breakdown.input, base.breakdown.output), decimalAdd(base.breakdown.cacheRead, base.breakdown.cacheWrite))
+  base.total = decimalMultiply(base.baseTotal, base.multiplier)
+  return base
+}
+
+function emptyCostAggregate(currency = 'USD') {
+  return { currency, input: '0', output: '0', cacheRead: '0', cacheWrite: '0', baseTotal: '0', total: '0', pricedCalls: 0, unpricedCalls: 0, ambiguousCalls: 0, unsupportedCalls: 0 }
+}
+
+function addCostAggregate(target, cost) {
+  const value = isRecord(cost) ? cost : {}
+  const status = COST_STATUSES.includes(value.status) ? value.status : 'unpriced'
+  if (status === 'priced') {
+    target.input = decimalAdd(target.input, value.breakdown && value.breakdown.input)
+    target.output = decimalAdd(target.output, value.breakdown && value.breakdown.output)
+    target.cacheRead = decimalAdd(target.cacheRead, value.breakdown && value.breakdown.cacheRead)
+    target.cacheWrite = decimalAdd(target.cacheWrite, value.breakdown && value.breakdown.cacheWrite)
+    target.baseTotal = decimalAdd(target.baseTotal, value.baseTotal)
+    target.total = decimalAdd(target.total, value.total)
+    target.pricedCalls += 1
+  } else if (status === 'ambiguous') target.ambiguousCalls += 1
+  else if (status === 'unsupported') target.unsupportedCalls += 1
+  else target.unpricedCalls += 1
+  return target
+}
+
+function serializeCostAggregate(cost) {
+  const value = cost || emptyCostAggregate()
+  return {
+    currency: typeof value.currency === 'string' && value.currency !== '' ? value.currency : 'USD',
+    input: decimalText(value.input) || '0',
+    output: decimalText(value.output) || '0',
+    cacheRead: decimalText(value.cacheRead) || '0',
+    cacheWrite: decimalText(value.cacheWrite) || '0',
+    baseTotal: decimalText(value.baseTotal) || '0',
+    total: decimalText(value.total) || '0',
+    pricedCalls: Number.isFinite(value.pricedCalls) ? value.pricedCalls : 0,
+    unpricedCalls: Number.isFinite(value.unpricedCalls) ? value.unpricedCalls : 0,
+    ambiguousCalls: Number.isFinite(value.ambiguousCalls) ? value.ambiguousCalls : 0,
+    unsupportedCalls: Number.isFinite(value.unsupportedCalls) ? value.unsupportedCalls : 0,
+  }
+}
+
+function normalizeCostSnapshot(raw) {
+  if (!isRecord(raw) || !COST_STATUSES.includes(raw.status)) return null
+  const rates = isRecord(raw.rates) ? raw.rates : {}
+  const breakdown = isRecord(raw.breakdown) ? raw.breakdown : {}
+  const fields = ['input', 'output', 'cacheRead', 'cacheWrite']
+  const normalizedRates = {}
+  const normalizedBreakdown = {}
+  for (const field of fields) {
+    const rate = decimalText(rates[field])
+    const cost = decimalText(breakdown[field])
+    if (rate === null || cost === null) return null
+    normalizedRates[field] = rate
+    normalizedBreakdown[field] = cost
+  }
+  const baseTotal = decimalText(raw.baseTotal)
+  const total = decimalText(raw.total)
+  const multiplier = decimalText(raw.multiplier)
+  if (baseTotal === null || total === null || multiplier === null) return null
+  return {
+    schemaVersion: COST_SCHEMA_VERSION,
+    pricingMode: raw.pricingMode === 'official-model' ? 'official-model' : 'legacy-provider-aware',
+    status: raw.status,
+    currency: typeof raw.currency === 'string' ? raw.currency : 'USD',
+    source: typeof raw.source === 'string' ? raw.source : 'none',
+    pricingModel: typeof raw.pricingModel === 'string' ? raw.pricingModel : null,
+    providerId: typeof raw.providerId === 'string' ? raw.providerId : null,
+    inputTokenSemantics: INPUT_SEMANTICS.includes(raw.inputTokenSemantics) ? raw.inputTokenSemantics : 'fresh',
+    multiplier,
+    billableInputTokens: Number.isFinite(raw.billableInputTokens) ? Math.max(0, Math.trunc(raw.billableInputTokens)) : 0,
+    billableOutputTokens: Number.isFinite(raw.billableOutputTokens) ? Math.max(0, Math.trunc(raw.billableOutputTokens)) : 0,
+    rates: normalizedRates,
+    breakdown: normalizedBreakdown,
+    baseTotal,
+    total,
+    reason: typeof raw.reason === 'string' ? raw.reason.slice(0, 200) : '',
+    tiered: raw.tiered === true,
+    reasoningRateAvailable: raw.reasoningRateAvailable === true,
+  }
+}
+
+async function fetchModelsDevCatalog(fetchImpl = globalThis.fetch, options = {}) {
+  if (typeof fetchImpl !== 'function') return { ok: false, error: 'fetch-unavailable' }
+  const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : 15000
+  const url = typeof options.url === 'string' && options.url !== '' ? options.url : MODEL_CATALOG_URL
+  let controller = null
+  let timer = null
+  try {
+    if (typeof AbortController === 'function') {
+      controller = new AbortController()
+      timer = setTimeout(() => controller.abort(), timeoutMs)
+    }
+    const response = await fetchImpl(url, { headers: { accept: 'application/json' }, signal: controller ? controller.signal : undefined })
+    if (!response || response.ok !== true) return { ok: false, error: 'http-' + String(response && response.status || 0) }
+    const length = response.headers && typeof response.headers.get === 'function' ? Number(response.headers.get('content-length')) : 0
+    if (Number.isFinite(length) && length > MAX_CATALOG_BYTES) return { ok: false, error: 'catalog-too-large' }
+    const text = await response.text()
+    if (new TextEncoder().encode(text).length > MAX_CATALOG_BYTES) return { ok: false, error: 'catalog-too-large' }
+    let parsed
+    try { parsed = JSON.parse(text.replace(/^\uFEFF/, '')) } catch (err) { return { ok: false, error: 'catalog-invalid-json' } }
+    return parseModelsDevCatalog(parsed, Date.now())
+  } catch (err) {
+    return { ok: false, error: 'catalog-fetch-failed' }
+  } finally {
+    if (timer !== null) clearTimeout(timer)
+  }
+}
+
+export {
+  COST_SCHEMA_VERSION,
+  COST_STATUSES,
+  DEFAULT_SYNC_INTERVAL_MS,
+  INPUT_SEMANTICS,
+  MODEL_CATALOG_URL,
+  PRICING_SCHEMA_VERSION,
+  RATE_KEYS,
+  addCostAggregate,
+  calculateCost,
+  createEmptyPricingState,
+  decimalAdd,
+  decimalMultiply,
+  decimalSubtract,
+  decimalText,
+  emptyCostAggregate,
+  fetchModelsDevCatalog,
+  modelPricingCandidates,
+  officialProviderIds,
+  normalizeCostSnapshot,
+  normalizeModelId,
+  normalizePricingState,
+  parseModelsDevCatalog,
+  resolvePricing,
+  serializeCostAggregate,
+  serializePricingState,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-all-usage",
-  "version": "1.0.9",
+  "version": "1.1.2",
   "description": "DeepSeek Harness usage dashboard with model, provider, workspace, cache, balance, and CSV insights",
   "repository": {
     "type": "git",
@@ -37,8 +37,10 @@
   "files": [
     "lib/index.js",
     "lib/client.js",
+    "lib/pricing.js",
     "CHANGELOG.md",
     "cordis.patch.yml",
+    "screenshots.json",
     "assets"
   ],
   "keywords": [

package/screenshots.json

@@ -0,0 +1,5 @@
+[
+  "assets/screenshot-1.png",
+  "assets/screenshot-2.png",
+  "assets/screenshot-3.png"
+]