dsh-livebench-panel 0.2.24 → 0.2.32

package/README.md

@@ -46,7 +46,7 @@ cd livebench
 | 分类 | 六大类：coding / math / reasoning / language / data_analysis / instruction_following | 首次验证选 `language` |
 | 任务 | 分类下的具体任务（如 language/typos 拼写纠错） | 首次验证选 `typos`（短平快） |
 | 题目序号范围 | 起止下标（0 起，**含首尾**）；选 Baseline 时序号相对该题库 | 冒烟测试填 0–1（只跑 2 题） |
-| max-tokens | 单次回答的 token 上限 | 推理模型给 8192+，否则思考被截断判 0 分 |
+| max-tokens | 单次回答的 token 上限（默认 65536，上限 200000） | 推理模型别低于 32768，否则思考吃满预算、正文为空，这题会被记成「没做出来」 |
 
 ## Baseline 题库（探针）
 
@@ -86,9 +86,35 @@ cd livebench
 - **推理强度下拉框**（模型右侧）：来自模型配置的 `reasoningEfforts` 映射（如 gpt-5.6 系 off/low/medium/high/xhigh/max，DeepSeek off/low/high/max）。选定后：
   - 插件向 `livebench/model/model_configs/dsh_panel_generated__<display-name>.yaml` 写入一条模型配置（每个模型一个文件，避免并发写同名文件互相覆盖），经 LiveBench 的 `api_kwargs.default.reasoning_effort` 透传给 API（`off` 表示不透传、由后端走默认）；
   - 强度编码进 display-name（如 `code-gpt__gpt-5.6-sol@high`），**不同强度在成绩表中是独立条目**，可直接对比。
-- **参数下拉框**：题集 release（LiveBench 全部 releases）、分类（coding/math/reasoning/language/data_analysis/instruction_following）、任务（随分类联动）、题目序号范围、max-tokens。
+- **参数下拉框**：题集 release（LiveBench 全部 releases）、分类（coding/math/reasoning/language/data_analysis/instruction_following）、任务（随分类联动）、题目序号范围、max-tokens（**默认 32000**，自动夹到模型声明的上限；LiveBench 自带默认只有 4096，推理模型会思考吃满、正文为空，难题可手动调到 65536）、**并发请求数**（`--parallel-requests`，1/2/3/4/6/8，默认 1=串行；模型单题思考慢时并发多题是唯一能等比缩短总时长的开关）。
+- **协议路由**：**Anthropic/Claude 系模型一律走 `anthropic-messages`**（POST `<baseURL>/v1/messages`，
+  与会话窗口同协议；`baseURL` 会自动剥掉 `/v1`、`/v1/messages` 后缀，因为 anthropic SDK 自己会拼）；
+  其余模型按 settings.yaml 的 `api` 走 `openai-completions` / `openai-responses` / 内置端点。
+  运行日志首行打印 `[route] …`，写明协议、目标地址、`max_tokens` 与 thinking 形状。
+- **请求形状对齐会话窗口**：anthropic 通道按强度档附上
+  `thinking: {type: enabled, budget_tokens: N}`（minimal 1024 / low 2048 / medium 8192 /
+  high·xhigh·max 16384；`off` → `{type: disabled}`），并因此**不发 `temperature`**；
+  非 anthropic 通道按渠道习惯选长度上限字段（aiportx 这类中转用 `max_completion_tokens`），
+  且 `--max-tokens` 会夹到该模型在 settings.yaml 里声明的上限。
+- **流式看门狗不会误杀健康请求**：判活标准是"连接上是否还有字节"（含网关每 3 秒的 `ping`），
+  默认 600s 无字节才断开重试（可用渠道声明的 `streamIdleTimeoutMs` 覆写）；
+  另有两道硬边界——单次请求总时长上限（`LIVEBENCH_STREAM_MAX_SECONDS`，默认 1800s）
+  与首个字节等待上限（`LIVEBENCH_FIRST_BYTE_TIMEOUT`，默认 600s）。
+- **进度心跳**：模型长时间思考时网关只发 `ping`、正文迟迟不来，日志里会每 30 秒出现一行
+  `仍在接收: 已 120s，连接累计 12345 字节（模型思考中，正文未到）`，长思考不会"看起来卡死"
+  （`LIVEBENCH_PROGRESS_SECONDS`，0 = 关闭）。
 - **运行控制**：开始 / 停止 / 刷新；最多 9 个模型并发评测（每个模型同时只跑 1 次）；实时滚动日志（每 2.5s 轮询）；「刷新」会清掉已结束的运行日志。
-- **成绩表**：直接读取 `data/live_bench/**/model_judgment/ground_truth_judgment.jsonl` 计算 模型 × 任务 平均分（分数 = 正确率 ×100，单元格下方括号标注「**本次没做或没做完的题数 / 用户选择的题数**」，即题目序号范围的题数；不参与正确率计算的总题数不展示），无需等 LiveBench 自己出榜。支持按模型名/时间排序、拖 ⠿ 自定义行序、勾选或单行按钮删除成绩（删除会同时清掉该模型的答案与判分行；只有空壳文件的“幽灵行”不会再被扫描出来，删除结果稳定持久）。
+- **自动补跑（API 抖动兜底）**：一次评测要连续打几百次 API，中转站 502/限流/超时是常态。
+  跑完后若答案文件里还有 `$ERROR$`，面板会自动用 `--resume --retry-failures`
+  **只重跑失败的那几题**（最多 3 轮，间隔 15s / 60s / 3min），并复用同一个条目名 ——
+  已成功题目的答案与判分都保留，成绩表里仍然只有一行。Baseline 评测同样适用。
+  日志里会打印 `[自动补跑] …`。
+  注意：思考吃满 max-tokens 的空答案（不是 `$ERROR$`）不会自动补跑——那不是抖动，
+  把 max-tokens 调大后手动重跑才有意义。
+- **题目数据集离线读取**：huggingface.co 在国内常常连不通，而已缓存的分类根本不需要联网。
+  面板检测到本次要跑的分类都在 `.hf_cache` 里时，直接以 `HF_HUB_OFFLINE=1` 启动，
+  省掉 5 轮 HEAD 超时重试（每次白等 20~60s）；缺缓存的分类保持联网，不影响新 release。
+- **成绩表**：直接读取 `data/live_bench/**/model_judgment/ground_truth_judgment.jsonl` 计算 模型 × 任务 平均分（分数 = 正确率 ×100，单元格下方括号标注「**本次没做或没做完的题数 / 用户选择的题数**」，即题目序号范围的题数；不参与正确率计算的总题数不展示），无需等 LiveBench 自己出榜。**判分与答案按 `answer_id` 配对**：补跑换过答案的题只认新判分，旧的 0 分不会把成绩拉低；答案文件里同一题出现多行时按最后一行取值（与 LiveBench 自身口径一致）。支持按模型名/时间排序、拖 ⠿ 自定义行序、勾选或单行按钮删除成绩（删除会同时清掉该模型的答案与判分行；只有空壳文件的“幽灵行”不会再被扫描出来，删除结果稳定持久）。
 - **题目序号范围按闭区间处理**：LiveBench 的 `--question-end` 是开区间（`questions[begin:end]`），面板按用户直觉采用闭区间（传参时 `止 + 1`），因此界面上填的题数与实际跑的题数一致。
 
 ## 依赖

package/lib/client.js

