@ebony-vinyl/dsh-our-free-model 2.7.4 → 2.8.0

package/src/core/runtime.js

@@ -1,456 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { FreeModelAdapter, ROUTE_MAIN, ROUTE_REGION } from '../adapter.js'
-import { buildCatalog, buildEacCatalog, buildKiloCatalog, isEacEntry, isKiloEntry, parseListing, reviveKiloCatalog } from '../catalog.js'
-import { buildAggregateCatalog, isAggregateEntry } from '../aggregate.js'
-import { buildComboCatalog, isComboEntry, normalizeCombos, pruneRotation } from '../combos.js'
-import { JsonStore, SETTINGS_INITIAL, STATS_INITIAL, STATS_VERSION, migrateStats, pruneDays, recordTurn, recordUsage, isModelHidden } from '../store.js'
-import { STATE, detectEgress, probeCatalog } from '../probe.js'
-import { CODE, UpstreamError, getJson } from '../http.js'
-import { runModelTest, modelAvailability } from '../model-test.js'
-import { DEFAULT_LEVEL } from '../effort.js'
-import { fetchSealedListing } from '../eac.js'
-import { fetchKiloListing } from '../kilo.js'
-import { sessionForConversation } from '../upstream.js'
-import { createForwardCompletion, publicModelRows } from './completion.js'
-import { isSubscriptionEntry, subscriptionCatalog } from '../subscription-adapter.js'
-
-const FALLBACK_CATALOG = buildCatalog([
-  'mimo-v2.6-flash-free', 'mimo-v2.5-free', 'ling-3.0-flash-fin-free',
-  'nemotron-3-ultra-free', 'nemotron-3.5-lightning-free', 'space-bunny-free',
-  'muse-spark-1.3-contributor-free', 'muse-spark-1.2-contributor-free',
-])
-
-/** 路径由产品入口决定；核心不解析 DSH_HOME，也不发现宿主服务。 */
-export function createRuntimeStores({ dataDir, logger = console }) {
-  if (typeof dataDir !== 'string' || !path.isAbsolute(dataDir)) {
-    throw new TypeError('dataDir must be an absolute path')
-  }
-  fs.mkdirSync(dataDir, { recursive: true, mode: 0o700 })
-  const open = (file, initial) => new JsonStore(path.join(dataDir, file), structuredClone(initial), {
-    log: message => logger.warn?.(message),
-  })
-  // Seed the recommended combo only for a genuinely fresh install. Existing
-  // settings files that predate combos must not gain a new advertised model
-  // merely because a new default was added to SETTINGS_INITIAL; user edits to
-  // an existing `combos` field still win through JsonStore's normal merge.
-  const settingsInitial = structuredClone(SETTINGS_INITIAL)
-  const settingsPath = path.join(dataDir, 'settings.json')
-  if (fs.existsSync(settingsPath)) settingsInitial.combos = []
-  const settings = new JsonStore(settingsPath, settingsInitial, {
-    log: message => logger.warn?.(message),
-  })
-  const stats = open('stats.json', STATS_INITIAL)
-  const availability = open('availability.json', { version: 1, at: 0, egress: null, results: {} })
-  const catalogStore = open('catalog.json', { version: 1, at: 0, entries: FALLBACK_CATALOG.map(entry => entry.id) })
-  if (stats.get().version !== STATS_VERSION) stats.edit(migrateStats)
-  return {
-    settings, stats, availability, catalogStore,
-    dispose() {
-      settings.dispose(); stats.dispose(); availability.dispose(); catalogStore.dispose()
-    },
-  }
-}
-
-/**
- * 两个产品共同使用的模型运行时。宿主仅注入能力，不传入 Cordis ctx。
- * 创建不启动网络任务；入口先绑定本地监听器，再决定何时刷新和探测。
- * Optional subscriptionRuntime supplies catalog() and complete(request, onChunk);
- * its helper owns accounting. Call syncAggregateCatalog() after account mutations.
- */
-export function createModelRuntime({
-  settings, stats, availability, catalogStore,
-  logger = console,
-  attributionUserAgent = 'our-free-model',
-  resolveImage,
-  sealedCredential = () => null,
-  onSealedUnavailable = () => {},
-  onTopology = () => {},
-  subscriptionRuntime,
-}) {
-  let catalog = materializeCatalog(catalogStore.get().entries ?? [])
-  let sealedCatalog = sealedCredential() === null ? [] : buildEacCatalog(catalogStore.get().sealIds ?? [])
-  let kiloCatalog = reviveKiloCatalog(catalogStore.get().kiloRows)
-  /** The aggregate lane: one row per enabled provider/model the user configured.
-   *  Derived from settings, not from a listing, so it is rebuilt on every merge. */
-  let aggregateCatalog = []
-  let subscriptionEntries = []
-  /** The virtual rows a combo contributes; rebuilt last, after every real lane. */
-  let comboCatalog = []
-  /** The free lane's own roster: the base every other lane is merged onto. */
-  let freeCatalog = catalog
-  let egress = availability.get().egress ?? null
-  let gatewayLatency = { ms: 0, at: 0 }
-  let disposed = false
-  const lifetime = new AbortController()
-  let egressGeneration = 0
-
-  /**
-   * Rebuild the merged catalog from its parts, in precedence order.
-   *
-   * Rebuilt rather than appended to, because every one of these lists can shrink:
-   * a provider the user switched off, a chain whose head was removed, a Kilo
-   * model that went paid. Appending only ever grew the view, so a removed row
-   * stayed dialable until the next full listing round happened to reset it.
-   *
-   * Combos come last on purpose — a chain's links have to already exist as real
-   * rows, which is also what makes `buildComboCatalog` drop a link that is gone
-   * instead of keeping a hopeful placeholder.
-   */
-  const rebuildCatalog = () => {
-    const seen = new Set()
-    const merged = []
-    for (const entry of [...freeCatalog, ...sealedCatalog, ...kiloCatalog, ...aggregateCatalog, ...subscriptionEntries]) {
-      if (entry === null || entry === undefined || seen.has(entry.id)) continue
-      seen.add(entry.id)
-      merged.push(entry)
-    }
-    const combos = normalizeCombos(settings.get().combos)
-    comboCatalog = buildComboCatalog(combos, merged)
-    pruneRotation(combos)
-    for (const entry of comboCatalog) {
-      if (seen.has(entry.id)) continue
-      seen.add(entry.id)
-      merged.push(entry)
-    }
-    catalog = merged
-  }
-  const mergeCatalogs = () => {
-    aggregateCatalog = buildAggregateCatalog(settings.get().aggregate ?? {})
-    subscriptionEntries = subscriptionCatalog(subscriptionRuntime)
-    rebuildCatalog()
-  }
-  mergeCatalogs()
-  const state = () => ({
-    catalog,
-    membership: computeMembership(catalog, availability.get(), settings.get()),
-    settings: settings.get(),
-    attributionUserAgent,
-    routing: {
-      quota: subscriptionRuntime?.routingQuota?.() ?? {},
-      usage: Object.fromEntries(catalog.map(row => [row.id, stats.get().models?.[row.id]?.calls ?? 0])),
-    },
-  })
-  const emitTopology = () => { if (!disposed) onTopology() }
-  const adapter = new FreeModelAdapter({
-    state,
-    resolveImage,
-    subscriptionRuntime,
-    sealedCredential,
-    recordUsage: record => {
-      if (disposed) return
-      recordUsage(stats, record)
-      stats.edit(value => pruneDays(value, 120))
-    },
-    recordTurn: record => { if (!disposed) recordTurn(stats, record) },
-    warn: message => logger.warn?.(message) ?? logger.log?.(message),
-    // Automatic probing is disabled by owner policy: a region refusal from a
-    // real turn stays a turn failure and never fires a background probe.
-  })
-
-  // 手动强制刷新不能借用一个因限流而跳过探测的普通刷新。
-  let catalogRefresh = null
-  let catalogRefreshForced = false
-  let catalogRefreshProbed = false
-  async function refreshCatalog(opts) {
-    // Automatic probing is disabled by owner policy: `probe` defaults to false
-    // and every automatic caller passes false. Only an explicit user action (the
-    // reprobe button or an explicit caller) asks for `probe: true`.
-    const { probe = false, force = false, report = false } = opts ?? {}
-    // 管理接口按需取本轮结果，其他调用仍返回模型数组。
-    const result = value => report ? value : value.catalog
-    if (disposed) return result({ catalog, sources: {} })
-    while (catalogRefresh !== null) {
-      const shared = catalogRefresh
-      const sharedForced = catalogRefreshForced
-      const sharedProbed = catalogRefreshProbed
-      const value = await shared
-      if (disposed || ((!force || sharedForced) && (!probe || sharedProbed))) return result(value)
-    }
-    const run = refreshCatalogOnce({ probe, force })
-    catalogRefresh = run
-    catalogRefreshForced = force
-    catalogRefreshProbed = probe
-    try { return result(await run) } finally {
-      if (catalogRefresh === run) {
-        catalogRefresh = null; catalogRefreshForced = false; catalogRefreshProbed = false
-      }
-    }
-  }
-
-  async function refreshCatalogOnce({ probe, force }) {
-    const sources = {}
-    let ids = []
-    try {
-      ids = parseListing(await fetchListing())
-    } catch (error) {
-      if (!disposed) logger.warn?.(`our-free-model: model listing refresh failed (${error?.message ?? error}); keeping the cached catalog`)
-    }
-    if (disposed) return { catalog, sources }
-    if (ids.length > 0) {
-      freeCatalog = buildCatalog(ids)
-      catalogStore.update({ at: Date.now(), entries: freeCatalog.map(entry => entry.id) })
-      catalogStore.flush()
-      settings.update({ catalogSyncedAt: Date.now() })
-    } else {
-      freeCatalog = materializeCatalog(catalogStore.get().entries ?? [])
-    }
-    sources.free = { ok: ids.length > 0, count: freeCatalog.length }
-    sources.sealed = await refreshSealedRoster()
-    if (disposed) return { catalog, sources }
-    sources.kilo = { ok: await refreshKiloRoster(), count: kiloCatalog.length }
-    if (disposed) return { catalog, sources }
-    mergeCatalogs()
-    if (probe) await refreshAvailability(force)
-    emitTopology()
-    return { catalog, sources }
-  }
-
-  async function refreshSealedRoster() {
-    const credential = sealedCredential()
-    if (credential === null) {
-      sealedCatalog = []
-      onSealedUnavailable()
-      return { ok: true, count: 0, skipped: true }
-    }
-    try {
-      const ids = parseListing(await fetchSealedListing(credential, { signal: lifetime.signal }))
-      if (disposed) return
-      // 独立应用授权变更时，旧账号正在返回的清单不得覆盖新状态。
-      if (Object.hasOwn(credential, 'userToken') && sealedCredential()?.userToken !== credential.userToken) return { ok: false, count: sealedCatalog.length, skipped: true }
-      if (ids.length > 0) {
-        sealedCatalog = buildEacCatalog(ids)
-        catalogStore.update({ sealIds: sealedCatalog.map(entry => entry.id) })
-      }
-      return { ok: ids.length > 0, count: sealedCatalog.length }
-    } catch (error) {
-      if (disposed) return
-      if (Object.hasOwn(credential, 'userToken') && sealedCredential()?.userToken !== credential.userToken) return { ok: false, count: sealedCatalog.length, skipped: true }
-      if (error?.code === CODE.credential) {
-        sealedCatalog = []
-        catalogStore.update({ sealIds: [] })
-        logger.warn?.('our-free-model: the sealed lane refused its credential; its models are hidden until it is accepted again')
-        return { ok: false, count: 0 }
-      }
-      logger.warn?.(`our-free-model: sealed lane listing failed (${error?.code ?? 'unknown'}); keeping its cached roster`)
-      return { ok: false, count: sealedCatalog.length }
-    }
-  }
-
-  async function refreshSealedLane() {
-    await refreshSealedRoster()
-    if (disposed) return
-    // The rebuild in `mergeCatalogs` drops a stale roster on its own: a closed
-    // lane's rows vanish without a filter pass over the merged view.
-    mergeCatalogs()
-    emitTopology()
-  }
-
-  async function refreshKiloRoster() {
-    try {
-      const payload = await fetchKiloListing({ signal: lifetime.signal })
-      if (disposed) return
-      if (payload?.error || !Array.isArray(payload?.data)) throw new Error('invalid Kilo model listing')
-      kiloCatalog = buildKiloCatalog(payload.data)
-      catalogStore.update({ kiloRows: kiloCatalog })
-      return true
-    } catch (error) {
-      if (!disposed) logger.warn?.(`our-free-model: Kilo channel listing failed (${error?.code ?? error?.message ?? 'unknown'}); keeping its cached roster`)
-      return false
-    }
-  }
-
-  async function fetchListing() {
-    if (disposed) return { data: [] }
-    const started = Date.now()
-    const listing = await getJson('/inference/v1/models', {
-      session: sessionForConversation('catalog:our-free-model'),
-      attributionUserAgent,
-      signal: lifetime.signal,
-    })
-    if (!disposed) gatewayLatency = { ms: Date.now() - started, at: Date.now() }
-    return listing
-  }
-
-  let probeRound = null
-  let probeRoundGeneration = 0
-  let probeThrottleStreak = 0
-  let probeBackoffUntil = 0
-  async function runProbeRound() {
-    const generation = egressGeneration
-    // The absorbed channels get no per-model probes: their verdicts would be
-    // spent against a different gateway than the one that serves them, and a
-    // roster the listing named is advertised as-is (its health is the listing
-    // round's, refreshed on the same cadence). The aggregate lane is excluded
-    // for a sharper reason — a probe there is a *real request to a provider the
-    // user pays for*, spent to learn something the settings page already knows
-    // (whether a key is configured). A combo is excluded because it has no
-    // endpoint of its own: probing one would send the chain's own id to the free
-    // lane as a model name, spending quota to collect a verdict about nothing.
-    const probeable = catalog.filter(entry => !isEacEntry(entry) && !isKiloEntry(entry) && !isAggregateEntry(entry) && !isComboEntry(entry) && !isSubscriptionEntry(entry))
-    const results = await probeCatalog(probeable, { attributionUserAgent, signal: lifetime.signal }, (id, result) => {
-      if (disposed || generation !== egressGeneration) return
-      availability.edit(value => ({
-        ...value,
-        results: {
-          ...value.results,
-          [id]: {
-            state: result.state,
-            ...result.detail === undefined ? {} : { detail: result.detail },
-            ...result.ttftMs === undefined ? {} : { ttftMs: result.ttftMs },
-            latencyMs: result.latencyMs, startedAt: result.startedAt, at: Date.now(),
-          },
-        },
-      }))
-    }, 2)
-    if (disposed || generation !== egressGeneration) return {}
-    availability.update({ at: Date.now(), egress })
-    availability.flush()
-    const verdicts = Object.values(results)
-    if (verdicts.length > 0 && verdicts.every(row => row.state === STATE.unavailable)) {
-      logger.warn?.(`our-free-model: the gateway refused all ${verdicts.length} models this round (${verdicts[0].detail ?? 'no detail'}); keeping them advertised`)
-    }
-    const allThrottled = verdicts.length > 0 && verdicts.every(row => row.state === STATE.throttled)
-    probeThrottleStreak = allThrottled ? probeThrottleStreak + 1 : 0
-    probeBackoffUntil = allThrottled
-      ? Date.now() + Math.min(30 * 2 ** (probeThrottleStreak - 1), 120) * 60_000
-      : 0
-    if (allThrottled) {
-      logger.warn?.(`our-free-model: the probe round hit the lane's quota; availability probes pause for ${Math.round((probeBackoffUntil - Date.now()) / 60_000)} minutes (your own requests are unaffected, and the reprobe button forces a round)`)
-    }
-    emitTopology()
-    return results
-  }
-  async function refreshAvailability(force = false) {
-    if (disposed || (!force && probeBackoffUntil > Date.now())) return {}
-    if (probeRound !== null && probeRoundGeneration === egressGeneration) return probeRound
-    probeRoundGeneration = egressGeneration
-    const round = runProbeRound()
-    probeRound = round
-    try { return await round } finally { if (probeRound === round) probeRound = null }
-  }
-
-  async function watchEgress() {
-    if (disposed) return false
-    const seen = await detectEgress({ signal: lifetime.signal })
-    if (disposed || seen === undefined) return false
-    const previous = availability.get().egress
-    const changed = previous === null || previous === undefined
-      || previous.ip !== seen.ip || (seen.country !== undefined && previous.country !== seen.country)
-    egress = seen
-    if (changed) {
-      egressGeneration++
-      // 保留历史记录，但旧出口的成功、拒绝和手动测量均不能代表新出口。
-      const expire = rows => Object.fromEntries(Object.entries(rows ?? {}).map(([id, row]) => [id, { ...row, stale: true }]))
-      availability.edit(value => ({
-        ...value, egress: seen, at: 0,
-        results: expire(value.results), manualResults: expire(value.manualResults),
-      }))
-      availability.flush()
-      probeThrottleStreak = 0
-      probeBackoffUntil = 0
-      emitTopology()
-      // 只使旧判定失效并通知选择器，不发送任何自动探测请求。
-      logger.info?.(`our-free-model: egress changed to ${seen.ip}${seen.country ? ` (${seen.country})` : ''}; previous availability marked stale`)
-    }
-    return true
-  }
-
-  const latestTests = new Map()
-  async function testModel(id, effort = DEFAULT_LEVEL, { signal } = {}) {
-    if (disposed) throw new UpstreamError('Model runtime stopped', CODE.aborted)
-    if (settings.get().enabled === false) throw new UpstreamError('Inference is paused', CODE.client)
-    const entry = catalog.find(candidate => candidate.id === id)
-    if (!entry) throw new UpstreamError('Unknown model "' + id + '"', CODE.client, { status: 404 })
-    const token = {}
-    latestTests.set(id, token)
-    const generation = egressGeneration
-    const selectedEffort = effort === undefined || effort === '' ? DEFAULT_LEVEL : effort
-    const linkedSignal = signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal
-    const persist = row => {
-      if (disposed || linkedSignal.aborted || latestTests.get(id) !== token || generation !== egressGeneration) return false
-      availability.edit(value => ({ ...value, manualResults: { ...value.manualResults, [id]: row } }))
-      availability.flush()
-      emitTopology()
-      return !availability.writeFailed
-    }
-    try {
-      const measured = await runModelTest(testSignal => adapter.stream({
-        provider: ROUTE_MAIN, model: entry.id,
-        messages: [{ role: 'user', content: 'Reply with exactly: OK' }],
-        reasoningEffort: selectedEffort, sessionId: 'bench:' + entry.id + ':' + selectedEffort,
-        signal: testSignal,
-      }, entry, state()), { signal: linkedSignal })
-      if (linkedSignal.aborted || disposed) throw new UpstreamError('Text test cancelled', CODE.aborted)
-      if (generation !== egressGeneration) throw new UpstreamError('Network egress changed during the text test; please test again', CODE.aborted)
-      const persisted = persist({ state: STATE.available, source: 'manual', at: Date.now(), ttftMs: measured.ttftMs, latencyMs: measured.totalMs })
-      return { model: entry.id, effort: selectedEffort, ok: true, ...measured, persisted }
-    } catch (error) {
-      // Cancellation is a user action, not a fresh availability verdict. Other failures
-      // remain unknown instead of silently banning a paid/region-gated route.
-      if (error?.code !== CODE.aborted) persist({ state: STATE.unknown, source: 'manual', at: Date.now(), detail: String(error?.message ?? error).slice(0, 200) })
-      throw error
-    } finally {
-      if (latestTests.get(id) === token) latestTests.delete(id)
-    }
-  }
-
-  return {
-    testModel, state, adapter, refreshCatalog, refreshSealedLane, refreshAvailability, watchEgress, fetchListing,
-    complete: createForwardCompletion({
-      adapter, signal: lifetime.signal,
-      state: () => {
-        const snapshot = state()
-        // Hiding advertisements must not invalidate requests using a saved id.
-        return { ...snapshot, membership: computeMembership(snapshot.catalog, availability.get(), {
-          ...snapshot.settings, hiddenModelIds: [], hideFreeModels: false, hideEacModels: false,
-        }) }
-      },
-    }),
-    publicModelRows: () => publicModelRows(state()),
-    // A settings write that changes the aggregate lane or the chains (a key
-    // saved, a subscription imported/toggled/removed, a combo edited) rebuilds
-    // the merged view without an upstream listing round.
-    syncAggregateCatalog() {
-      if (disposed) return catalog
-      mergeCatalogs()
-      emitTopology()
-      return catalog
-    },
-    get catalog() { return catalog },
-    get egress() { return egress },
-    get gatewayLatency() { return gatewayLatency },
-    setAttributionUserAgent(value) { attributionUserAgent = value },
-    dispose() {
-      if (disposed) return
-      disposed = true
-      lifetime.abort()
-    },
-  }
-}
-
-function materializeCatalog(ids) {
-  const rebuilt = buildCatalog(ids)
-  return rebuilt.length > 0 ? rebuilt : FALLBACK_CATALOG
-}
-
-export function computeMembership(catalog, availabilitySnapshot, settings) {
-  const expose = settings?.exposeRegionModels !== false
-  const verdictOf = entry => modelAvailability(entry.id, availabilitySnapshot, Boolean(entry.channel)).availability
-  const probeable = catalog.filter(entry => !entry.channel)
-  const refusedAll = probeable.length > 0 && probeable.every(entry => verdictOf(entry) === STATE.unavailable)
-  let usable = catalog.filter(entry => verdictOf(entry) !== STATE.unavailable)
-  if (refusedAll) usable = catalog
-  const main = []
-  const region = []
-  for (const entry of usable) {
-    if (isModelHidden(entry, settings)) continue
-    const verdict = verdictOf(entry)
-    if (verdict !== STATE.regionBlocked) main.push(entry.id)
-    else if (expose) region.push(entry.id)
-  }
-  const membership = {}
-  if (main.length > 0) membership[ROUTE_MAIN] = main
-  if (region.length > 0) membership[ROUTE_REGION] = region
-  return membership
-}

