fix(api): support agentic-only runs in unofficial-run previews (#537)

Agentic-only sweeps never run the collect-results merge job (run-sweep.yml
only triggers it for fixed-seq sweeps), so they upload per-config
bmk_agentic_<config> artifacts with no merged results_bmk. The
/api/unofficial-run route only looked for results_bmk and returned 404,
breaking ?unofficialrun= chart overlays for agentic PRs.

Fall back to downloading every per-config bmk_* artifact (deduped by name,
newest id wins) when results_bmk is absent. The fallback stays off when the
merged artifact exists since it already contains all per-config rows.
Downloads run in bounded batches of 8 to stay clear of GitHub secondary
rate limits.

中文：agentic 专属 sweep 不会触发 collect-results 合并任务（run-sweep.yml
仅为固定序列 sweep 触发），因此只上传按配置拆分的 bmk_agentic_<config>
产物，没有合并的 results_bmk。/api/unofficial-run 路由此前只查找
results_bmk 并返回 404，导致 agentic PR 的 ?unofficialrun= 图表叠加预览
失效。现在当 results_bmk 缺失时回退为逐个下载 bmk_* 产物（按名称去重，
保留最新 id），合并产物存在时不启用回退以避免重复计数；下载以每批 8 个
的有界批次执行，避免触发 GitHub 二级速率限制。

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: cquil11

packages/app/src/app/api/unofficial-run/route.test.ts

@@ -65,6 +65,20 @@ function rawRow(overrides: Record<string, unknown> = {}): Record<string, unknown
   };
 }
 
