@ljwei-stak/dsh-model-router 0.13.0

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

@@ -0,0 +1,104 @@
+/** Host receiver for the official desktop's typed one-click installer RPC. */
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol'
+import { getOfficialTool } from './shared/official-tool-registry.mjs'
+import { officialToolExecutionCapabilities, officialToolReadiness } from './shared/official-tool-executor.mjs'
+import {
+  defaultRunner,
+  cancelInstall,
+  ensureNpmPrefixOnPath,
+  installStatus,
+  probeAllTools,
+  probeToolWith,
+  startInstall,
+} from './shared/official-tools-runtime.mjs'
+import {
+  OFFICIAL_TOOLS_HOST_TYPERT,
+  OFFICIAL_TOOLS_REMOTE_NAMESPACE,
+} from './shared/official-tools-remote.mjs'
+
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error)
+}
+
+const unavailable = () => { throw new Error('模型路由工作台服务尚未加载。') }
+
+/** Wrap a Host operation so the client always receives a plain object. */
+async function settled(operation) {
+  try { return { ok: true, value: await operation() } }
+  catch (error) { return { ok: false, error: errorText(error) } }
+}
+
+export class OfficialToolsRemoteService extends TypertRemoteService {
+  constructor(ctx, services = {}) {
+    super(ctx, OFFICIAL_TOOLS_REMOTE_NAMESPACE)
+    this.services = services
+  }
+
+  /** 开箱体检: installed, version and login state per registry tool. */
+  health(fresh) { return settled(() => (this.services.health ?? unavailable)(fresh === true)) }
+
+  completeOnboarding() { return settled(() => (this.services.completeOnboarding ?? unavailable)()) }
+
+  /** Recent runs, spending, budget status and learned route biases. */
+  ledger() { return settled(() => (this.services.ledger ?? unavailable)()) }
+
+  rateResult(request) { return settled(() => (this.services.rate ?? unavailable)(request)) }
+
+  /** Retry one recorded step (optionally reassigned); unfinished downstream steps follow. */
+  rerunStep(request) { return settled(() => (this.services.rerun ?? unavailable)(request)) }
+
+  boundaries() { return settled(() => (this.services.boundaries ?? unavailable)()) }
+
+  /** Plan, cost estimate and the reasons that need the user's confirmation; runs nothing. */
+  previewRun(request) { return settled(() => (this.services.previewRun ?? unavailable)(request)) }
+
+  /** Execute a previewed run once every listed reason was confirmed. */
+  startRun(request) { return settled(() => (this.services.startRun ?? unavailable)(request)) }
+
+  /** Re-probe the local fixed registry; the caller cannot supply a command. */
+  async list() {
+    const tools = await probeAllTools({ fresh: true })
+    const executionReadiness = await Promise.all(tools.map(tool => tool.installed
+      ? officialToolReadiness(tool.id)
+      : Promise.resolve({ id: tool.id, ready: false, reason: 'CLI 尚未安装或版本检测失败。' })))
+    return { tools, executionCapabilities: officialToolExecutionCapabilities(), executionReadiness }
+  }
+
+  /** Start one serialized fixed-registry install; return immediately for UI polling. */
+  async installTool(toolId) {
+    try {
+      await ensureNpmPrefixOnPath()
+      return { accepted: true, job: startInstall(toolId) }
+    } catch (error) {
+      return { accepted: false, error: errorText(error) }
+    }
+  }
+
+  /** Stop a queued or running npm install, retaining its bounded job log. */
+  cancel(toolId) {
+    try {
+      return { accepted: true, job: cancelInstall(toolId) }
+    } catch (error) {
+      return { accepted: false, error: errorText(error) }
+    }
+  }
+
+  /** Read bounded progress; after command success, verify that the CLI resolves. */
+  async status(toolId) {
+    const job = installStatus(toolId)
+    if (job?.status !== 'succeeded') return { job }
+    await ensureNpmPrefixOnPath()
+    const tool = getOfficialTool(toolId)
+    const postInstallProbe = tool === null ? null
+      : await probeToolWith(tool, defaultRunner, { cacheMs: 0 })
+    return { job, postInstallProbe }
+  }
+
+
+}
+
+/** Registration follows the Host plugin fiber; unload withdraws all endpoints. */
+export function registerOfficialToolsRemote(ctx, services = {}) {
+  new OfficialToolsRemoteService(ctx, services)
+  ctx.effect(() => ctx.typert.register(OFFICIAL_TOOLS_HOST_TYPERT), 'model-router-galgame: official tools remote descriptors')
+}

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