package/src/core/stats.js

@@ -1,98 +0,0 @@
-import { MIN_DECODE_MS } from '../store.js'
-import { describeSavingsTotal, emptySavings, savingsPercent } from '../token-saver.js'
-
-export function buildStats(stats, catalog) {
-  const days = stats.days ?? {}
-  const series = Object.keys(days).sort().map(day => ({
-    day,
-    total: days[day].total ?? 0,
-    models: Object.entries(days[day].models ?? {}).map(([model, value]) => ({ model, ...value })),
-  }))
-  const totals = {}
-  for (const entry of series) for (const row of entry.models) {
-    const previous = totals[row.model] ?? {
-      model: row.model, input: 0, output: 0, reasoning: 0, calls: 0, failed: 0,
-      ttftMs: 0, ttftSamples: 0, decodeMs: 0, decodeTokens: 0,
-    }
-    totals[row.model] = {
-      ...previous,
-      input: previous.input + row.input,
-      output: previous.output + row.output,
-      reasoning: previous.reasoning + row.reasoning,
-      calls: previous.calls + row.calls,
-      failed: previous.failed + row.failed,
-      ttftMs: previous.ttftMs + (row.ttftMs ?? 0),
-      ttftSamples: previous.ttftSamples + (row.ttftSamples ?? 0),
-      decodeMs: previous.decodeMs + (row.decodeMs ?? 0),
-      decodeTokens: previous.decodeTokens + (row.decodeTokens ?? 0),
-    }
-  }
-  const logical = stats.logical ?? {}
-  const logicalModels = logical.models ?? {}
-  const logicalReady = Number.isSafeInteger(logical.turns)
-  const lifetimeModels = stats.models ?? {}
-  const empty = model => ({
-    model, input: 0, output: 0, reasoning: 0, cacheRead: 0, calls: 0, failed: 0,
-    ttftMs: 0, ttftSamples: 0, decodeMs: 0, decodeTokens: 0,
-  })
-  // The logical map is part of the row set, not just a lookup table: a combo
-  // records its turn under the chain's own id and its physical calls under each
-  // link's, so a chain that never appears here would show its links in the panel
-  // and be invisible itself — the one row a user configuring a chain looks for.
-  const modelIds = new Set([...Object.keys(totals), ...Object.keys(lifetimeModels), ...Object.keys(logicalModels)])
-  const named = [...modelIds].map(model => {
-    const row = totals[model] ?? empty(model)
-    const lifetime = lifetimeModels[model] ?? {}
-    const physical = {
-      ...row,
-      input: Number.isSafeInteger(lifetime.input) ? lifetime.input : row.input,
-      output: Number.isSafeInteger(lifetime.output) ? lifetime.output : row.output,
-      reasoning: Number.isSafeInteger(lifetime.reasoning) ? lifetime.reasoning : row.reasoning,
-      cacheRead: Number.isSafeInteger(lifetime.cacheRead) ? lifetime.cacheRead : row.cacheRead,
-      calls: Number.isSafeInteger(lifetime.calls) ? lifetime.calls : row.calls,
-      failed: Number.isSafeInteger(lifetime.failed) ? lifetime.failed : row.failed,
-    }
-    return {
-      ...physical,
-      turns: logicalModels[model]?.turns ?? (logicalReady ? 0 : row.calls),
-      failedTurns: logicalModels[model]?.failed ?? (logicalReady ? 0 : row.failed),
-      recoveredTurns: logicalModels[model]?.recovered ?? 0,
-      name: catalog.find(entry => entry.id === model)?.name ?? model,
-      // A rate over too few measurable calls is a rounding error with a unit on it.
-      tps: row.decodeMs >= MIN_DECODE_MS ? Math.round(row.decodeTokens / (row.decodeMs / 1000)) : null,
-      avgTtftMs: row.ttftSamples > 0 ? Math.round(row.ttftMs / row.ttftSamples) : null,
-    }
-  })
-  const physicalFailed = named.reduce((sum, row) => sum + row.failed, 0)
-  const turns = logicalReady ? logical.turns : named.reduce((sum, row) => sum + row.turns, 0)
-  const failedTurns = Number.isSafeInteger(logical.failed) ? logical.failed : named.reduce((sum, row) => sum + row.failedTurns, 0)
-  const recoveredTurns = Number.isSafeInteger(logical.recovered) ? logical.recovered : named.reduce((sum, row) => sum + row.recoveredTurns, 0)
-  const hasLifetimeFailures = Number.isSafeInteger(stats.failedRequests)
-  const savings = { ...emptySavings(), ...(stats.savings ?? {}) }
-  return {
-    requests: stats.requests ?? 0,
-    requestFailures: hasLifetimeFailures ? stats.failedRequests : physicalFailed,
-    requestFailuresEstimated: stats.failedRequestsEstimated === true || !hasLifetimeFailures,
-    logicalEstimated: logical.estimated === true,
-    turns,
-    failedTurns,
-    recoveredTurns,
-    days: series,
-    models: named,
-    samples: (stats.samples ?? []).slice(-200),
-    // What the token savers measured. The percentage is computed here, from the
-    // same bytes the rows above counted, so the panel never has to derive a rate
-    // from two numbers that were rounded separately.
-    savings: { ...savings, percent: savingsPercent(savings), summary: describeSavingsTotal(savings) },
-    grand: {
-      input: named.reduce((sum, row) => sum + row.input, 0),
-      output: named.reduce((sum, row) => sum + row.output, 0),
-      reasoning: named.reduce((sum, row) => sum + row.reasoning, 0),
-      calls: named.reduce((sum, row) => sum + row.calls, 0),
-      failed: hasLifetimeFailures ? stats.failedRequests : physicalFailed,
-      turns,
-      failedTurns,
-      recoveredTurns,
-    },
-  }
-}