+/** Minimal valid agentic row: scenario_type triggers the agentic path; `users` → conc. */
+function rawAgenticRow(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    infmax_model_prefix: 'dsv4',
+    hw: 'mi355x-amds',
+    framework: 'vllm',
+    precision: 'fp4',
+    scenario_type: 'agentic-coding',
+    users: 72,
+    tput_per_gpu: 20000,
+    ...overrides,
+  };
+}
+
 function rawEvalRow(overrides: Record<string, unknown> = {}): Record<string, unknown> {
   return {
     hw: 'gb300-nv',
@@ -437,6 +451,158 @@ describe('GET /api/unofficial-run', () => {
     expect(body.evaluations).toEqual([]);
   });
 
+  it('falls back to per-config bmk_* artifacts when results_bmk is missing (agentic-only sweeps)', async () => {
+    // Run metadata
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          id: 777,
+          name: 'agentic-run',
+          head_branch: 'amd/agentx',
+          head_sha: 'ccc',
+          created_at: '2026-07-07T00:00:00Z',
+          html_url: 'http://github.com/run/777',
+          conclusion: 'success',
+          status: 'completed',
+        }),
+    });
+    // Artifacts: no results_bmk — only per-config agentic artifacts (plus the
+    // big sibling `agentic_*` trace blobs the route must NOT download).
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          artifacts: [
+            { name: 'bmk_agentic_dsv4_conc72', id: 30, archive_download_url: 'http://dl-a' },
+            { name: 'bmk_agentic_dsv4_conc56', id: 31, archive_download_url: 'http://dl-b' },
+            { name: 'agentic_dsv4_conc72', id: 32, archive_download_url: 'http://dl-blob' },
+            { name: 'server_logs_dsv4_conc72', id: 33, archive_download_url: 'http://dl-log' },
+          ],
+        }),
+    });
+    // Two per-config downloads (Promise.all order matches artifact order)
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      arrayBuffer: () => Promise.resolve(new ArrayBuffer(8)),
+    });
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      arrayBuffer: () => Promise.resolve(new ArrayBuffer(8)),
+    });
+    mockGetEntries
+      .mockReturnValueOnce([
+        {
+          entryName: 'dsv4_conc72.json',
+          getData: () => Buffer.from(JSON.stringify(rawAgenticRow())),
+        },
+      ])
+      .mockReturnValueOnce([
+        {
+          entryName: 'dsv4_conc56.json',
+          getData: () => Buffer.from(JSON.stringify(rawAgenticRow({ users: 56 }))),
+        },
+      ]);
+
+    const res = await GET(makeRequest('runId=777'));
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.benchmarks).toHaveLength(2);
+    expect(
+      body.benchmarks
+        .map((b: { conc: number }) => b.conc)
+        .toSorted((a: number, b: number) => a - b),
+    ).toEqual([56, 72]);
+    expect(body.benchmarks[0].benchmark_type).toBe('agentic_traces');
+    expect(body.benchmarks[0].hardware).toBe('mi355x');
+    expect(body.benchmarks[0].run_url).toBe('http://github.com/run/777');
+    // Only the two bmk_* artifacts were downloaded: run + artifacts + 2 downloads.
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+  });
+
+  it('does not download per-config bmk_* artifacts when results_bmk exists', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          id: 888,
+          head_branch: 'main',
+          html_url: 'http://github.com/run/888',
+          created_at: '2026-07-07T00:00:00Z',
+        }),
+    });
+    // Merged artifact alongside per-config ones (mixed fixed-seq + agentic
+    // sweep) — the merged artifact already contains the per-config rows.
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          artifacts: [
+            { name: 'results_bmk', id: 40, archive_download_url: 'http://dl-merged' },
+            { name: 'bmk_agentic_dsv4_conc72', id: 41, archive_download_url: 'http://dl-a' },
+          ],
+        }),
+    });
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      arrayBuffer: () => Promise.resolve(new ArrayBuffer(8)),
+    });
+    mockGetEntries.mockReturnValueOnce([
+      {
+        entryName: 'agg_bmk.json',
+        getData: () => Buffer.from(JSON.stringify([rawRow(), rawAgenticRow()])),
+      },
+    ]);
+
+    const res = await GET(makeRequest('runId=888'));
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.benchmarks).toHaveLength(2);
+    // Exactly one download (the merged artifact) — per-config was skipped.
+    expect(mockFetch).toHaveBeenCalledTimes(3);
+  });
+
+  it('keeps only the newest per-config artifact when names repeat', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          id: 999,
+          head_branch: 'feature/agentic',
+          html_url: 'http://github.com/run/999',
+          created_at: '2026-07-07T00:00:00Z',
+        }),
+    });
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          artifacts: [
+            { name: 'bmk_agentic_dsv4_conc72', id: 50, archive_download_url: 'http://dl-old' },
+            { name: 'bmk_agentic_dsv4_conc72', id: 51, archive_download_url: 'http://dl-new' },
+          ],
+        }),
+    });
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      arrayBuffer: () => Promise.resolve(new ArrayBuffer(8)),
+    });
+    mockGetEntries.mockReturnValueOnce([
+      {
+        entryName: 'dsv4_conc72.json',
+        getData: () => Buffer.from(JSON.stringify(rawAgenticRow())),
+      },
+    ]);
+
+    const res = await GET(makeRequest('runId=999'));
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.benchmarks).toHaveLength(1);
+    // Three fetches total; the single download hit the newest artifact URL.
+    expect(mockFetch).toHaveBeenCalledTimes(3);
+    expect(mockFetch.mock.calls[2][0]).toBe('http://dl-new');
+  });
+
   it('returns evaluations for eval-only runs', async () => {
     const evalData = [rawEvalRow()];
 

packages/app/src/app/api/unofficial-run/route.ts

@@ -17,9 +17,17 @@ import {
   getGithubToken,
   getRunDate,
   normalizeGithubRunInfo,
+  type GithubArtifact,
   type GithubWorkflowRun,
 } from '@/lib/github-artifacts';
 
+/**
+ * Batch size for downloading per-config `bmk_*` artifacts. Big agentic sweeps
+ * upload one artifact per config (dozens per run); a bounded batch keeps us
+ * clear of GitHub's secondary rate limits while still parallelizing.
+ */
+const PER_CONFIG_DOWNLOAD_BATCH_SIZE = 8;
+
 /** Normalize raw artifact rows into the BenchmarkRow shape the frontend expects. */
 export function normalizeArtifactRows(
   rawRows: Record<string, unknown>[],
@@ -234,11 +242,32 @@ async function processSingleRun(
     .filter((a) => a.name === 'eval_results_all')
     .toSorted((a, b) => b.id - a.id)[0];
 
-  if (!bmkArtifact && !evalArtifact) {
+  // Agentic-only sweeps never run the collect-results merge job (run-sweep.yml
+  // only triggers it for fixed-seq sweeps), so they upload per-config
+  // `bmk_agentic_<config>` artifacts with no merged `results_bmk`. Fall back to
+  // downloading those directly. When `results_bmk` exists it already contains
+  // every `bmk_*` row (the merge job downloads the `bmk_*` pattern), so the
+  // fallback must stay off in that case — running both would double-count.
+  // Same-name re-uploads keep only the newest (highest id), mirroring the
+  // merged-artifact selection above.
+  const perConfigBmkArtifacts: GithubArtifact[] = bmkArtifact
+    ? []
+    : [
+        ...artifacts
+          .filter((a) => a.name.startsWith('bmk_'))
+          .reduce((byName, a) => {
+            const prev = byName.get(a.name);
+            if (!prev || a.id > prev.id) byName.set(a.name, a);
+            return byName;
+          }, new Map<string, GithubArtifact>())
+          .values(),
+      ];
+
+  if (!bmkArtifact && perConfigBmkArtifacts.length === 0 && !evalArtifact) {
     return {
       errorResponse: NextResponse.json(
         {
-          error: `No results_bmk or eval_results_all artifact found for runId ${runId}`,
+          error: `No results_bmk, per-config bmk_*, or eval_results_all artifact found for runId ${runId}`,
         },
         { status: 404 },
       ),
@@ -259,6 +288,19 @@ async function processSingleRun(
     );
     if (errorResponse) return { errorResponse };
     benchmarks = normalizeArtifactRows(rows, date, runUrl || null);
+  } else if (perConfigBmkArtifacts.length > 0) {
+    const rawRows: Record<string, unknown>[] = [];
+    for (let i = 0; i < perConfigBmkArtifacts.length; i += PER_CONFIG_DOWNLOAD_BATCH_SIZE) {
+      const batch = perConfigBmkArtifacts.slice(i, i + PER_CONFIG_DOWNLOAD_BATCH_SIZE);
+      const results = await Promise.all(
+        batch.map((a) => downloadArtifactRows(a.archive_download_url, githubToken)),
+      );
+      for (const result of results) {
+        if (result.errorResponse) return { errorResponse: result.errorResponse };
+        rawRows.push(...result.rows);
+      }
+    }
+    benchmarks = normalizeArtifactRows(rawRows, date, runUrl || null);
   }
 
   if (evalArtifact) {