@@ -0,0 +1,179 @@
+import { buildPlan, detectTaskTypes } from './router.mjs'
+import { OFFICIAL_TOOLS, toolForProvider } from './official-tool-registry.mjs'
+import { normalizeExecutionPreference } from './model-profiles.mjs'
+
+const clean = value => typeof value === 'string' ? value.trim() : ''
+
+const HEADLESS_TOOL_IDS = new Set(['claude-code', 'codex', 'gemini'])
+
+/**
+ * Resolve the intended execution channel for one provider without touching
+ * the filesystem: `official-cli` when the provider maps to a registry tool
+ * that the caller reports as installed, `harness-llm` otherwise. The probe
+ * snapshot comes from the Host caller, which owns the real process boundary.
+ */
+export function channelForProvider(provider, installedToolIds = [], runnableToolIds = [], route = null, loggedOutToolIds = []) {
+  const preference = normalizeExecutionPreference(route?.execution)
+  const tool = toolForProvider(provider)
+  if (preference === 'api') {
+    return {
+      kind: 'harness-llm', preference,
+      ...(tool ? { tool: tool.id, label: tool.label } : {}),
+      detail: '该模型配置为只使用模型目录 API。',
+    }
+  }
+  if (!tool || tool.unsupported) {
+    return { kind: 'harness-llm', preference, detail: '通过官方模型目录 API 调用。' }
+  }
+  const installed = Array.isArray(installedToolIds) && installedToolIds.includes(tool.id)
+  if (installed && Array.isArray(loggedOutToolIds) && loggedOutToolIds.includes(tool.id)) {
+    return {
+      kind: 'harness-llm', preference, tool: tool.id, label: tool.label, loginRequired: true,
+      detail: `${tool.label} 已安装但未登录（开箱体检结果）；实际调用直接使用模型目录 API，不等待 CLI 失败。`,
+    }
+  }
+  const runnable = installed && Array.isArray(runnableToolIds) && runnableToolIds.includes(tool.id)
+  const headless = installed && HEADLESS_TOOL_IDS.has(tool.id)
+  if (runnable || headless) {
+    return {
+      kind: 'official-cli', preference, tool: tool.id, label: tool.label,
+      detail: tool.id === 'zcode'
+        ? 'ZCode 已安装，插件可调用其官方编程代理；3.14.3 的 CLI 使用自身配置的默认模型，不能保证与 Harness 建议模型一致。'
+        : headless && !runnable
+          ? `${tool.label} 已安装。分配到该模型的任务会先走官方无界面命令；命令缺失或失败时回退模型目录 API。`
+          : `${tool.label} 已安装，插件可托管调用其官方 CLI；Harness 模型目录与厂商 CLI 名称可能不同，团队无法确认映射时使用 CLI 默认模型，实际模型仍须核对运行记录。`,
+    }
+  }
+  return {
+    kind: 'harness-llm',
+    preference,
+    tool: tool.id,
+    label: tool.label,
+    detail: installed
+      ? `${tool.label} 已安装，但当前平台缺少经核验的托管执行适配器；实际调用使用官方模型目录 API。`
+      : `${tool.label} 未安装；实际调用使用官方模型目录 API。可在工作台一键安装，或运行 /tools install ${tool.id}。`,
+  }
+}
+
+function annotate(channel) {
+  return {
+    executionChannel: channel.kind,
+    ...channel.tool ? { channelTool: channel.tool } : {},
+    ...channel.label ? { channelLabel: channel.label } : {},
+    ...channel.preference ? { executionPreference: channel.preference } : {},
+    ...channel.loginRequired ? { loginRequired: true } : {},
+    channelDetail: channel.detail,
+  }
+}
+
+/**
+ * The same deterministic planning projection is used by the Host tool and
+ * by the Desktop panel. Model discovery stays on the official side of each
+ * runtime and only the public provider/model directory crosses this boundary.
+ */
+export function createPlanFromRoutes(task, availableRoutes, {
+  mode = 'single', budgetUsd = 0, installedToolIds = [], runnableToolIds = [],
+  pricing = {}, liveBench = null, cacheReadRatio = 0, cacheWriteRatio = 0,
+  directProvider = '', directModel = '', preset = 'balanced', loggedOutToolIds = [],
+} = {}) {
+  const taskText = clean(task)
+  if (!taskText) throw new Error('task must contain text')
+  const requestedDirect = mode === 'direct' || clean(directProvider) !== '' || clean(directModel) !== ''
+  const selectedMode = mode === 'team' ? 'team' : 'single'
+  let routes = Array.isArray(availableRoutes) ? availableRoutes : []
+  let directRoute = null
+  if (requestedDirect) {
+    const provider = clean(directProvider)
+    const model = clean(directModel)
+    if (!provider || !model) throw new Error('指定单一模型需要同时提供 provider 和 model')
+    const match = routes.filter(route => route.provider === provider && route.model === model)
+    if (match.length !== 1) throw new Error(`指定模型 ${provider}/${model} 不在当前模型目录中`)
+    routes = match
+    directRoute = { provider, model }
+  }
+  const installedIds = Array.isArray(installedToolIds) ? installedToolIds.filter(Boolean) : []
+  const channelCache = new Map()
+  const channelOf = (provider, model) => {
+    const route = routes.find(item => item.provider === provider && item.model === model)
+    const key = `${String(provider ?? '')}\0${String(model ?? '')}\0${route?.execution ?? ''}`
+    if (!channelCache.has(key)) channelCache.set(key, channelForProvider(provider, installedIds, runnableToolIds, route, loggedOutToolIds))
+    return channelCache.get(key)
+  }
+  const needsImage = detectTaskTypes(taskText).includes('vision')
+  const plan = buildPlan({
+    text: taskText,
+    available: routes,
+    mode: directRoute ? 'single' : selectedMode,
+    budgetUsd: Math.max(0, Number.isFinite(budgetUsd) ? budgetUsd : 0),
+    pricing,
+    liveBench,
+    cacheReadRatio,
+    cacheWriteRatio,
+    preset,
+  })
+  const selectedChannel = plan.selected ? channelOf(plan.selected.provider, plan.selected.model) : null
+  return {
+    ...plan,
+    mode: directRoute ? 'direct' : plan.mode,
+    routingBypassed: directRoute !== null,
+    directRoute,
+    ...(directRoute ? { reason: `已指定 ${directRoute.provider}/${directRoute.model}，不与其他已配置模型比较。复杂度仍按任务文本估计。` } : {}),
+    contractVersion: 2,
+    availableRoutes: routes,
+    ...(selectedChannel ? annotate(selectedChannel) : {}),
+    availabilityNotice: '模型目录列出的路线尚未验证当前凭据和网络；实际可用性以官方适配器调用结果为准。',
+    pricingNotice: plan.estimatedCost === null
+      ? '部分路线尚未配置该供应商的美元输入/输出单价，无法计算可靠的总费用与节省比例；请在模型价格设置中补齐。'
+      : '费用按已提供的美元单价和估计 token 数计算，不是供应商账单，也不是硬性支出上限。',
+    qualityNotice: plan.optimization.qualityEvidenceComplete
+      ? '模型质量使用已提供评分或基准数据估计，仍需实际任务验证。'
+      : '部分模型质量缺少可核验评分；目录启发式只供选择参考，质量门槛和节省比例无法保证。',
+    modalityNotice: needsImage
+      ? plan.unassignableTasks.length > 0
+        ? '图像工作包没有可确认支持图像输入的路线，当前计划无法完整分配；请在官方模型目录配置支持图像的模型。'
+        : routes.some(route => !Array.isArray(route.inputModalities) || route.inputModalities.length === 0)
+          ? '图像工作包只分给已声明图像能力或未声明输入能力的模型；未声明能力的模型仍需实际验证。其他文本工作包可继续使用经济型文本模型。'
+          : '图像工作包只分给明确支持图像输入的模型；其他文本工作包可继续使用经济型文本模型。'
+      : null,
+    toolNotice: '执行渠道按官方工具注册表和已核验适配器标注：official-cli 表示该厂商官方 CLI 已安装且可托管执行；harness-llm 表示通过官方模型目录调用。可在工作台查看安装与执行支持状态。',
+    team: {
+      requested: selectedMode === 'team',
+      recommended: selectedMode === 'team' && plan.complexity.band === 'complex' && plan.subtasks.length > 1,
+      handoff: '可在官方会话调用 model_router_team_execute 托管执行当前平台支持的官方 CLI 工作包；官方 Agent Teams 可协作管理任务，但成员模型由宿主配置，不能直接按本计划逐个切换。',
+      workPackages: plan.subtasks.map((item, index) => ({
+        id: item.id,
+        name: item.name,
+        ...(item.objective ? { objective: item.objective } : {}),
+        type: item.type,
+        purpose: item.purpose,
+        difficulty: item.difficulty,
+        qualitySource: item.qualitySource,
+        pricingSource: item.pricingSource,
+        dependsOn: item.dependsOn,
+        recommendedProvider: item.recommendedProvider,
+        recommendedModel: item.recommended,
+        estimatedCost: plan.costBreakdown[index]?.estimatedCost ?? null,
+        ...item.recommendedReasoningEffort ? { recommendedReasoningEffort: item.recommendedReasoningEffort } : {},
+        ...annotate(channelOf(item.recommendedProvider, item.recommended)),
+        verificationChecklist: item.purpose === 'synthesis'
+          ? ['核对各工作包交付物与依赖', '记录冲突、未解决事项和最终验收结果']
+          : item.type === 'code'
+            ? ['说明改动文件与接口', '运行与改动相关的验证并记录结果', '列出尚未完成的边界情况']
+            : item.type === 'research'
+              ? ['列出来源、日期和可核对的结论', '标出推断与不确定事项']
+              : ['列出交付内容和验收依据', '标出未完成事项'],
+      })),
+    },
+  }
+}
+
+/** Registry summary for tools that a plan or panel may want to display. */
+export function officialToolSummaries() {
+  return OFFICIAL_TOOLS.map(tool => ({
+    id: tool.id,
+    label: tool.label,
+    vendor: tool.vendor,
+    purpose: tool.purpose,
+    unsupported: tool.unsupported === true,
+  }))
+}

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

