@ljwei-stak/dsh-model-router 0.15.0 → 0.16.0

package/.dsh-plugin/shared/dynamic-data.mjs

@@ -0,0 +1,294 @@
+/**
+ * Opt-in public-data refresh, never an API/model call. Pricing is a user-chosen
+ * curated JSON feed with official documentation citations, NOT a universal
+ * scraper or an independently authenticated official price service.
+ *
+ * Whole snapshots are validated before atomic promotion; a request reservation
+ * prevents late responses from replacing another process's newer request.
+ * Domain-name checks are not DNS-rebinding isolation: deployments must apply
+ * their own outbound network policy if untrusted users can configure endpoints.
+ */
+import { createHash, randomUUID } from 'node:crypto'
+import { isIP } from 'node:net'
+import { fetchLiveBenchSnapshot } from './livebench.mjs'
+export { applyPricingSnapshot, dynamicDataSummary, routingData } from './dynamic-data-view.mjs'
+
+const DEFAULT_TTL_MS = 86_400_000
+const TIMEOUT_MS = 8000
+const MAX_PAYLOAD_BYTES = 4 * 1024 * 1024
+const MAX_ROWS = 2000
+const MAX_CLOCK_SKEW_MS = 60_000
+const ROW_FIELDS = new Set(['provider', 'model', 'input', 'output', 'cacheRead', 'cacheWrite', 'currency', 'unit', 'asOf', 'sourceUrl'])
+const PRICE_FIELDS = new Set(['schemaVersion', 'kind', 'version', 'publishedAt', 'rows'])
+const SCORE_FIELDS = new Set(['reasoning', 'code', 'math', 'research', 'writing', 'vision', 'summarization', 'classification'])
+const object = value => value && typeof value === 'object' && !Array.isArray(value)
+const finite = value => typeof value === 'number' && Number.isFinite(value)
+const emptyData = () => ({ liveBench: null, pricing: null, status: {}, revision: '' })
+
+function stable(value) {
+  if (Array.isArray(value)) return `[${value.map(stable).join(',')}]`
+  if (object(value)) return `{${Object.keys(value).filter(key => value[key] !== undefined).sort()
+    .map(key => `${JSON.stringify(key)}:${stable(value[key])}`).join(',')}}`
+  return JSON.stringify(value)
+}
+
+const hash = value => createHash('sha256').update(stable(value)).digest('hex')
+function dataOf(state) {
+  const data = state?.dynamicData
+  return object(data) ? { liveBench: data.liveBench ?? null, pricing: data.pricing ?? null,
+    status: object(data.status) ? { ...data.status } : {}, revision: String(data.revision ?? '') } : emptyData()
+}
+
+function revisionOf(data) {
+  return hash({ liveBench: data.liveBench?.hash ?? null, pricing: data.pricing?.hash ?? null, status: data.status })
+}
+
+function publicUrl(value) {
+  if (typeof value !== 'string' || value.length > 2048) throw new Error('invalid-public-url')
+  const url = new URL(value)
+  const host = url.hostname.toLowerCase()
+  if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash
+    || (url.port && url.port !== '443') || isIP(host) || host.startsWith('[')
+    || !/^(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/u.test(host)
+    || /(?:^|\.)(?:localhost|local|internal|lan|home|test|invalid)$/u.test(host)) throw new Error('invalid-public-url')
+  return url.toString()
+}
+
+function identifier(value, max = 240) {
+  if (typeof value !== 'string' || value.trim() !== value || !value || value.length > max
+    || /[\u0000-\u001f\u007f]/u.test(value)) throw new Error('invalid-identifier')
+  return value
+}
+
+function timestamp(value, at) {
+  if (!Number.isSafeInteger(value) || value < Date.UTC(2000, 0, 1)
+    || value > at + MAX_CLOCK_SKEW_MS) throw new Error('invalid-timestamp')
+  return value
+}
+
+function boundedPrice(value) {
+  if (!finite(value) || value < 0 || value > 1_000_000) throw new Error('invalid-price')
+  return value
+}
+
+function pricingSnapshot(payload, endpoint, at) {
+  if (!object(payload) || Object.keys(payload).some(key => !PRICE_FIELDS.has(key))
+    || payload.schemaVersion !== 1 || payload.kind !== 'pricing'
+    || !Array.isArray(payload.rows) || payload.rows.length === 0 || payload.rows.length > MAX_ROWS) throw new Error('invalid-price-snapshot')
+  const version = identifier(payload.version, 160)
+  const publishedAt = timestamp(payload.publishedAt, at)
+  const prices = {}
+  let verifiedAt = Number.POSITIVE_INFINITY
+  for (const row of payload.rows) {
+    if (!object(row) || Object.keys(row).some(key => !ROW_FIELDS.has(key))
+      || row.currency !== 'USD' || row.unit !== 'per-million-tokens') throw new Error('unsupported-price-schema')
+    const provider = identifier(row.provider, 160)
+    const model = identifier(row.model)
+    const key = `${provider}\0${model}`
+    if (Object.hasOwn(prices, key)) throw new Error('duplicate-route')
+    const asOf = timestamp(row.asOf, at)
+    if (asOf > publishedAt) throw new Error('verification-after-publication')
+    verifiedAt = Math.min(verifiedAt, asOf)
+    prices[key] = { provider, model, input: boundedPrice(row.input), output: boundedPrice(row.output),
+      ...(row.cacheRead === undefined ? {} : { cacheRead: boundedPrice(row.cacheRead) }),
+      ...(row.cacheWrite === undefined ? {} : { cacheWrite: boundedPrice(row.cacheWrite) }),
+      currency: 'USD', unit: 'per-million-tokens', asOf, sourceUrl: publicUrl(row.sourceUrl) }
+  }
+  const snapshot = { kind: 'pricing', source: 'curated-pricing-json', endpoint, verifiedAt, publishedAt, version, prices }
+  return { ...snapshot, hash: hash({ kind: snapshot.kind, version, publishedAt, prices }) }
+}
+
+function benchmarkSnapshot(payload, endpoint, at) {
+  if (!object(payload) || !object(payload.models) || Object.keys(payload.models).length === 0
+    || Object.keys(payload.models).length > MAX_ROWS) throw new Error('empty-benchmark')
+  const models = {}
+  for (const [id, row] of Object.entries(payload.models)) {
+    // The existing adapter supplies normalized model ids, not provider aliases.
+    if (!/^[a-z0-9]{1,240}$/u.test(id) || !object(row) || !object(row.scores)
+      || !finite(row.overall) || row.overall < 0 || row.overall > 1) throw new Error('invalid-benchmark-row')
+    const model = identifier(row.model)
+    if (model.toLowerCase().replace(/[^a-z0-9]+/gu, '') !== id) throw new Error('invalid-benchmark-model-id')
+    const scores = {}
+    for (const [task, score] of Object.entries(row.scores)) {
+      if (!SCORE_FIELDS.has(task) || !finite(score) || score < 0 || score > 1) throw new Error('invalid-benchmark-score')
+      scores[task] = score
+    }
+    if (row.overallSource !== 'explicit' && row.overallSource !== 'derived') throw new Error('invalid-benchmark-provenance')
+    if (row.rank !== undefined && (!finite(row.rank) || row.rank < 0)) throw new Error('invalid-benchmark-rank')
+    models[id] = { model, overall: row.overall, overallSource: row.overallSource, scores,
+      ...(row.rank === undefined ? {} : { rank: row.rank }) }
+  }
+  const source = identifier(payload.source ?? 'livebench-json-mirror', 160)
+  const release = /^livebench:(20\d{2}-\d{2}-\d{2})$/u.exec(source)?.[1]
+  let publishedAt = null
+  if (release) {
+    publishedAt = Date.parse(`${release}T00:00:00.000Z`)
+    if (!Number.isSafeInteger(publishedAt) || new Date(publishedAt).toISOString().slice(0, 10) !== release
+      || publishedAt > at + MAX_CLOCK_SKEW_MS) throw new Error('invalid-benchmark-release')
+  } else if (payload.publishedAt !== undefined) {
+    publishedAt = timestamp(payload.publishedAt, at)
+  }
+  const contentHash = hash({ source, publishedAt, models })
+  return { kind: 'liveBench', source, endpoint, verifiedAt: at, publishedAt, exactModelMatch: true,
+    version: release ?? contentHash, hash: contentHash, models }
+}
+
+function mayPromote(previous, candidate) {
+  if (!previous) return true
+  // If the feed supplies no publication metadata, hash identity is NOT time order.
+  if (finite(previous.publishedAt) && finite(candidate.publishedAt) && candidate.publishedAt < previous.publishedAt) return false
+  if (candidate.kind === 'pricing') {
+    if (finite(previous.verifiedAt) && candidate.verifiedAt < previous.verifiedAt) return false
+    for (const [key, entry] of Object.entries(candidate.prices)) {
+      if (finite(previous.prices?.[key]?.asOf) && entry.asOf < previous.prices[key].asOf) return false
+    }
+    if (previous.publishedAt === candidate.publishedAt && previous.hash !== candidate.hash) return false
+    if (previous.version === candidate.version && previous.hash !== candidate.hash) return false
+  }
+  return true
+}
+
+async function limitedText(response) {
+  const length = Number(response.headers?.get?.('content-length'))
+  if (Number.isFinite(length) && length > MAX_PAYLOAD_BYTES) throw new Error('payload-too-large')
+  if (!response.body?.getReader) {
+    const text = await response.text()
+    if (Buffer.byteLength(text, 'utf8') > MAX_PAYLOAD_BYTES) throw new Error('payload-too-large')
+    return text
+  }
+  const reader = response.body.getReader()
+  const decoder = new TextDecoder()
+  let size = 0
+  let text = ''
+  try {
+    for (;;) {
+      const chunk = await reader.read()
+      if (chunk.done) return text + decoder.decode()
+      size += chunk.value.byteLength
+      if (size > MAX_PAYLOAD_BYTES) throw new Error('payload-too-large')
+      text += decoder.decode(chunk.value, { stream: true })
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {})
+    throw error
+  } finally { reader.releaseLock() }
+}
+
+function publicFetch(fetchImpl) {
+  return async (input, options = {}) => {
+    const endpoint = publicUrl(String(input))
+    const response = await fetchImpl(endpoint, {
+      method: 'GET', headers: { accept: 'application/json,text/csv,text/html' },
+      credentials: 'omit', redirect: 'error', signal: options.signal,
+    })
+    if (!response?.ok || response.redirected) throw new Error('public-fetch-failed')
+    if (response.url && publicUrl(response.url) !== endpoint) throw new Error('public-fetch-redirected')
+    return { ok: true, status: response.status, headers: response.headers,
+      text: () => limitedText(response) }
+  }
+}
+
+async function withTimeout(run) {
+  const controller = new AbortController()
+  let timer
+  let rejectTimeout
+  const timeout = new Promise((_, reject) => { rejectTimeout = reject })
+  timer = setTimeout(() => { controller.abort(); rejectTimeout(new Error('refresh-timeout')) }, TIMEOUT_MS)
+  try { return await Promise.race([run(controller.signal), timeout]) }
+  finally { clearTimeout(timer) }
+}
+
+function due(data, kind, endpoint, ttlMs, at, force) {
+  const status = data.status?.[kind]
+  if (force || status?.endpoint !== endpoint || !finite(status?.lastAttemptAt)) return true
+  const delay = status.error ? Math.min(ttlMs, 300_000) : ttlMs
+  return at - status.lastAttemptAt >= delay
+}
+
+/**
+ * Store API: read() -> state, update(change) -> change's return value; change
+ * mutates the fresh state under the caller's interprocess/atomic write lock.
+ */
+export function createDynamicDataRefresher({ store, fetchImpl = globalThis.fetch, now = Date.now,
+  fetchBenchmark = fetchLiveBenchSnapshot } = {}) {
+  if (typeof store?.read !== 'function' || typeof store?.update !== 'function') throw new Error('dynamic-data-store-required')
+  const flights = new Map()
+  const refresh = async (options = {}) => {
+    if (options.enabled !== true) return emptyData()
+    const ttlMs = finite(options.ttlMs) && options.ttlMs >= 0 ? options.ttlMs : DEFAULT_TTL_MS
+    const liveBenchEndpoint = options.liveBenchEndpoint ?? 'https://livebench.ai'
+    const pricingSnapshotEndpoint = options.pricingSnapshotEndpoint ?? ''
+    // Never reserve, persist, hash or return an unchecked raw endpoint: a bad
+    // URL can contain credentials even though no network request is made.
+    const sources = [['liveBench', liveBenchEndpoint], ['pricing', pricingSnapshotEndpoint]].map(([kind, raw]) => {
+      if (typeof raw === 'string' && raw.trim() === '') return { kind, endpoint: '', disabled: true, invalid: false }
+      try { return { kind, endpoint: publicUrl(raw), disabled: false, invalid: false } }
+      catch { return { kind, endpoint: '', disabled: false, invalid: true } }
+    })
+    const key = stable([sources, ttlMs, options.force === true])
+    if (flights.has(key)) return flights.get(key)
+    const operation = (async () => {
+      const initial = dataOf(await store.read())
+      const requests = sources.filter(source => !source.disabled)
+        .filter(({ kind, endpoint }) => due(initial, kind, endpoint, ttlMs, now(), options.force === true))
+      await Promise.all(requests.map(async ({ kind, endpoint, invalid }) => {
+        const at = now()
+        const requestId = randomUUID()
+        // Reserve before network I/O. Another process or source change wins by
+        // replacing this token; a late completion then cannot mutate its data.
+        const reserved = await store.update(state => {
+          const data = dataOf(state)
+          if (!due(data, kind, endpoint, ttlMs, at, options.force === true)) return false
+          data.status[kind] = { ...(data.status[kind] ?? {}), endpoint,
+            lastAttemptAt: at, requestId, error: '' }
+          data.revision = revisionOf(data)
+          state.dynamicData = data
+          return true
+        })
+        if (!reserved) return
+        let candidate
+        let error = ''
+        try {
+          if (invalid) throw new Error('invalid-public-url')
+          if (typeof fetchImpl !== 'function') throw new Error('fetch-unavailable')
+          const fetchPublic = publicFetch(fetchImpl)
+          candidate = await withTimeout(async signal => {
+            if (kind === 'liveBench') {
+              const payload = await fetchBenchmark({ endpoint, fetchImpl: fetchPublic, timeoutMs: TIMEOUT_MS, strict: true })
+              return benchmarkSnapshot(payload, endpoint, now())
+            }
+            const response = await fetchPublic(endpoint, { signal })
+            return pricingSnapshot(JSON.parse(await response.text()), endpoint, now())
+          })
+        } catch { error = 'refresh-failed' }
+        await store.update(state => {
+          const data = dataOf(state)
+          if (data.status[kind]?.requestId !== requestId) return false
+          if (candidate && !mayPromote(data[kind], candidate)) error = 'snapshot-rollback-rejected'
+          if (candidate && !error) data[kind] = candidate
+          data.status[kind] = { ...data.status[kind], error,
+            ...(candidate && !error ? { lastSuccessAt: now() } : {}) }
+          delete data.status[kind].requestId
+          data.revision = revisionOf(data)
+          state.dynamicData = data
+          return true
+        })
+      }))
+      const result = dataOf(await store.read())
+      // A user clearing a source disables its use immediately, without erasing
+      // recoverable last-good snapshots from disk.
+      for (const { kind, disabled } of sources) {
+        if (disabled) {
+          result[kind] = null
+          result.status[kind] = { disabled: true, endpoint: '', error: '' }
+        }
+      }
+      result.revision = revisionOf(result)
+      return result
+    })()
+    flights.set(key, operation)
+    try { return await operation }
+    finally { if (flights.get(key) === operation) flights.delete(key) }
+  }
+  return { refresh }
+}