@@ -121,7 +121,10 @@ window.__ModuleLoader__.load({
 		function LiveBenchView() {
 					const [config, setConfig] = useState(null);
 					const [configError, setConfigError] = useState(null);
-					const [sel, setSel] = useState({ models: [], efforts: {}, cats: [], tasks: [], release: "2024-11-25", begin: "", end: "", maxTokens: "32000", baseline: null });
+					// maxTokens 默认 32000（用户口径）：LiveBench 自带默认只有 4096，跑推理模型
+					// 会"思考吃满、正文为空"；32k 是够用与耗时之间的折中。难题若出现
+					// "思考占满 max-tokens、未产出答案"，把它调到 65536 重跑即可（上限 200k）。
+					const [sel, setSel] = useState({ models: [], efforts: {}, cats: [], tasks: [], release: "2024-11-25", begin: "", end: "", maxTokens: "32000", parallel: "1", baseline: null });
 					const [modelDdOpen, setModelDdOpen] = useState(false);
 					const [busy, setBusy] = useState(false);
 					const [running, setRunning] = useState(false);
@@ -311,6 +314,7 @@ window.__ModuleLoader__.load({
 										begin: sel.begin,
 										end: sel.end,
 										maxTokens: sel.maxTokens,
+										parallel: sel.parallel,
 									}),
 								});
 								if (!payload.ok) failures.push(`${entry.modelId}: ${payload.error ?? "启动失败"}`);
@@ -577,8 +581,15 @@ window.__ModuleLoader__.load({
 								),
 								),
 								h("div", { className: c("field") },
-									h("label", { className: c("label") }, "max-tokens（默认 32000）"),
-									h("input", { className: c("input"), type: "number", min: 256, max: 200000, value: sel.maxTokens, onChange: setField("maxTokens"), title: "单题输出上限。推理模型在难题上容易把预算全花在思考里、正文为空（成绩表括号里记为「没做出来」），这类题可以把上限调大后重跑。" }),
+									h("label", { className: c("label") }, "max-tokens"),
+									h("input", { className: c("input"), type: "number", min: 256, max: 200000, value: sel.maxTokens, onChange: setField("maxTokens"), title: "单题输出上限（默认 32000，会自动夹到该模型在 settings.yaml 里声明的上限）。LiveBench 自带默认只有 4096，推理模型会思考吃满、正文为空（成绩表里记「没做出来」）；难题遇到这种情况就调到 65536 重跑。" }),
+								),
+								// Anthropic/Claude 这类模型答一道难题常常要思考几分钟（网关期间只发 ping、
+								// 正文不来），单题串行会把总时长拉得很长；这里允许同一次评测内并发多题。
+								h("div", { className: c("field") },
+									h("label", { className: c("label") }, "并发请求数"),
+									h("select", { className: c("select"), value: sel.parallel, onChange: setField("parallel"), title: "同一次评测内同时请求几道题（--parallel-requests）。默认 1 = 串行；模型思考慢时调大可以显著缩短总时长。中转限流/502 会由容错层退避重试。" },
+										["1", "2", "3", "4", "6", "8"].map((n) => h("option", { key: n, value: n }, n === "1" ? "1（串行）" : n))),
 								),
 								h("div", { className: c("field") },
 									h("label", { className: c("label") }, "题目序号范围（可选，0 起，含首尾）"),

package/lib/index.js

@@ -182,13 +182,52 @@ function loadYaml(profileDir) {
  * Read harness providers from settings.yaml, plus the built-in
  * `deepseek-official` provider (registered by @deepseek-ai/dsh-llm-deepseek,
  * which never appears under llm-pi-ai.providers).
- * @returns {Array<{id: string, name: string, api: string|null, baseURL: string|null, keyEnv: string|null, models: Array<{id: string, name: string, efforts: string[]}>}>}
+ *
+ * 除了 id/name/api/baseURL，还要带上两个**渠道约束**，面板必须遵守：
+ *   - `models[].maxTokens`：该模型单次输出上限（如 claude-fable-5-1 = 64000）；
+ *     面板的 max-tokens 默认 32000，不夹住就可能超过渠道上限（bearlab 这类渠道上限就是 32000）；
+ *   - `streamIdleTimeoutMs`：harness 自己给这个渠道设的"流多久没数据就掐断"
+ *     （如 code-claude = 120000）；面板把它透给 LiveBench 的静默看门狗，
+ *     这样"能长思考的渠道"和"确实会挂住的渠道"用的是各自合适的阈值。
+ * @returns {Array<{id: string, name: string, api: string|null, baseURL: string|null, keyEnv: string|null, streamIdleTimeoutMs: number|null, models: Array<{id: string, name: string, efforts: string[], maxTokens: number|null}>}>}
  */
 function readProviders(profileDir) {
 	// profileDir = ~/.dsh/profiles/web  →  settings.yaml = ~/.dsh/settings.yaml
 	const settingsPath = join(profileDir.replace(/[\\/]+$/, ""), "..", "..", "settings.yaml");
 	const settings = existsSync(settingsPath) ? loadYaml(profileDir).parse(readFileSync(settingsPath, "utf8")) ?? {} : {};
+	const providers = providerCapsFromSettings(settings);
 
+	// Providers without an explicit baseURL may still be OpenAI-compatible with
+	// a well-known endpoint: resolve it from the pi-ai provider registry
+	// (@earendil-works/pi-ai, the same source the harness serves from).
+	const piAiData = resolvePiAiDataDir(profileDir);
+	if (piAiData !== null) {
+		for (const provider of providers) {
+			if (provider.baseURL === null) {
+				const info = builtinProtocolInfo(piAiData, provider.id);
+				if (info) {
+					provider.baseURL = info.baseURL;
+					provider.api = info.api;
+				}
+			}
+		}
+	}
+	return providers;
+}
+
+/**
+ * settings.yaml（已解析）→ 面板用的 provider/模型清单。纯函数，便于回归测试。
+ *
+ * 除了 id/name/api/baseURL，还要带上两个**渠道约束**，面板必须遵守：
+ *   - `models[].maxTokens`：该模型单次输出上限（如 claude-fable-5-1 = 64000）；
+ *     面板的 max-tokens 默认 32000，不夹住就可能超过渠道上限（bearlab 这类渠道上限就是 32000）；
+ *   - `streamIdleTimeoutMs`：harness 自己给这个渠道设的"流多久没数据就掐断"
+ *     （如 code-claude = 120000）；面板把它透给 LiveBench 的静默看门狗，
+ *     这样"能长思考的渠道"和"确实会挂住的渠道"各自用合适的阈值。
+ * @param {object} settings 解析后的 settings.yaml
+ */
+function providerCapsFromSettings(settings) {
+	const positiveNumber = (value) => (Number.isFinite(Number(value)) && Number(value) > 0 ? Number(value) : null);
 	const providers = [];
 	const piAi = settings?.["llm-pi-ai"]?.providers ?? {};
 	for (const [id, cfg] of Object.entries(piAi)) {
@@ -198,10 +237,18 @@ function readProviders(profileDir) {
 			api: typeof cfg?.api === "string" ? cfg.api : null,
 			baseURL: typeof cfg?.baseURL === "string" ? cfg.baseURL : null,
 			keyEnv: typeof cfg?.apiKeyEnv === "string" ? cfg.apiKeyEnv : null,
+			streamIdleTimeoutMs: positiveNumber(cfg?.streamIdleTimeoutMs),
+			// 会话窗口（pi-ai）发输出上限时用的字段名 —— 面板要让 LiveBench 用同一个
+			maxTokensField: maxTokensFieldFor({ id, baseURL: cfg?.baseURL, compat: cfg?.compat }),
 			models: Array.isArray(cfg?.models)
 				? cfg.models
 					.filter((m) => m && typeof m.id === "string" && m.id.trim().length > 0)
-					.map((m) => ({ id: m.id.trim(), name: String(m.name ?? m.id).trim(), efforts: effortsOfModel(m) }))
+					.map((m) => ({
+						id: m.id.trim(),
+						name: String(m.name ?? m.id).trim(),
+						efforts: effortsOfModel(m),
+						maxTokens: positiveNumber(m?.maxTokens),
+					}))
 				: [],
 		});
 	}
@@ -213,32 +260,24 @@ function readProviders(profileDir) {
 	const dsModels = Array.isArray(dsCfg.models) && dsCfg.models.length > 0
 		? dsCfg.models
 			.filter((m) => m && typeof m.id === "string" && m.id.trim().length > 0)
-			.map((m) => ({ id: m.id.trim(), name: String(m.name ?? m.id).trim(), efforts: [...DEEPSEEK_EFFORTS] }))
-		: DEFAULT_DEEPSEEK_MODELS.map((m) => ({ ...m, efforts: [...DEEPSEEK_EFFORTS] }));
+			.map((m) => ({
+				id: m.id.trim(),
+				name: String(m.name ?? m.id).trim(),
+				efforts: [...DEEPSEEK_EFFORTS],
+				maxTokens: positiveNumber(m?.maxTokens),
+			}))
+		: DEFAULT_DEEPSEEK_MODELS.map((m) => ({ ...m, efforts: [...DEEPSEEK_EFFORTS], maxTokens: null }));
 	providers.push({
 		id: "deepseek-official",
 		name: "DeepSeek 官方",
 		api: "openai-completions",
 		baseURL: typeof dsCfg.baseURL === "string" && dsCfg.baseURL.length > 0 ? dsCfg.baseURL : "https://api.deepseek.com",
 		keyEnv: typeof dsCfg.apiKeyEnv === "string" && dsCfg.apiKeyEnv.length > 0 ? dsCfg.apiKeyEnv : "DEEPSEEK_API_KEY",
+		streamIdleTimeoutMs: positiveNumber(dsCfg?.streamIdleTimeoutMs),
+		// DeepSeek 官方在 pi-ai 的 detectCompat 里属于 useMaxTokens → max_tokens
+		maxTokensField: "max_tokens",
 		models: dsModels,
 	});
-
-	// Providers without an explicit baseURL may still be OpenAI-compatible with
-	// a well-known endpoint: resolve it from the pi-ai provider registry
-	// (@earendil-works/pi-ai, the same source the harness serves from).
-	const piAiData = resolvePiAiDataDir(profileDir);
-	if (piAiData !== null) {
-		for (const provider of providers) {
-			if (provider.baseURL === null) {
-				const info = builtinProtocolInfo(piAiData, provider.id);
-				if (info) {
-					provider.baseURL = info.baseURL;
-					provider.api = info.api;
-				}
-			}
-		}
-	}
 	return providers;
 }
 
@@ -472,6 +511,90 @@ function displayModelName(providerId, modelId) {
 	return `${String(providerId).replace(/[^A-Za-z0-9._-]/g, "-")}__${String(modelId).replace(/[^A-Za-z0-9._-]/g, "-")}`;
 }
 
+/**
+ * 这个 模型/provider 是不是 Anthropic(Claude) 系？—— 决定要不要走 anthropic-messages 协议。
+ * 名字里带 claude / anthropic 就算（provider id 或 model id 任一命中）。
+ */
+function isAnthropicModel(providerId, modelId) {
+	return /claude|anthropic/i.test(String(modelId ?? "")) || /claude|anthropic/i.test(String(providerId ?? ""));
+}
+
+/**
+ * anthropic SDK 会在 baseURL 后面自己拼 `/v1/messages`，所以 ANTHROPIC_BASE_URL
+ * 必须是**站点根**：把用户可能写的 `/v1`、`/v1/messages`、结尾斜杠都剥掉。
+ * 踩过的坑：settings.yaml 里 openai 兼容渠道习惯写成 `https://host/v1`，
+ * 直接拿它当 ANTHROPIC_BASE_URL 会 POST 到 `https://host/v1/v1/messages` → 404。
+ */
+function anthropicBaseUrl(baseURL) {
+	return String(baseURL ?? "")
+		.trim()
+		.replace(/\/+$/, "")
+		.replace(/\/v1\/messages$/i, "")
+		.replace(/\/v1$/i, "")
+		.replace(/\/+$/, "");
+}
+
+/**
+ * 请求形状的"思考预算"档位（对齐 pi-ai）：
+ *   - 有预算 → thinking enabled + budget_tokens
+ *   - effort 明确是 off → thinking disabled
+ *   - 其它（没选强度）→ 不写，交给上游默认
+ */
+function thinkingModeForEffort(effort) {
+	const budget = thinkingBudgetForEffort(effort);
+	if (budget !== null) return { type: "enabled", budget_tokens: budget };
+	if (effort === "off") return { type: "disabled" };
+	return null;
+}
+
+/**
+ * LiveBench 发"单次输出上限"时该用哪个字段？
+ *
+ * 会话窗口（harness）走 pi-ai，会按渠道自动挑字段：大部分中转（aiportx、code28 等）
+ * 用 `max_completion_tokens`；deepseek / moonshot / z.ai / together / nvidia /
+ * ant-ling / chutes / Cloudflare 网关用 `max_tokens`
+ * （对应 pi-ai `openai-completions.js` 的 `detectCompat().maxTokensField`）。
+ * 而 LiveBench 的 `chat_completion_openai` 只看模型名里有没有 "gpt"：非 gpt 模型一律发
+ * `max_tokens`。**实测 aiportx-claude 因此慢 5 倍以上**：同一道 olympiad、同一
+ * `reasoning_effort=max`，发 `max_completion_tokens=64000` 用 224s 跑完（最大空档 106s）；
+ * 发 `max_tokens=64000` 要 1232s，中途 449s 一个 chunk 都没有 —— 面板里就是"卡死"。
+ * 所以面板在生成的模型配置里显式写死用哪个字段，LiveBench 看到就不再自己猜。
+ * @param {{id?: string, baseURL?: string|null, compat?: object}} provider
+ * @returns {"max_tokens"|"max_completion_tokens"}
+ */
+function maxTokensFieldFor(provider) {
+	const explicit = provider?.compat?.maxTokensField;
+	if (explicit === "max_tokens" || explicit === "max_completion_tokens") return explicit;
+	const id = String(provider?.id ?? "");
+	const url = String(provider?.baseURL ?? "").toLowerCase();
+	const useMaxTokens = url.includes("chutes.ai")
+		|| id === "deepseek" || url.includes("deepseek.com")
+		|| id === "moonshotai" || id === "moonshotai-cn" || url.includes("api.moonshot.")
+		|| id === "cloudflare-ai-gateway" || url.includes("gateway.ai.cloudflare.com")
+		|| id === "together" || url.includes("api.together.ai") || url.includes("api.together.xyz")
+		|| id === "nvidia" || url.includes("integrate.api.nvidia.com")
+		|| id === "ant-ling" || url.includes("api.ant-ling.com")
+		|| id === "zai" || id === "zai-coding-cn" || url.includes("api.z.ai") || url.includes("open.bigmodel.cn");
+	return useMaxTokens ? "max_tokens" : "max_completion_tokens";
+}
+
+/**
+ * 会话窗口（pi-ai 的 anthropic-messages 通道）给每个推理档位的 thinking 预算：
+ * minimal 1024 / low 2048 / medium 8192 / high 16384，`xhigh` 与 `max` 都按 `high` 处理
+ * （对应 `simple-options.js` 的 `DEFAULT_THINKING_BUDGETS` + `clampReasoning`）。
+ *
+ * **这个预算必须转发**：会话窗口在 anthropic 通道上固定发
+ * `thinking: {type: enabled, budget_tokens: N}`（并且因为开了 thinking，
+ * 就**完全不发 temperature**）。LiveBench 的 `chat_completion_anthropic` 不会自己发
+ * `thinking`，于是上游走"自适应思考"：一道 olympiad 能安静地想十几分钟、
+ * 中途一个 chunk 都没有（面板里表现为卡死 + 一堆 RemoteProtocolError）。
+ * 面板把同一份预算写进生成的模型配置，让两边请求形状一致。
+ */
+const THINKING_BUDGETS = { minimal: 1024, low: 2048, medium: 8192, high: 16384, xhigh: 16384, max: 16384 };
+function thinkingBudgetForEffort(effort) {
+	return Number.isFinite(THINKING_BUDGETS[effort]) ? THINKING_BUDGETS[effort] : null;
+}
+
 /**
  * Write a single-entry model config into LiveBench's model_configs directory so
  * `get_model_config(displayName)` resolves it (instead of the bare custom-model
@@ -479,7 +602,7 @@ function displayModelName(providerId, modelId) {
  * The file is regenerated on every start; secrets never go in here.
  * @returns {string|null} error message, or null on success.
  */
-function writeGeneratedModelConfig(layout, YAML, { displayName, modelId, reasoningEffort, protocol }) {
+function writeGeneratedModelConfig(layout, YAML, { displayName, modelId, reasoningEffort, protocol, maxTokens = null, maxTokensField = null, thinkingBudget = null, thinkingDisabled = false }) {
 	const configDir = join(layout.livebenchDir, "model", "model_configs");
 	// 每个模型一个独立配置文件：并发启动多模型时共享单文件会互相覆盖，
 	// 导致先启动的进程读到别人的配置 → anthropic/responses 路由失效 → 全 $ERROR$。
@@ -491,26 +614,56 @@ function writeGeneratedModelConfig(layout, YAML, { displayName, modelId, reasoni
 		`display_name: ${displayName}`,
 		"api_name:",
 	];
+	// 输出上限的字段名：写进 api_kwargs 后，LiveBench 的
+	// `if 'max_tokens' not in api_kwargs and 'max_completion_tokens' not in api_kwargs`
+	// 分支会被跳过，于是"用哪个字段"完全由面板决定（见 maxTokensFieldFor）。
+	const limitLine = protocol === "openai" && maxTokensField === "max_completion_tokens"
+		&& Number.isFinite(Number(maxTokens)) && Number(maxTokens) > 0
+		? `    max_completion_tokens: ${Number(maxTokens)}`
+		: null;
 	if (protocol === "anthropic") {
 		// Route through LiveBench's native anthropic client; the endpoint is
 		// pointed at the provider proxy via ANTHROPIC_BASE_URL (spawn env).
 		lines.push(`  anthropic: ${modelId}`, "default_provider: anthropic");
-		if (reasoningEffort) {
-			// note: reasoning_effort is an OpenAI-style knob and is intentionally
-			// not forwarded on the anthropic protocol path.
+		// 会话窗口在这个通道上固定带 thinking（并因此不带 temperature），面板照抄，
+		// 否则上游会走"自适应思考"，一题能安静地想十几分钟（见 thinkingBudgetForEffort）。
+		if (Number.isFinite(Number(thinkingBudget)) && Number(thinkingBudget) > 0) {
+			lines.push(
+				"api_kwargs:",
+				"  default:",
+				"    thinking:",
+				"      type: enabled",
+				`      budget_tokens: ${Number(thinkingBudget)}`,
+				// thinking 与 temperature 互斥：显式置 None → LiveBench 映射成 NOT_GIVEN 而不发送
+				"    temperature: null",
+			);
+		} else if (thinkingDisabled) {
+			// 用户把强度选成 off：会话窗口发的是 {type: disabled}，不带 thinking 反而会让
+			// 上游走默认（实测默认是"开思考"）。
+			lines.push(
+				"api_kwargs:",
+				"  default:",
+				"    thinking:",
+				"      type: disabled",
+				"    temperature: null",
+			);
 		}
 	} else if (protocol === "openai_responses") {
 		// OpenAI Responses API proxy: provider name matches
 		// get_api_function('openai_responses') → chat_completion_openai_responses,
 		// which converts reasoning_effort to reasoning:{effort} itself.
 		lines.push(`  openai_responses: ${modelId}`);
-		if (reasoningEffort) {
-			lines.push("api_kwargs:", "  default:", `    reasoning_effort: ${reasoningEffort}`);
+		if (reasoningEffort || limitLine !== null) {
+			lines.push("api_kwargs:", "  default:");
+			if (reasoningEffort) lines.push(`    reasoning_effort: ${reasoningEffort}`);
+			if (limitLine !== null) lines.push(limitLine);
 		}
 	} else {
 		lines.push(`  local: ${modelId}`);
-		if (reasoningEffort) {
-			lines.push("api_kwargs:", "  default:", `    reasoning_effort: ${reasoningEffort}`);
+		if (reasoningEffort || limitLine !== null) {
+			lines.push("api_kwargs:", "  default:");
+			if (reasoningEffort) lines.push(`    reasoning_effort: ${reasoningEffort}`);
+			if (limitLine !== null) lines.push(limitLine);
 		}
 	}
 	lines.push("");
@@ -584,19 +737,119 @@ async function streamJsonl(path, onRow) {
 	}
 }
 
+/** 从答案行里抽 answer_id（同样只做正则，不 JSON.parse）。 */
+const ANSWER_ID_RE = /"answer_id"\s*:\s*"([A-Za-z0-9_.:-]{6,80})"/;
+
+/** 一行答案归并后的状态：这一题最终算不算"做出来了"。 */
+function newAnswerScan() {
+	return { byQid: new Map(), anon: 0 };
+}
+
 /**
- * 从一行 answer JSON 提取 (model_id, 是否 $ERROR$)。不整对象解析时仍需 parse，
- * 但只保留必要字段并立即释放 —— 避免大对象堆积。
+ * 把一行答案并进扫描状态（同一 question_id 后写的覆盖先写的）。
+ *
+ * 为什么必须按 question_id 归并：断点补跑（--resume --retry-failures）重跑出来的
+ * 答案会**追加**到同一个文件里，旧行不会被删（LiveBench 自己靠 reorg_answer_file
+ * 取每个 question_id 的最后一行）。不归并就会把同一题算两次：作答数虚高、
+ * $ERROR$ 虚高，括号里的「没做出来 / 选择题数」跟着一起错。
  */
-function parseAnswerLineLight(line) {
-	try {
-		const row = JSON.parse(line);
-		const turns = row.choices?.[0]?.turns;
-		const text = Array.isArray(turns) ? String(turns[0] ?? "") : "";
-		return { model: typeof row.model_id === "string" ? row.model_id : null, is_error: text.startsWith("$ERROR$"), raw: row };
-	} catch {
-		return null;
+function scanAnswerLine(scan, line) {
+	if (line.trim().length === 0) return;
+	const idMatch = line.match(QUESTION_ID_RE);
+	// 没有 question_id 的行（理论上不该有）用序号占位，避免互相覆盖
+	const qid = idMatch !== null ? idMatch[1] : `\u0000#${scan.anon++}`;
+	const aMatch = line.match(ANSWER_ID_RE);
+	const isError = line.includes('"$ERROR$"');
+	scan.byQid.set(qid, {
+		isError,
+		isEmpty: !isError && isEmptyAnswerLine(line),
+		// 每次生成都会换一个 answer_id（gen_api_answer: shortuuid.uuid()），
+		// 判分侧靠它区分"这条判分属于哪一次答案"，见 scoreJudgments。
+		answerId: aMatch !== null ? aMatch[1] : null,
+	});
+}
+
+/**
+ * 收尾统计：作答数 / API 失败数 / 空答案数 / 有有效答案的题号。
+ * @param {{byQid: Map<string,{isError:boolean,isEmpty:boolean,answerId:string|null}>}} scan
+ */
+function answerScanStats(scan) {
+	const okIds = new Set();
+	let errors = 0;
+	let empty = 0;
+	for (const [qid, rec] of scan.byQid) {
+		if (rec.isError) errors += 1;
+		else if (rec.isEmpty) empty += 1;
+		else okIds.add(qid);
+	}
+	return { answered: scan.byQid.size, errors, empty, okIds, byQid: scan.byQid };
+}
+
+/** 答案文件全文 → 统计（scanAnswerLine + answerScanStats 的便捷封装）。 */
+function reduceAnswerLines(text) {
+	const scan = newAnswerScan();
+	for (const line of text.split("\n")) scanAnswerLine(scan, line);
+	return answerScanStats(scan);
+}
+
+/**
+ * 判分归并：**只保留属于本次答案的那一条判分**。
+ *
+ * 补跑会换新 answer_id，而旧答案（例如 $ERROR$ 那一版）的 0 分判分仍留在
+ * ground_truth_judgment.jsonl 里。老实现把所有判分行直接求和，于是
+ * "补跑后每题都做对"也会被旧 0 分拉低（8 题里 4 题满分 + 4 条旧 0 分 → 50%）。
+ *
+ * 规则：
+ *   - 答案文件里这一题是 $ERROR$ / 空答案 → 判分一律不计（没做出来，不进分母）；
+ *   - 判分 answer_id 与当前答案一致 → 计入；
+ *   - 判分/答案缺 answer_id（老数据）→ 无法区分，沿用旧行为计入；
+ *   - 只剩旧答案的判分 → 丢弃（宁可少一题，也不把旧判分算进新成绩）；
+ *   - 答案文件里根本没有这一题（只有判分）→ 沿用旧行为计入。
+ *
+ * @param {Array<{questionId:string|null,answerId:string|null,score:number,tstamp:number}>} judgments
+ * @param {Map<string,{isError:boolean,isEmpty:boolean,answerId:string|null}>} byQid
+ * @returns {{judged:number, sum:number, time:number}}
+ */
+function scoreJudgments(judgments, byQid) {
+	const byQuestion = new Map();
+	const orphans = [];
+	for (const j of judgments) {
+		if (j.questionId === null) {
+			orphans.push(j);
+			continue;
+		}
+		const list = byQuestion.get(j.questionId);
+		if (list === undefined) byQuestion.set(j.questionId, [j]);
+		else list.push(j);
+	}
+	let sum = 0;
+	let judged = 0;
+	let time = 0;
+	const accept = (j) => {
+		sum += j.score;
+		judged += 1;
+		if (Number.isFinite(j.tstamp) && j.tstamp > time) time = j.tstamp;
+	};
+	for (const [qid, list] of byQuestion) {
+		const ans = byQid.get(qid);
+		if (ans !== undefined && (ans.isError || ans.isEmpty)) continue;
+		if (ans === undefined || ans.answerId === null) {
+			accept(list[list.length - 1]);
+			continue;
+		}
+		let picked = null;
+		for (let i = list.length - 1; i >= 0; i -= 1) {
+			if (list[i].answerId === ans.answerId) { picked = list[i]; break; }
+		}
+		if (picked === null) {
+			for (let i = list.length - 1; i >= 0; i -= 1) {
+				if (list[i].answerId === null) { picked = list[i]; break; }
+			}
+		}
+		if (picked !== null) accept(picked);
 	}
+	for (const j of orphans) accept(j);
+	return { judged, sum, time };
 }
 
 /**
@@ -706,9 +959,9 @@ async function readTextFileAsync(path) {
 async function computeResults(dataDir) {
 	const now = Date.now();
 	if (resultsCache.data !== null && now - resultsCache.at < 5000) return resultsCache.data;
-	const judged = new Map(); // `${model}\u0000${task}` -> {model, category, task, sum, n, time}
+	const judged = new Map(); // `${model}\u0000${task}` -> {model, category, task, items: []}
 	const totals = new Map(); // task -> question count
-	const answers = new Map(); // `${model}\u0000${task}` -> {answered, errors}
+	const answers = new Map(); // `${model}\u0000${task}` -> 答案扫描状态（按 question_id 归并）
 	const catByTask = new Map();
 	if (!existsSync(dataDir)) return { rows: [], taskTotals: {} };
 	// 读取每次评测的配置范围（displayName -> {benchNames, begin, end}）
@@ -735,29 +988,13 @@ async function computeResults(dataDir) {
 				const text = await readTextFileAsync(join(answerDir, file));
 				if (text === null) continue;
 				const key = `${model}\u0000${task}`;
-				const stat = answers.get(key) ?? { answered: 0, errors: 0, empty: 0, okIds: null };
-				// baseline 评测要回答"少做了哪几个题"，所以需要收集**有有效答案**的 question_id。
-				// 「没做出来」= 压根没跑 + 跑了但空答案 + 跑了但 API 失败，三者都算，
-				// 因为它们都该从正确率分母里排除，也都是用户想补跑的题。
-				// 只用正则抽 id（不 JSON.parse），对几百 KB～几 MB 的答案文件也够快。
-				const runMetaEntry = runMeta.get(model);
-				const trackIds = baselineIdsFor(runMetaEntry) !== null;
-				if (trackIds && stat.okIds === null) stat.okIds = new Set();
-				for (const line of text.split("\n")) {
-					if (line.trim().length === 0) continue;
-					stat.answered += 1;
-					const isError = line.includes('"$ERROR$"');
-					const isEmpty = !isError && isEmptyAnswerLine(line);
-					if (isError) stat.errors += 1;
-					else if (isEmpty) stat.empty += 1;
-					if (trackIds && !isError && !isEmpty) {
-						const idMatch = line.match(QUESTION_ID_RE);
-						if (idMatch !== null) stat.okIds.add(idMatch[1]);
-					}
-				}
+				// 逐行归并（不 JSON.parse 大答案行）：同一题保留最后一行，
+				// 也就是补跑后的新答案 —— 与 LiveBench reorg_answer_file 的口径一致。
+				const scan = answers.get(key) ?? newAnswerScan();
+				for (const line of text.split("\n")) scanAnswerLine(scan, line);
 				// 空文件（尚未产出答案，或成绩已被删除只留下 0 字节壳）不计入结果：
 				// 否则删掉的记录会在下一次扫描时凭“文件名仍在”重新冒出来。
-				if (stat.answered > 0) answers.set(key, stat);
+				if (scan.byQid.size > 0) answers.set(key, scan);
 			}
 			const jText = await readTextFileAsync(join(taskDir, "model_judgment", "ground_truth_judgment.jsonl"));
 			if (jText !== null) {
@@ -769,11 +1006,13 @@ async function computeResults(dataDir) {
 					const score = typeof row.score === "number" ? row.score : Number(row.score);
 					if (model === null || !Number.isFinite(score) || score < 0) continue;
 					const key = `${model}\u0000${task}`;
-					const entry = judged.get(key) ?? { model, category, task, sum: 0, n: 0, time: 0 };
-					entry.sum += score;
-					entry.n += 1;
-					const tstamp = Number(row.tstamp);
-					if (Number.isFinite(tstamp) && tstamp > entry.time) entry.time = tstamp;
+					const entry = judged.get(key) ?? { model, category, task, items: [] };
+					entry.items.push({
+						questionId: typeof row.question_id === "string" ? row.question_id : null,
+						answerId: typeof row.answer_id === "string" ? row.answer_id : null,
+						score,
+						tstamp: Number(row.tstamp),
+					});
 					judged.set(key, entry);
 				}
 			}
@@ -784,16 +1023,16 @@ async function computeResults(dataDir) {
 	const keys = new Set([...judged.keys(), ...answers.keys()]);
 	const rows = [...keys].map((key) => {
 		const entry = judged.get(key);
-		const stat = answers.get(key) ?? { answered: 0, errors: 0 };
+		const scan = answers.get(key) ?? null;
 		const [model, task] = key.split("\u0000");
 		const category = entry?.category ?? catByTask.get(task) ?? "";
 		const total = totals.get(task) ?? 0;
-		const judgedCount = entry?.n ?? 0;
-		// 「做出来」的题 = 尝试数 - API 失败 - 空答案。
-		// 关键：思考吃满 max_tokens、正文为空的题属于"没做出来"，不是"做错了"，
-		// 必须从正确率分母里剔除，否则一个模型 8 题里只答出 1 题（0.9167 分）
-		// 会被算成 11.5% 而不是 91.7%。
-		const empty = stat.empty ?? 0;
+		// 答案先归并到「每题一条最新记录」，再用它给判分定性：
+		// 「做出来」的题 = 有有效答案的题；思考吃满 max_tokens（正文为空）、
+		// API 失败都不是"做错了"，不能进正确率分母，也不能被旧判分拉低。
+		const stat = scan === null ? { answered: 0, errors: 0, empty: 0, okIds: new Set(), byQid: new Map() } : answerScanStats(scan);
+		const { judged: judgedCount, sum, time: judgedTime } = scoreJudgments(entry?.items ?? [], stat.byQid);
+		const empty = stat.empty;
 		const notProduced = stat.errors + empty;
 		const done = Math.max(0, stat.answered - notProduced);
 		// 选择题数 = 用户在「题目序号范围」里选择的题数（end 含端点）。
@@ -834,20 +1073,21 @@ async function computeResults(dataDir) {
 		// 实际尝试数比设定还多（断点重跑等）时，以实际为准
 		if (configured < stat.answered) configured = stat.answered;
 		const notDone = Math.max(0, configured - done);
-		// 正确率 = 做对的题 / **做出来的题**（API 失败、思考吃满 token 没产出答案的都不进分母）
-		const judgedDone = Math.max(0, judgedCount - notProduced);
-		const score = entry && judgedDone > 0 ? (entry.sum / judgedDone) * 100 : null;
+		// 正确率 = 做对的题 / **做出来的题**（API 失败、思考吃满 token 没产出答案的都不进分母）。
+		// judgedCount 已经只统计"属于本次答案"的判分，所以这里不再减 notProduced：
+		// 那些题的判分（如果有）在 scoreJudgments 里就已经被剔除了。
+		const score = judgedCount > 0 ? (sum / judgedCount) * 100 : null;
 		// Baseline 评测：算出**具体哪几个题号没做出来**（题号 = 该题库内的 0 起下标，
 		// 与「题目序号范围」的编号一致，方便直接复制去重跑）。
-		const missingIndexes = missingBaselineIndexes(meta, stat.okIds ?? new Set());
+		const missingIndexes = missingBaselineIndexes(meta, stat.okIds);
 		return {
 			model,
 			category,
 			task,
 			score,
-			judged: entry?.n ?? 0,
+			judged: judgedCount,
 			total,
-			time: entry && entry.time > 0 ? entry.time : null,
+			time: judgedTime > 0 ? judgedTime : null,
 			answered: stat.answered,
 			errors: stat.errors,
 			empty,
@@ -872,28 +1112,34 @@ async function computeResults(dataDir) {
 }
 
 /**
- * 异步统计某模型在指定 bench 范围内的 $ERROR$ 答案数（用于自动补跑判断）。
- * 只扫 body.benchNames 涉及的任务目录，流式读取不阻塞事件循环。
+ * 异步统计某模型在指定 bench 范围内"最终仍是 $ERROR$"的题数（用于自动补跑判断）。
+ *
+ * benchPaths 必须是**服务端解析后的** bench 列表（`live_bench/<cat>[/<task>]`）。
+ * 早期版本直接读 body.benchNames，而 Baseline 评测根本不送这个字段（它送的是
+ * baseline/baselineTask/baselinePicks），于是 baseline 跑完全军覆没也不会自动补跑 ——
+ * 这正是 kimi-k3 那次 8 题全 502、面板只留一行 `—`、没有任何重试的原因。
+ *
+ * 按 question_id 归并后统计（同一题补跑成功过就不再算失败），流式读取不阻塞事件循环。
+ * @returns {Promise<{errors:number, failedIds:string[]}>}
  */
-async function countErrorAnswersAsync(dataDir, displayName, body) {
-	if (!/^[A-Za-z0-9._@-]{1,160}$/.test(displayName)) return 0;
-	const benches = Array.isArray(body?.benchNames) ? body.benchNames : [];
-	let errors = 0;
+async function countErrorAnswersAsync(dataDir, displayName, benchPaths) {
+	if (!/^[A-Za-z0-9._@-]{1,160}$/.test(displayName)) return { errors: 0, failedIds: [] };
+	const benches = Array.isArray(benchPaths) ? benchPaths : [];
+	const scan = newAnswerScan();
 	for (const bn of benches) {
-		const parts = bn.split("/").filter((s) => s.length > 0); // live_bench/<cat>[/<task>]
+		const parts = String(bn).split("/").filter((s) => s.length > 0); // live_bench/<cat>[/<task>]
 		if (parts.length < 2) continue;
 		const category = parts[1];
 		const tasks = parts.length >= 3 ? [parts[2]] : readDirSafe(join(dataDir, category));
 		for (const task of tasks) {
 			if (!/^[A-Za-z0-9_]{1,80}$/.test(task)) continue;
 			const file = join(dataDir, category, task, "model_answer", displayName + ".jsonl");
-			await streamJsonl(file, (line) => {
-				const parsed = parseAnswerLineLight(line);
-				if (parsed && parsed.is_error) errors += 1;
-			});
+			await streamJsonl(file, (line) => scanAnswerLine(scan, line));
 		}
 	}
-	return errors;
+	const failedIds = [];
+	for (const [qid, rec] of scan.byQid) if (rec.isError) failedIds.push(qid);
+	return { errors: failedIds.length, failedIds };
 }
 
 /**
@@ -956,11 +1202,62 @@ function validateBenchName(bn) {
 	return null;
 }
 
+/**
+ * LiveBench 的分类列表（权威来源是 LiveBench 自己的 `LIVE_BENCH_CATEGORIES`）。
+ *
+ * 面板要判断"本次要跑的题目数据集是否都已缓存"，而 `--bench-name live_bench`
+ * （全部分类）的路径里没有分类段 —— 不补上分类列表就会误判成"没缓存"，
+ * 于是每个分类都要走一遍 huggingface.co 的 HEAD 超时重试（WinError 10060 刷屏）。
+ * 所以直接从 LiveBench 源码里读那份列表，读不到再用兜底常量。
+ * @param {string} root LiveBench 根目录
+ * @returns {string[]} 分类名（如 coding / math / reasoning …）
+ */
+const LIVEBENCH_CATEGORIES_FALLBACK = ["coding", "data_analysis", "instruction_following", "math", "reasoning", "language"];
+function livebenchCategories(root) {
+	try {
+		const text = readFileSync(join(root, "livebench", "common.py"), "utf8");
+		const block = text.match(/LIVE_BENCH_CATEGORIES\s*=\s*\[([^\]]*)\]/);
+		if (block !== null) {
+			const names = [...block[1].matchAll(/"([A-Za-z0-9_]{1,40})"/g)].map((m) => m[1]);
+			if (names.length > 0) return names;
+		}
+	} catch { /* 源码读不到（改过结构/权限）时用兜底列表 */ }
+	return LIVEBENCH_CATEGORIES_FALLBACK;
+}
+
+/**
+ * 一次运行需要哪些题目数据集（= 分类）？
+ *
+ * bench 路径带分类（`live_bench/<分类>[/<任务>]`）就用它；
+ * 只给 `live_bench`（全跑）时就是**全部分类** —— 这里漏掉分类是实测踩过的坑：
+ * 答案为空的集合 → 判成"没缓存" → 每个分类白刷 5 轮 HF 超时重试。
+ * @param {string[]} benchPaths 服务端解析后的 bench 列表
+ * @param {string[]} categories LiveBench 全部分类
+ * @returns {Set<string>}
+ */
+function hfCategoriesFor(benchPaths, categories) {
+	const out = new Set();
+	for (const bn of benchPaths) {
+		const parts = String(bn).split("/").filter((s) => s.length > 0);
+		if (parts.length >= 2 && /^[A-Za-z0-9_]{1,80}$/.test(parts[1])) out.add(parts[1]);
+		else for (const cat of categories) out.add(cat);
+	}
+	return out;
+}
+
 function apply(ctx) {
 	/** All runs: runId -> record. Several evaluations may run concurrently. */
 	const runs = new Map();
 
-	const startRun = async (body, autoRetries = 0) => {
+	/**
+	 * 启动一次评测。
+	 * @param {object} body 面板送来的请求体
+	 * @param {number} autoRetries 已经自动补跑过几轮
+	 * @param {string|null} displayNameOverride 自动补跑时复用首次运行的 display-name：
+	 *   answers 文件同名 → `--resume --retry-failures` 只重跑失败题（其它题的答案与判分都留着），
+	 *   成绩表里也仍然只有一行，而不是每次补跑多冒出一行。
+	 */
+	const startRun = async (body, autoRetries = 0, displayNameOverride = null) => {
 		const layout = livebenchLayout();
 		if (!layout.available) {
 			return { status: 409, payload: { ok: false, error: `LiveBench venv not found under ${layout.root}` } };
@@ -1054,12 +1351,21 @@ function apply(ctx) {
 		const _now = new Date();
 		const _pad = (n) => String(n).padStart(2, "0");
 		const runStamp = `r${_now.getFullYear()}${_pad(_now.getMonth() + 1)}${_pad(_now.getDate())}-${_pad(_now.getHours())}${_pad(_now.getMinutes())}${_pad(_now.getSeconds())}`;
-		const displayName = displayModelName(providerId || "direct", modelId) + (hasEffortSuffix ? "@" + effort : "") + "__" + runStamp;
+		const displayName = typeof displayNameOverride === "string" && displayNameOverride.length > 0
+			? displayNameOverride
+			: displayModelName(providerId || "direct", modelId) + (hasEffortSuffix ? "@" + effort : "") + "__" + runStamp;
 		let writeError = null;		// Anthropic-protocol proxies cannot go through --api-base (that path
 		// speaks OpenAI Chat Completions). Instead the generated model config
 		// selects LiveBench's native anthropic client and the spawn env points
 		// the SDK at the proxy (ANTHROPIC_BASE_URL / ANTHROPIC_API_KEY).
-		const isAnthropicRoute = provider && provider.api === "anthropic-messages" && provider.baseURL;
+		//
+		// 规则（用户要求 + 实测）：**只要是 Anthropic/Claude 系模型，一律走 anthropic-messages**，
+		// 不再看 settings.yaml 里写的是 openai-completions 还是 anthropic-messages ——
+		// 会话窗口对这类模型用的就是 /v1/messages，两边协议一致才谈得上"形状一致"。
+		// baseURL 会被规范化（剥掉 /v1、/v1/messages），因为 anthropic SDK 自己拼 /v1/messages。
+		const anthropicRouteBase = provider?.baseURL ? anthropicBaseUrl(provider.baseURL) : "";
+		const isAnthropicRoute = anthropicRouteBase.length > 0
+			&& (provider.api === "anthropic-messages" || isAnthropicModel(providerId, modelId));
 		// OpenAI Responses-API proxies (api: openai-responses) select LiveBench's
 		// openai_responses client; --api-base + LIVEBENCH_API_KEY route them the
 		// usual way, and reasoning_effort converts to reasoning:{effort} inside.
@@ -1072,26 +1378,45 @@ function apply(ctx) {
 		// provider / api_kwargs / max_tokens —— 实测会把 temperature 悄悄变成 1.0、
 		// max_tokens 变成 131072，等于用户选的 provider 被换掉。写了自己的配置，
 		// 解析结果就是确定的 {local: <modelId>} + --api-base。
+		// max-tokens：面板默认 32000（LiveBench 自带默认只有 4096，推理模型会思考吃满、
+		// 正文为空 → 记「没做出来」；32k 是够用与耗时之间的折中，难题可手动调到 65536）。
+		// 另外不能超过 harness 给这个模型声明的上限（settings.yaml 的 models[].maxTokens，
+		// 例如 claude-fable-5-1 = 64000、bearlab-claude = 32000）。
+		const requestedMaxTokens = asInt(body.maxTokens, 256, 200000, 32000);
+		const modelMaxTokens = modelMeta !== null && Number(modelMeta.maxTokens) > 0 ? Number(modelMeta.maxTokens) : null;
+		const maxTokens = modelMaxTokens !== null ? Math.min(requestedMaxTokens, modelMaxTokens) : requestedMaxTokens;
 		writeError = writeGeneratedModelConfig(layout, loadYaml(profileDir), {
 			displayName,
 			modelId,
 			reasoningEffort: isAnthropicRoute ? null : effort,
 			protocol: isAnthropicRoute ? "anthropic" : isOpenAIResponsesRoute ? "openai_responses" : "openai",
+			// 输出上限与字段名：让 LiveBench 用**会话窗口同样的字段**发出去
+			// （aiportx 这类中转要 max_completion_tokens；发 max_tokens 会慢数倍甚至卡死）
+			maxTokens,
+			// provider 上已经算好（providerCapsFromSettings 里调 maxTokensFieldFor，
+			// 会尊重 settings.yaml 显式声明的 compat.maxTokensField）
+			maxTokensField: provider !== null ? provider.maxTokensField : null,
+			// anthropic 通道：把会话窗口那份 thinking 预算一起发出去（见 thinkingBudgetForEffort）
+			thinkingBudget: isAnthropicRoute ? thinkingBudgetForEffort(effort) : null,
+			thinkingDisabled: isAnthropicRoute && effort === "off",
 		});
 		if (writeError) return { status: 500, payload: { ok: false, error: writeError } };
 
 		const benchParts = ["live_bench", ...(category ? [category] : []), ...(task ? [task] : [])];
+		// 服务端最终使用的 bench 列表：自动补跑扫描（找 $ERROR$）和 HF 缓存判断都用它，
+		// 不能用 body.benchNames —— baseline 评测不送这个字段。
+		const benchPaths = benchNames !== null ? benchNames : [benchParts.join("/")];
 		const args = [
 			"run_livebench.py",
 			"--model", displayName,
 			"--model-display-name", displayName,
 			"--bench-name",
-			...(benchNames !== null ? benchNames : [benchParts.join("/")]),
+			...benchPaths,
 			"--livebench-release-option", release,
 			// 上限放到 200k：推理模型在难题上会把 max_tokens 全烧在思考里，正文为空
 			// （eval_status=token_exhaustion），此时"做不出来"其实是预算不够而不是能力不够。
 			// 旧上限 32768 在 olympiad 这类题上会直接把参考模型卡死。
-			"--max-tokens", String(asInt(body.maxTokens, 256, 200000, 32000)),
+			"--max-tokens", String(maxTokens),
 			"--parallel-requests", String(asInt(body.parallel, 1, 8, 1)),
 			// 流式：中转网关（Cloudflare 等）对非流式请求有 ~100s 超时（524），
 			// 高推理强度模型思考数分钟必然超时。流式保持字节流动可规避。
@@ -1116,10 +1441,38 @@ function apply(ctx) {
 		if (body.resume === true) args.push("--resume");
 		if (body.retryFailures === true) args.push("--retry-failures");
 
+		// HuggingFace 只用来取题目数据集。国内网络下 huggingface.co 常常连不通：
+		// 每次评测都要先 HEAD 请求超时重试 5 轮（1+2+4+8+8s 退避 + 每次约 21s 的连接超时，
+		// 实测刷一屏 WinError 10060），再回落到本地缓存。
+		// 本次要跑的分类**都已在缓存里**时直接离线启动：题目一样，省掉整段等待。
+		// 缺任何一个分类的缓存就不设离线 —— 保留联网下载能力，避免"新 release
+		// 的题目还没下过"这种正常场景被离线模式直接判死。
+		//
+		// 注意 `--bench-name live_bench`（全部分类）时 bench 路径里没有分类段，
+		// 必须自己补上分类列表，否则会被误判成"没缓存"→ 6 个分类各刷一遍超时重试
+		// （实测：跑到第 3 个分类已经白等 10 分钟，用户看到的"总是报错"就是这个）。
+		const hfCategories = hfCategoriesFor(benchPaths, livebenchCategories(layout.root));
+		const hfMissing = [...hfCategories].filter((cat) => !existsSync(join(layout.root, ".hf_cache", "datasets", `livebench___${cat}`)));
+		const hfCached = hfCategories.size > 0 && hfMissing.length === 0;
+		// harness 给这个渠道声明的"流多久没数据就掐断"（毫秒）→ 秒
+		const providerIdleSeconds = Number.isFinite(Number(provider?.streamIdleTimeoutMs)) && Number(provider.streamIdleTimeoutMs) > 0
+			? Math.max(30, Math.round(Number(provider.streamIdleTimeoutMs) / 1000))
+			: null;
+
 		const env = {
 			...process.env,
 			HF_HOME: join(layout.root, ".hf_cache"),
 			HF_HUB_DISABLE_SYMLINKS_WARNING: "1",
+			// 真要联网时也别卡太久：把 etag/下载超时压低，失败得快一点。
+			HF_HUB_ETAG_TIMEOUT: "5",
+			HF_HUB_DOWNLOAD_TIMEOUT: "30",
+			...(hfCached ? { HF_HUB_OFFLINE: "1", HF_DATASETS_OFFLINE: "1" } : {}),
+			// 静默看门狗阈值：优先用 harness 给这个渠道声明的 streamIdleTimeoutMs
+			// （code-claude = 120000 → 120s），没声明就不设，由 LiveBench 用自己的
+			// 保守默认（600s）。**不能一律压到 120s** —— Claude 这类模型答一道
+			// olympiad 本来就要 2~5 分钟、输出 1~2 万 token，阈值太小会把正常长思考
+			// 当成"挂住"反复掐断（实测：一题被掐 5 次、每次 120s，最后记 $ERROR$）。
+			...(providerIdleSeconds !== null ? { LIVEBENCH_STREAM_IDLE_TIMEOUT: String(providerIdleSeconds) } : {}),
 			// 限制评测进程的数值库线程（numpy/pyarrow/MKL 默认吃满全核，
 			// 多模型并发时会把 node 事件循环饿死 → websocket 断连）。
 			OMP_NUM_THREADS: "1",
@@ -1161,16 +1514,21 @@ function apply(ctx) {
 				} catch { /* credential seam unavailable — fall through to env */ }
 				if (!key && process.env[provider.keyEnv]) key = process.env[provider.keyEnv];
 			}
-			if (provider.api === "openai-completions" || provider.api === "openai-responses" || provider.api === "openai_responses") {
+			if (isAnthropicRoute) {
+				// The generated model config selects the native anthropic client;
+				// the Anthropic SDK picks endpoint+key up from these env vars and
+				// appends /v1/messages itself —— 所以这里给的是**站点根**，
+				// 不再给 --api-base（那条路只讲 OpenAI Chat Completions）。
+				if (key) env.ANTHROPIC_API_KEY = key;
+				env.ANTHROPIC_BASE_URL = anthropicRouteBase;
+			} else if (provider.api === "openai-completions" || provider.api === "openai-responses" || provider.api === "openai_responses") {
 				// openai-responses 与 openai-completions 一样走 --api-base + LIVEBENCH_API_KEY
 				// （Responses 客户端同样从 api_dict 读 base_url/api_key）。
 				args.push("--api-base", provider.baseURL);
 				if (key) env.LIVEBENCH_API_KEY = key;
 			} else if (provider.api === "anthropic-messages") {
-				// The generated model config selects the native anthropic client;
-				// the Anthropic SDK picks endpoint+key up from these env vars.
 				if (key) env.ANTHROPIC_API_KEY = key;
-				env.ANTHROPIC_BASE_URL = provider.baseURL;
+				env.ANTHROPIC_BASE_URL = anthropicRouteBase;
 			}
 		}
 
@@ -1222,11 +1580,29 @@ function apply(ctx) {
 			proc: child,
 			displayName,
 			body,
+			// 服务端解析后的 bench 列表：自动补跑扫描要用（baseline 评测没有 body.benchNames）
+			benchPaths,
 			autoRetries,
 			exitCode: null,
 			startedAt: new Date().toISOString(),
 			command: [layout.pythonExe, ...args].join(" "),
-			log: [`$ ${[...args].join(" ")}`],
+			log: [
+				`$ ${[...args].join(" ")}`,
+				...(modelMaxTokens !== null && requestedMaxTokens > modelMaxTokens
+					? [`[cap] 面板请求的 max-tokens ${requestedMaxTokens} 超过该模型在 settings.yaml 里声明的上限 ${modelMaxTokens}，本次按 ${modelMaxTokens} 发送`]
+					: []),
+				...(hfCached
+					? [`[hf] 题目数据集已在本地缓存（${[...hfCategories].join(", ")}），本次离线读取，跳过 huggingface.co 联网检查`]
+					: hfMissing.length > 0
+						? [`[hf] 以下分类的数据集还没有本地缓存：${hfMissing.join(", ")} —— 本次会联网向 huggingface.co 取；连不通时会先超时重试 5 轮再失败`]
+						: []),
+				// 路由与请求形状：出问题时这段是唯一能自证"面板到底发了什么"的地方
+				...(isAnthropicRoute
+					? [`[route] Anthropic 系模型 → anthropic-messages（POST ${anthropicRouteBase}/v1/messages）；`
+						+ `max_tokens=${maxTokens}；thinking=${JSON.stringify(thinkingModeForEffort(effort) ?? "不写（交给上游默认）")}`]
+					: [`[route] ${provider !== null ? provider.api ?? "未知协议" : "直连"} → ${args.includes("--api-base") ? `--api-base ${provider?.baseURL}` : "内置默认端点"}；`
+						+ `max_tokens=${maxTokens}（字段 ${provider?.maxTokensField ?? "默认"}）`]),
+			],
 		};
 		runs.set(record.id, record);
 		// keep history bounded: drop oldest finished runs beyond 20 entries
@@ -1245,21 +1621,26 @@ function apply(ctx) {
 		child.on("close", (code) => {
 			record.exitCode = code === null ? -1 : code;
 			record.log.push(`[exit ${record.exitCode}]`);
-			// 自动补跑：正常结束但存在 $ERROR$ 答案时，用 --resume --retry-failures
-			// 只重跑失败题（最多 2 轮）。统计改为异步流式（同步版曾阻塞事件循环，
+			// 自动补跑：正常结束但仍有 $ERROR$ 答案时，用 --resume --retry-failures
+			// 只重跑失败题（最多 3 轮）。统计改为异步流式（同步版曾阻塞事件循环，
 			// 且函数缺失会在 close 回调抛未捕获异常 → DSH 假死断连）。
+			// 复用同一个 display-name：答案写回同一个文件，只补失败的题；
+			// 换了名字就会整套重跑一遍，还在成绩表里多出一行。
 			if (record.exitCode === 0 && record.autoRetries < 3 && record.body) {
 				(async () => {
 					try {
-						const errors = await countErrorAnswersAsync(layout.dataDir, record.displayName, record.body);
+						const { errors, failedIds } = await countErrorAnswersAsync(layout.dataDir, record.displayName, record.benchPaths ?? []);
 						if (errors > 0) {
-							record.log.push(`[自动补跑] 检测到 ${errors} 条失败答案，自动重试（第 ${record.autoRetries + 1}/3 轮）`);
+							record.log.push(`[自动补跑] 检测到 ${errors} 题 API 失败（$ERROR$），`
+								+ `第 ${record.autoRetries + 1}/3 轮：只重跑这几题，其余答案与判分保留`);
 							const retryBody = { ...record.body, resume: true, retryFailures: true };
 							setTimeout(() => {
-								startRun(retryBody, record.autoRetries + 1).catch((e) => {
+								startRun(retryBody, record.autoRetries + 1, record.displayName).catch((e) => {
 									appendLog(record, `[自动补跑启动失败] ${e.message}`);
 								});
 							}, [15000, 60000, 180000][Math.min(record.autoRetries, 2)]);
+						} else {
+							record.log.push(`[自动补跑] 检查通过：${(record.benchPaths ?? []).join(", ")} 没有 $ERROR$ 答案`);
 						}
 					} catch (e) {
 						record.log.push(`[自动补跑检查失败] ${e.message}`);
@@ -1322,12 +1703,17 @@ function apply(ctx) {
 						failedCount: t.failed.length,
 					})),
 				})),
-				providers: providers.map(({ id, name: pname, models, api, baseURL }) => ({
+				providers: providers.map(({ id, name: pname, models, api, baseURL, streamIdleTimeoutMs, maxTokensField }) => ({
 					id,
 					name: pname,
 					routable: ["openai-completions", "openai-responses", "openai_responses", "anthropic-messages"].includes(api)
 						&& typeof baseURL === "string" && baseURL.length > 0,
 					baseURL: baseURL ?? null,
+					// harness 给这个渠道设的流空闲阈值（毫秒）；面板会透给 LiveBench 的静默看门狗
+					streamIdleTimeoutMs: streamIdleTimeoutMs ?? null,
+					// 会话窗口（pi-ai）发输出上限用的字段名；面板让 LiveBench 也用同一个
+					maxTokensField: maxTokensField ?? null,
+					// models 里带 maxTokens（该模型单次输出上限），面板用它夹 --max-tokens
 					models,
 				})),
 			});
@@ -1539,4 +1925,4 @@ function apply(ctx) {
 	}), `${name}: delete route`);
 }
 
-export { name, inject, apply, writeGeneratedModelConfig, readProviders, validateBenchName, clampedRangeLength, releaseQuestionCount, isEmptyAnswerLine, missingBaselineIndexes, baselineIdsFor };
+export { name, inject, apply, writeGeneratedModelConfig, readProviders, providerCapsFromSettings, maxTokensFieldFor, thinkingBudgetForEffort, thinkingModeForEffort, isAnthropicModel, anthropicBaseUrl, validateBenchName, clampedRangeLength, releaseQuestionCount, isEmptyAnswerLine, missingBaselineIndexes, baselineIdsFor, reduceAnswerLines, scoreJudgments, countErrorAnswersAsync, livebenchCategories, hfCategoriesFor };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-livebench-panel",
-  "version": "0.2.24",
+  "version": "0.2.32",
   "description": "DSH web plugin: a LiveBench tab in the Trajectory view (right of 对话/轨迹). Run LiveBench evaluations against every model configured in the DeepSeek Harness — pick provider/model, category, task, release and question range from dropdowns, watch progress, and read scores in place. Ships a Baseline probe set built from the questions a reference model cannot solve.",
   "license": "MIT",
   "author": "cszr (Vithrive)",