@@ -0,0 +1,264 @@
+/**
+ * LiveBench snapshot adapter.
+ *
+ * The public LiveBench site currently publishes versioned CSV/JSON assets
+ * rather than a stable JSON API. This adapter understands both that official
+ * layout and a user-supplied JSON/CSV mirror. A refresh failure is non-fatal:
+ * the Host keeps the last successful snapshot and the router exposes the
+ * fallback state in its audit record.
+ */
+
+const DEFAULT_RELEASE = '2026-06-25'
+const TASK_ALIASES = Object.freeze({
+  reasoning: ['reasoning', 'reasoning_score', 'hard_reasoning'],
+  code: ['code', 'coding', 'coding_score'],
+  math: ['math', 'mathematics', 'math_score'],
+  research: ['research', 'retrieval', 'knowledge', 'data_analysis'],
+  writing: ['writing', 'creative_writing', 'language'],
+  vision: ['vision', 'multimodal', 'visual'],
+  summarization: ['summarization', 'summary', 'if'],
+  classification: ['classification', 'instruction_following'],
+})
+
+const CATEGORY_TO_TASK = Object.freeze({
+  reasoning: 'reasoning',
+  coding: 'code',
+  'agentic coding': 'code',
+  mathematics: 'math',
+  'data analysis': 'research',
+  language: 'writing',
+  if: 'summarization',
+  vision: 'vision',
+  multimodal: 'vision',
+})
+
+const clamp = (value, min = 0, max = 1) => Math.max(min, Math.min(max, value))
+
+function normalized(value) {
+  return String(value ?? '').toLowerCase().replace(/[^a-z0-9]+/g, '')
+}
+
+function asScore(value) {
+  const number = Number(value)
+  if (!Number.isFinite(number)) return undefined
+  return clamp(number > 1 ? number / 100 : number)
+}
+
+function modelRows(payload) {
+  if (Array.isArray(payload)) return payload
+  if (payload !== null && typeof payload === 'object') {
+    for (const key of ['models', 'data', 'leaderboard', 'results', 'entries', 'rows']) {
+      if (Array.isArray(payload[key])) return payload[key]
+    }
+  }
+  return []
+}
+
+function rowName(row) {
+  if (row === null || typeof row !== 'object') return ''
+  return String(row.model ?? row.model_name ?? row.name ?? row.id ?? row.slug ?? '')
+}
+
+function rowScores(row) {
+  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])
+      if (score !== undefined) {
+        scores[task] = score
+        break
+      }
+    }
+  }
+  return scores
+}
+
+/** Normalize a provider response into `{ models: Record<normalizedId, row> }`. */
+export function normalizeLiveBenchPayload(payload, fetchedAt = Date.now(), source = 'livebench') {
+  const models = {}
+  for (const row of modelRows(payload)) {
+    const id = normalized(rowName(row))
+    if (id === '') continue
+    const scores = rowScores(row)
+    const values = Object.values(scores)
+    const overall = asScore(row?.overall ?? row?.score ?? row?.livebench_score)
+      ?? (values.length > 0 ? values.reduce((sum, value) => sum + value, 0) / values.length : undefined)
+    if (overall === undefined) continue
+    models[id] = {
+      overall: Number(clamp(overall).toFixed(4)),
+      scores,
+      rank: Number.isFinite(Number(row?.rank)) ? Number(row.rank) : undefined,
+    }
+  }
+  return { source, fetchedAt, models }
+}
+
+/** Parse a small RFC-4180-compatible CSV without adding a runtime dependency. */
+export function parseCsv(text) {
+  const rows = []
+  let row = []
+  let field = ''
+  let quoted = false
+  const value = String(text ?? '').replace(/^\uFEFF/, '')
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index]
+    if (quoted) {
+      if (char === '"' && value[index + 1] === '"') {
+        field += '"'
+        index += 1
+      } else if (char === '"') {
+        quoted = false
+      } else {
+        field += char
+      }
+    } else if (char === '"') {
+      quoted = true
+    } else if (char === ',') {
+      row.push(field)
+      field = ''
+    } else if (char === '\n') {
+      row.push(field.replace(/\r$/, ''))
+      if (row.some(cell => cell.trim() !== '')) rows.push(row)
+      row = []
+      field = ''
+    } else {
+      field += char
+    }
+  }
+  row.push(field.replace(/\r$/, ''))
+  if (row.some(cell => cell.trim() !== '')) rows.push(row)
+  if (rows.length === 0) return []
+  const headers = rows[0].map(header => header.trim())
+  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)
+  return numbers.length === 0 ? undefined : numbers.reduce((sum, value) => sum + value, 0) / numbers.length
+}
+
+function officialCsvPayload(csv, categories = {}) {
+  const rows = parseCsv(csv)
+  const categoryColumns = new Map()
+  for (const [label, columns] of Object.entries(categories ?? {})) {
+    const task = CATEGORY_TO_TASK[String(label).trim().toLowerCase()]
+    if (task && Array.isArray(columns)) categoryColumns.set(task, columns)
+  }
+  const models = rows.map(row => {
+    const scores = {}
+    for (const [task, columns] of categoryColumns.entries()) {
+      const score = mean(columns.map(column => row[column]))
+      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]))
+      if (score !== undefined) scores[task] = score
+    }
+    return { model: row.model, scores, overall: mean(Object.values(row).slice(1)) }
+  })
+  return { models }
+}
+
+function releaseCandidatesFromText(text) {
+  const source = String(text ?? '')
+  const matches = []
+  // The current bundle has `const pe=["2024-...", ...]`. Restrict parsing to
+  // an actual array assignment so unrelated build timestamps are not treated
+  // as releases.
+  const arrays = source.matchAll(/(?:const|let|var)\s+\w+\s*=\s*\[((?:\s*["']20\d{2}-\d{2}-\d{2}["']\s*,?)+)\]/g)
+  for (const match of arrays) matches.push(...(match[1].match(/20\d{2}-\d{2}-\d{2}/g) ?? []))
+  if (matches.length === 0) matches.push(...(source.match(/20\d{2}-\d{2}-\d{2}/g) ?? []))
+  return [...new Set([...matches, DEFAULT_RELEASE])].sort().reverse()
+}
+
+function absoluteUrl(base, path) {
+  return new URL(path, base.endsWith('/') ? base : `${base}/`).toString()
+}
+
+async function readResponse(response) {
+  const type = String(response.headers?.get?.('content-type') ?? '').toLowerCase()
+  const text = await response.text()
+  return { type, text }
+}
+
+async function fetchWithTimeout(fetchImpl, url, signal) {
+  const response = await fetchImpl(url, {
+    headers: { accept: 'application/json,text/csv,text/html' },
+    signal,
+  })
+  if (!response.ok) throw new Error(`LiveBench returned HTTP ${String(response.status)} for ${url}`)
+  return response
+}
+
+async function officialSnapshot({ endpoint, fetchImpl, signal, fetchedAt }) {
+  const base = new URL(endpoint).origin
+  let releases = [DEFAULT_RELEASE]
+  try {
+    const htmlResponse = await fetchWithTimeout(fetchImpl, base, signal)
+    const html = (await readResponse(htmlResponse)).text
+    const scriptPaths = [...html.matchAll(/<script[^>]+src=["']([^"']+\.js)["']/gi)].map(match => match[1])
+    const scriptPath = scriptPaths.at(-1)
+    if (scriptPath !== undefined) {
+      const scriptResponse = await fetchWithTimeout(fetchImpl, absoluteUrl(base, scriptPath), signal)
+      releases = releaseCandidatesFromText((await readResponse(scriptResponse)).text)
+    } else {
+      releases = releaseCandidatesFromText(html)
+    }
+  } catch {
+    // A CDN may deny HTML/JS while still serving a pinned release asset.
+  }
+  let lastError
+  for (const release of releases) {
+    const token = release.replaceAll('-', '_')
+    try {
+      const tableResponse = await fetchWithTimeout(fetchImpl, absoluteUrl(base, `table_${token}.csv`), signal)
+      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}`)
+    } catch (error) {
+      lastError = error
+    }
+  }
+  throw lastError ?? new Error('LiveBench release assets are unavailable')
+}
+
+/**
+ * Fetch one LiveBench snapshot. The official root automatically discovers the
+ * newest release. A custom endpoint may be JSON, CSV, or a `{release}` URL.
+ */
+export async function fetchLiveBenchSnapshot({
+  endpoint = 'https://livebench.ai',
+  fetchImpl = globalThis.fetch,
+  timeoutMs = 8000,
+} = {}) {
+  if (typeof fetchImpl !== 'function') throw new Error('fetch is unavailable')
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  const fetchedAt = Date.now()
+  try {
+    const rawEndpoint = String(endpoint).trim()
+    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 })
+    }
+    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')
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+/** Return a model's benchmark row using the same normalization as the adapter. */
+export function liveBenchRow(snapshot, model) {
+  return snapshot?.models?.[normalized(model)] ?? null
+}