package/.dsh-plugin/shared/harness-plan.mjs

@@ -73,7 +73,7 @@ function annotate(channel) {
  */
 export function createPlanFromRoutes(task, availableRoutes, {
   mode = 'single', budgetUsd = 0, installedToolIds = [], runnableToolIds = [],
-  pricing = {}, liveBench = null, cacheReadRatio = 0, cacheWriteRatio = 0,
+  pricing = {}, liveBench = null, liveBenchError = '', dataVersions = null, learning = null, cacheReadRatio = 0, cacheWriteRatio = 0,
   directProvider = '', directModel = '', preset = 'balanced', loggedOutToolIds = [],
 } = {}) {
   const taskText = clean(task)
@@ -107,6 +107,9 @@ export function createPlanFromRoutes(task, availableRoutes, {
     budgetUsd: Math.max(0, Number.isFinite(budgetUsd) ? budgetUsd : 0),
     pricing,
     liveBench,
+    liveBenchError,
+    dataVersions,
+    learning,
     cacheReadRatio,
     cacheWriteRatio,
     preset,
@@ -126,7 +129,7 @@ export function createPlanFromRoutes(task, availableRoutes, {
       ? '部分路线尚未配置该供应商的美元输入/输出单价，无法计算可靠的总费用与节省比例；请在模型价格设置中补齐。'
       : '费用按已提供的美元单价和估计 token 数计算，不是供应商账单，也不是硬性支出上限。',
     qualityNotice: plan.optimization.qualityEvidenceComplete
-      ? '模型质量使用已提供评分或基准数据估计，仍需实际任务验证。'
+      ? '模型质量使用已提供评分或基准数据估计；分数与门槛不是答对概率，也不保证实际质量，仍需独立任务验证。'
       : '部分模型质量缺少可核验评分；目录启发式只供选择参考，质量门槛和节省比例无法保证。',
     modalityNotice: needsImage
       ? plan.unassignableTasks.length > 0

package/.dsh-plugin/shared/livebench.mjs

@@ -23,7 +23,7 @@ const TASK_ALIASES = Object.freeze({
 const CATEGORY_TO_TASK = Object.freeze({
   reasoning: 'reasoning',
   coding: 'code',
-  'agentic coding': 'code',
+  // Agentic Coding is a different task family, not silently a Coding score.
   mathematics: 'math',
   'data analysis': 'research',
   language: 'writing',
@@ -38,10 +38,12 @@ function normalized(value) {
   return String(value ?? '').toLowerCase().replace(/[^a-z0-9]+/g, '')
 }
 
-function asScore(value) {
+function asScore(value, scale) {
+  if (value === null || value === undefined || String(value).trim() === '') return undefined
   const number = Number(value)
   if (!Number.isFinite(number)) return undefined
-  return clamp(number > 1 ? number / 100 : number)
+  if (number < 0 || number > (scale ?? 100)) return undefined
+  return scale === undefined ? (number > 1 ? number / 100 : number) : number / scale
 }
 
 function modelRows(payload) {
@@ -59,13 +61,13 @@ function rowName(row) {
   return String(row.model ?? row.model_name ?? row.name ?? row.id ?? row.slug ?? '')
 }
 
-function rowScores(row) {
+function rowScores(row, scale) {
   const source = row?.scores ?? row?.categories ?? row?.benchmark ?? row
   const scores = {}
   if (source === null || typeof source !== 'object') return scores
   for (const [task, aliases] of Object.entries(TASK_ALIASES)) {
     for (const alias of aliases) {
-      const score = asScore(source[alias])
+      const score = asScore(source[alias], scale)
       if (score !== undefined) {
         scores[task] = score
         break
@@ -77,22 +79,27 @@ function rowScores(row) {
 
 /** Normalize a provider response into `{ models: Record<normalizedId, row> }`. */
 export function normalizeLiveBenchPayload(payload, fetchedAt = Date.now(), source = 'livebench') {
+  const scale = payload?.scoreScale === 1 || payload?.scoreScale === 100 ? payload.scoreScale : undefined
   const models = {}
   for (const row of modelRows(payload)) {
     const id = normalized(rowName(row))
     if (id === '') continue
-    const scores = rowScores(row)
+    const scores = rowScores(row, scale)
     const values = Object.values(scores)
-    const overall = asScore(row?.overall ?? row?.score ?? row?.livebench_score)
+    const suppliedOverall = asScore(row?.overall ?? row?.score ?? row?.livebench_score, scale)
+    const overall = suppliedOverall
       ?? (values.length > 0 ? values.reduce((sum, value) => sum + value, 0) / values.length : undefined)
     if (overall === undefined) continue
+    if (models[id]) throw new Error('LiveBench model identifiers collide after normalization')
     models[id] = {
+      model: rowName(row),
       overall: Number(clamp(overall).toFixed(4)),
+      overallSource: suppliedOverall !== undefined && row?.overallSource !== 'derived' ? 'explicit' : 'derived',
       scores,
       rank: Number.isFinite(Number(row?.rank)) ? Number(row.rank) : undefined,
     }
   }
-  return { source, fetchedAt, models }
+  return { source, fetchedAt, models, ...(payload?.publishedAt === undefined ? {} : { publishedAt: payload.publishedAt }) }
 }
 
 /** Parse a small RFC-4180-compatible CSV without adding a runtime dependency. */
@@ -134,13 +141,22 @@ export function parseCsv(text) {
   return rows.slice(1).map(cells => Object.fromEntries(headers.map((header, index) => [header, cells[index] ?? ''])))
 }
 
-function mean(values) {
-  const numbers = values.map(asScore).filter(value => value !== undefined)
+function mean(values, percent = false) {
+  const numbers = values.map(value => percent
+    ? (String(value ?? '').trim() !== '' && Number.isFinite(Number(value)) && Number(value) >= 0 && Number(value) <= 100 ? Number(value) / 100 : undefined)
+    : asScore(value)).filter(value => value !== undefined)
   return numbers.length === 0 ? undefined : numbers.reduce((sum, value) => sum + value, 0) / numbers.length
 }
 
-function officialCsvPayload(csv, categories = {}) {
+function officialCsvPayload(csv, categories = {}, percent = false, strict = false) {
   const rows = parseCsv(csv)
+  if (strict) for (const row of rows) {
+    if (!row.model) throw new Error('LiveBench row has no model')
+    for (const [column, value] of Object.entries(row)) {
+      if (column === 'model' || String(value).trim() === '') continue
+      if (!Number.isFinite(Number(value)) || Number(value) < 0 || Number(value) > 100) throw new Error('LiveBench CSV score is outside 0..100')
+    }
+  }
   const categoryColumns = new Map()
   for (const [label, columns] of Object.entries(categories ?? {})) {
     const task = CATEGORY_TO_TASK[String(label).trim().toLowerCase()]
@@ -149,16 +165,18 @@ function officialCsvPayload(csv, categories = {}) {
   const models = rows.map(row => {
     const scores = {}
     for (const [task, columns] of categoryColumns.entries()) {
-      const score = mean(columns.map(column => row[column]))
+      const score = mean(columns.map(column => row[column]), percent)
       if (score !== undefined) scores[task] = score
     }
     // A mirror may already provide normalized task columns, so preserve them.
     for (const [task, aliases] of Object.entries(TASK_ALIASES)) {
       if (scores[task] !== undefined) continue
-      const score = mean(aliases.map(alias => row[alias]))
+      const score = mean(aliases.map(alias => row[alias]), percent)
       if (score !== undefined) scores[task] = score
     }
-    return { model: row.model, scores, overall: mean(Object.values(row).slice(1)) }
+    const suppliedOverall = mean([row.overall ?? row.score ?? row.livebench_score], percent)
+    return { model: row.model, scores, overall: suppliedOverall ?? mean(Object.values(row).slice(1), percent),
+      overallSource: suppliedOverall === undefined ? 'derived' : 'explicit' }
   })
   return { models }
 }
@@ -194,7 +212,7 @@ async function fetchWithTimeout(fetchImpl, url, signal) {
   return response
 }
 
-async function officialSnapshot({ endpoint, fetchImpl, signal, fetchedAt }) {
+async function officialSnapshot({ endpoint, fetchImpl, signal, fetchedAt, strict }) {
   const base = new URL(endpoint).origin
   let releases = [DEFAULT_RELEASE]
   try {
@@ -219,7 +237,7 @@ async function officialSnapshot({ endpoint, fetchImpl, signal, fetchedAt }) {
       const categoryResponse = await fetchWithTimeout(fetchImpl, absoluteUrl(base, `categories_${token}.json`), signal)
       const table = (await readResponse(tableResponse)).text
       const categories = JSON.parse((await readResponse(categoryResponse)).text)
-      return normalizeLiveBenchPayload(officialCsvPayload(table, categories), fetchedAt, `livebench:${release}`)
+      return normalizeLiveBenchPayload(officialCsvPayload(table, categories, true, strict), fetchedAt, `livebench:${release}`)
     } catch (error) {
       lastError = error
     }
@@ -235,6 +253,7 @@ export async function fetchLiveBenchSnapshot({
   endpoint = 'https://livebench.ai',
   fetchImpl = globalThis.fetch,
   timeoutMs = 8000,
+  strict = false,
 } = {}) {
   if (typeof fetchImpl !== 'function') throw new Error('fetch is unavailable')
   const controller = new AbortController()
@@ -245,14 +264,29 @@ export async function fetchLiveBenchSnapshot({
     const parsed = new URL(rawEndpoint)
     if ((parsed.hostname === 'livebench.ai' || parsed.hostname === 'www.livebench.ai')
       && (parsed.pathname === '' || parsed.pathname === '/')) {
-      return await officialSnapshot({ endpoint: parsed.toString(), fetchImpl, signal: controller.signal, fetchedAt })
+      return await officialSnapshot({ endpoint: parsed.toString(), fetchImpl, signal: controller.signal, fetchedAt, strict })
     }
     const url = parsed.toString().replace('{release}', DEFAULT_RELEASE)
     const response = await fetchWithTimeout(fetchImpl, url, controller.signal)
     const { type, text } = await readResponse(response)
     const isCsv = type.includes('csv') || /\.csv(?:$|\?)/i.test(parsed.pathname)
-    if (isCsv) return normalizeLiveBenchPayload(officialCsvPayload(text), fetchedAt, 'livebench-csv-mirror')
-    return normalizeLiveBenchPayload(JSON.parse(text), fetchedAt, 'livebench-json-mirror')
+    if (isCsv) {
+      if (strict) throw new Error('Dynamic custom LiveBench feeds require JSON with explicit scoreScale')
+      return normalizeLiveBenchPayload(officialCsvPayload(text), fetchedAt, 'livebench-csv-mirror')
+    }
+    const payload = JSON.parse(text)
+    if (strict) {
+      if (![1, 100].includes(payload?.scoreScale) || modelRows(payload).length === 0) throw new Error('LiveBench feed needs explicit scoreScale and nonempty models')
+      for (const row of modelRows(payload)) {
+        if (!rowName(row) || rowName(row).trim() !== rowName(row)) throw new Error('LiveBench model identifier is invalid')
+        const scores = row?.scores ?? row?.categories ?? row?.benchmark ?? row
+        const values = [row.overall ?? row.score ?? row.livebench_score,
+          ...Object.values(TASK_ALIASES).flatMap(aliases => aliases.map(alias => scores?.[alias]))]
+          .filter(value => value !== undefined && value !== null && String(value).trim() !== '')
+        if (!values.length || values.some(value => typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > payload.scoreScale)) throw new Error('LiveBench score is invalid for declared scale')
+      }
+    }
+    return normalizeLiveBenchPayload(payload, fetchedAt, 'livebench-json-mirror')
   } finally {
     clearTimeout(timer)
   }
@@ -260,5 +294,8 @@ export async function fetchLiveBenchSnapshot({
 
 /** Return a model's benchmark row using the same normalization as the adapter. */
 export function liveBenchRow(snapshot, model) {
-  return snapshot?.models?.[normalized(model)] ?? null
+  const row = snapshot?.models?.[normalized(model)] ?? null
+  // Dynamic snapshots require explicit model identity. Old programmatic
+  // snapshots retain their previous normalization-only compatibility.
+  return snapshot?.exactModelMatch === true && row?.model !== model ? null : row
 }

package/.dsh-plugin/shared/model-profiles.mjs

@@ -22,7 +22,7 @@ function nonnegative(value, label) {
 function normalizeProfile(entry, index) {
   const label = `第 ${index + 1} 个模型`
   if (!entry || typeof entry !== 'object' || Array.isArray(entry)) throw new Error(`${label} 必须是对象`)
-  const allowed = new Set(['provider', 'model', 'quality', 'pricing', 'specialties', 'cliModel', 'execution', 'billing', 'subscription', 'apiRoute'])
+  const allowed = new Set(['provider', 'model', 'benchmarkModel', 'quality', 'pricing', 'specialties', 'cliModel', 'execution', 'billing', 'subscription', 'apiRoute'])
   const unknown = Object.keys(entry).find(key => !allowed.has(key))
   if (unknown) throw new Error(`${label} 含不支持的字段 ${unknown}；不要在这里填写密钥或命令`)
   const provider = id(entry.provider)
@@ -31,6 +31,11 @@ function normalizeProfile(entry, index) {
     throw new Error(`${label} 需要模型目录中的准确 provider 和 model`)
   }
   const profile = { provider, model }
+  if (entry.benchmarkModel !== undefined) {
+    const benchmarkModel = id(entry.benchmarkModel)
+    if (!benchmarkModel || benchmarkModel.length > 240 || /[\u0000-\u001f]/u.test(benchmarkModel)) throw new Error(`${label} 的 benchmarkModel 需要准确的基准模型名称`)
+    profile.benchmarkModel = benchmarkModel
+  }
   if (entry.quality !== undefined) {
     const value = nonnegative(entry.quality, `${label} 的 quality`)
     if (value > 100) throw new Error(`${label} 的 quality 应在 0 到 100 之间`)
@@ -129,6 +134,7 @@ export function applyModelProfiles(routes, profiles) {
     if (!profile) return route
     return {
       ...route,
+      ...(profile.benchmarkModel === undefined ? {} : { benchmarkModel: profile.benchmarkModel }),
       ...(profile.quality === undefined ? {} : { quality: profile.quality, qualitySource: 'user' }),
       ...(profile.pricing === undefined ? {} : { pricing: { ...profile.pricing }, pricingSource: 'user' }),
       ...(profile.specialties === undefined ? {} : { specialties: [...profile.specialties] }),

package/.dsh-plugin/shared/official-tools-remote.mjs

@@ -78,7 +78,9 @@ const optionalRouteText = (value, subject) => {
 const rateRequestCodec = strictCodec(`${OFFICIAL_TOOLS_REMOTE_PACKAGE}#RateRequest`, value => {
   const request = plainObject(value, 'rate request')
   if (!['up', 'down', 'clear'].includes(request.rating)) throw new TypeError('rating must be up, down or clear')
-  return { runId: idText(request.runId, 'runId'), packageId: idText(request.packageId, 'packageId'), rating: request.rating }
+  if (request.expectedFinishedAt !== undefined && (!Number.isFinite(request.expectedFinishedAt) || request.expectedFinishedAt < 0)) throw new TypeError('expectedFinishedAt must be a non-negative timestamp')
+  return { runId: idText(request.runId, 'runId'), packageId: idText(request.packageId, 'packageId'), rating: request.rating,
+    ...(request.expectedFinishedAt === undefined ? {} : { expectedFinishedAt: request.expectedFinishedAt }) }
 })
 
 const rerunRequestCodec = strictCodec(`${OFFICIAL_TOOLS_REMOTE_PACKAGE}#RerunRequest`, value => {

package/.dsh-plugin/shared/router-state.mjs

@@ -39,7 +39,7 @@ const LOCK_STALE_MS = 15_000
 const LOCK_TIMEOUT_MS = 10_000
 
 function emptyState() {
-  return { version: STATE_VERSION, onboarding: { completedAt: null }, health: null, quota: {}, authFailures: {}, runs: [], archivedSpending: sanitizeArchivedSpending(), notices: [], terminalSessions: [] }
+  return { version: STATE_VERSION, onboarding: { completedAt: null }, health: null, quota: {}, authFailures: {}, runs: [], dynamicData: { liveBench: null, pricing: null, status: {}, revision: '' }, archivedSpending: sanitizeArchivedSpending(), notices: [], terminalSessions: [] }
 }
 
 function sanitizeNotices(value) {
@@ -65,6 +65,7 @@ function sanitize(value, maxRuns) {
     authFailures: Object.fromEntries(Object.entries(value.authFailures && typeof value.authFailures === 'object' && !Array.isArray(value.authFailures) ? value.authFailures : {})
       .filter(([, entry]) => Number.isFinite(entry?.at))),
     runs: Array.isArray(value.runs) ? value.runs.filter(run => run && typeof run.id === 'string') : [],
+    dynamicData: value.dynamicData && typeof value.dynamicData === 'object' && !Array.isArray(value.dynamicData) ? value.dynamicData : { liveBench: null, pricing: null, status: {}, revision: '' },
     archivedSpending: sanitizeArchivedSpending(value.archivedSpending),
     notices: sanitizeNotices(value.notices),
     terminalSessions: sanitizeTerminalSessions(value.terminalSessions),