新增预设工作台:编辑、版本树、结构检查、用例试跑放在同一页。

改预设要能一边写一边看装出来的 messages,还要多模型对照,所以把编辑与试跑拆成两个视图塞进一个页面;版本存完整快照、可分叉,用例全局共用一份、运行记录按预设存。顺带让读预设文件先剥 BOM,静态资源改成不缓存,免得改了脚本还要强刷。
This commit is contained in:
2026-10-26 01:09:40 +08:00
parent 98e51f9c6c
commit f3303038fe
20 changed files with 6263 additions and 6 deletions
+105
View File
@@ -0,0 +1,105 @@
import { mkdtempSync, rmSync } from "node:fs";
import os from "node:os";
import path from "node:path";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import type { PresetPackage } from "../src/types/preset.js";
import { checkAuthoringPreset } from "../src/preset/authoring-check.js";
import {
checkoutVersion,
commitVersion,
loadVersionTree,
versionLineage,
} from "../src/preset/versions.js";
function preset(id: string, content = "正文"): PresetPackage {
return {
id,
name: id,
source: "native",
prompts: [
{ id: "sys", name: "规则", enabled: true, role: "system", content, marker: false, sourceIdentifier: "sys" },
{ id: "chatHistory", name: "对话历史", enabled: true, role: "system", content: "", marker: true, sourceIdentifier: "chatHistory" },
],
promptOrder: [
{ promptId: "sys", enabled: true, orderIndex: 0 },
{ promptId: "chatHistory", enabled: true, orderIndex: 1 },
],
generation: {},
unsupported: [],
importedAt: new Date().toISOString(),
};
}
let dir = "";
beforeEach(() => {
dir = mkdtempSync(path.join(os.tmpdir(), "preset-versions-"));
process.env.WRITING_AGENT_DATA_DIR = dir;
});
afterEach(() => {
delete process.env.WRITING_AGENT_DATA_DIR;
rmSync(dir, { recursive: true, force: true });
});
describe("版本树", () => {
it("线性保存并可追溯", () => {
commitVersion({ presetId: "p1", preset: preset("p1", "v1") });
const tree = commitVersion({ presetId: "p1", preset: preset("p1", "v2") });
const lineage = versionLineage(tree, tree.currentId!);
expect(lineage.map((n) => n.preset.prompts[0]!.content)).toEqual(["v1", "v2"]);
});
it("从历史节点分叉,原分支保持不变", () => {
const first = commitVersion({ presetId: "p2", preset: preset("p2", "a") });
const rootId = first.currentId!;
commitVersion({ presetId: "p2", preset: preset("p2", "b") });
const forked = commitVersion({ presetId: "p2", preset: preset("p2", "c"), parentId: rootId });
expect(forked.nodes).toHaveLength(3);
const branch = forked.nodes.filter((n) => n.parentId === rootId);
expect(branch).toHaveLength(2);
expect(versionLineage(forked, forked.currentId!)[0]!.id).toBe(rootId);
});
it("不允许再建第二个根,也不允许挂到不存在的父节点", () => {
commitVersion({ presetId: "p3", preset: preset("p3") });
expect(() => commitVersion({ presetId: "p3", preset: preset("p3"), parentId: null })).toThrow();
expect(() => commitVersion({ presetId: "p3", preset: preset("p3"), parentId: "missing" })).toThrow();
});
it("checkout 只移动当前位置,不新增节点", () => {
const tree = commitVersion({ presetId: "p4", preset: preset("p4") });
const rootId = tree.currentId!;
commitVersion({ presetId: "p4", preset: preset("p4", "x") });
const moved = checkoutVersion("p4", rootId);
expect(moved.currentId).toBe(rootId);
expect(loadVersionTree("p4").nodes).toHaveLength(2);
});
it("拒绝非法预设 id(防路径穿越)", () => {
expect(() => loadVersionTree("../evil")).toThrow();
});
});
describe("结构检查", () => {
it("正常预设没有 error", () => {
const issues = checkAuthoringPreset(preset("ok"));
expect(issues.filter((i) => i.level === "error")).toHaveLength(0);
});
it("全角 {{ 给 warn 而不是 error", () => {
const issues = checkAuthoringPreset(preset("fw", "你好 {{user{{"));
expect(issues.some((i) => i.level === "warn" && i.message.includes("全角"))).toBe(true);
expect(issues.some((i) => i.level === "error")).toBe(false);
});
it("未闭合的 {{ 为 error", () => {
const issues = checkAuthoringPreset(preset("open", "{{setvar::a::1"));
expect(issues.some((i) => i.level === "error" && i.message.includes("未闭合"))).toBe(true);
});
it("未启用对话历史位置给 warn", () => {
const p = preset("nohist");
p.promptOrder = p.promptOrder.filter((o) => o.promptId !== "chatHistory");
const issues = checkAuthoringPreset(p);
expect(issues.some((i) => i.message.includes("对话历史"))).toBe(true);
});
});
+146
View File
@@ -0,0 +1,146 @@
import { mkdtempSync, rmSync } from "node:fs";
import { Readable } from "node:stream";
import os from "node:os";
import path from "node:path";
import type { IncomingMessage, ServerResponse } from "node:http";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { savePreset } from "../src/preset/store.js";
import { handlePresetLabApi } from "../src/server/preset-lab-handlers.js";
import type { PresetPackage } from "../src/types/preset.js";
function preset(id = "lab"): PresetPackage {
return {
id,
name: "工作台预设",
source: "native",
prompts: [
{ id: "sys", name: "规则", enabled: true, role: "system", content: "\u4f60\u662f{{char}}", marker: false, sourceIdentifier: "sys" },
{ id: "chatHistory", name: "历史", enabled: true, role: "system", content: "", marker: true, sourceIdentifier: "chatHistory" },
],
promptOrder: [
{ promptId: "sys", enabled: true, orderIndex: 0 },
{ promptId: "chatHistory", enabled: true, orderIndex: 1 },
],
generation: {},
unsupported: [],
importedAt: new Date().toISOString(),
};
}
type Captured = { status: number; body: any };
async function call(
pathname: string,
init: { method?: string; body?: unknown; query?: string } = {},
): Promise<Captured> {
const raw = init.body === undefined ? "" : JSON.stringify(init.body);
const req = Readable.from(raw ? [Buffer.from(raw, "utf8")] : []) as unknown as IncomingMessage;
(req as any).method = init.method ?? "GET";
let status = 0;
let payload = "";
const res = {
writeHead(code: number) {
status = code;
},
end(chunk: string) {
payload = chunk ?? "";
},
} as unknown as ServerResponse;
const handled = await handlePresetLabApi(req, res, pathname, new URLSearchParams(init.query ?? ""));
expect(handled).toBe(true);
return { status, body: payload ? JSON.parse(payload) : null };
}
let dir = "";
beforeEach(() => {
dir = mkdtempSync(path.join(os.tmpdir(), "preset-lab-api-"));
process.env.WRITING_AGENT_DATA_DIR = dir;
savePreset(preset());
});
afterEach(() => {
delete process.env.WRITING_AGENT_DATA_DIR;
rmSync(dir, { recursive: true, force: true });
});
describe("预设工作台 API", () => {
it("非本模块路径不接管", async () => {
const req = Readable.from([]) as unknown as IncomingMessage;
(req as any).method = "GET";
const res = { writeHead() {}, end() {} } as unknown as ServerResponse;
expect(await handlePresetLabApi(req, res, "/api/settings/x", new URLSearchParams())).toBe(false);
});
it("列出预设", async () => {
const { status, body } = await call("/api/preset-lab/presets");
expect(status).toBe(200);
expect(body.presets.some((p: any) => p.id === "lab")).toBe(true);
});
it("读取单个预设与结构检查", async () => {
const one = await call("/api/preset-lab/preset", { query: "presetId=lab" });
expect(one.body.preset.id).toBe("lab");
const checked = await call("/api/preset-lab/check", { method: "POST", body: { preset: one.body.preset } });
expect(checked.body.issues.filter((i: any) => i.level === "error")).toHaveLength(0);
});
it("提交版本后能读回版本树", async () => {
const committed = await call("/api/preset-lab/versions/commit", {
method: "POST",
body: { preset: preset(), note: "第一次" },
});
expect(committed.body.nodes).toHaveLength(1);
const tree = await call("/api/preset-lab/versions", { query: "presetId=lab" });
expect(tree.body.currentId).toBe(committed.body.nodes[0].id);
});
it("保存至当前版本只覆盖节点,不新增", async () => {
const first = await call("/api/preset-lab/versions/commit", {
method: "POST",
body: { preset: preset(), note: "建根" },
});
const nodeId = first.body.currentId;
const edited = { ...preset(), name: "改过的名字" };
const amended = await call("/api/preset-lab/versions/amend", {
method: "POST",
body: { preset: edited, note: "就地改" },
});
expect(amended.body.nodes).toHaveLength(1);
expect(amended.body.currentId).toBe(nodeId);
const node = amended.body.nodes[0];
expect(node.id).toBe(nodeId);
expect(node.parentId).toBe(null);
expect(node.preset.name).toBe("改过的名字");
expect(node.note).toBe("就地改");
expect(typeof node.updatedAt).toBe("string");
});
it("预览按用例组装消息,{{char}} 被替换", async () => {
const { status, body } = await call("/api/preset-lab/preview", {
method: "POST",
body: {
preset: preset(),
testCase: { id: "c", name: "c", charName: "林", charDescription: "", worldBook: "", userInput: "开门", history: [] },
},
});
expect(status).toBe(200);
const text = body.messages.map((m: any) => m.content).join("\n");
expect(text).toContain("你是林");
expect(text).toContain("开门");
});
it("测试组保存与列出", async () => {
const saved = await call("/api/preset-lab/groups/save", {
method: "POST",
body: { presetId: "lab", name: "组一", cases: [{ name: "a", userInput: "hi" }] },
});
expect(saved.body.cases[0].id).toBeTruthy();
const groups = await call("/api/preset-lab/groups", { query: "presetId=lab" });
expect(groups.body.groups).toHaveLength(1);
});
it("缺少 preset 时返回 400 而不是崩溃", async () => {
const { status, body } = await call("/api/preset-lab/check", { method: "POST", body: {} });
expect(status).toBe(400);
expect(body.error).toContain("preset");
});
});
+221
View File
@@ -0,0 +1,221 @@
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { Readable } from "node:stream";
import os from "node:os";
import path from "node:path";
import type { IncomingMessage, ServerResponse } from "node:http";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { getPreset } from "../src/preset/store.js";
import { createNativePreset } from "../src/preset/new-preset.js";
import type { PresetPackage } from "../src/types/preset.js";
vi.mock("../src/llm/client.js", async (importOriginal) => {
const actual = await importOriginal<typeof import("../src/llm/client.js")>();
return {
...actual,
OpenAiCompatibleProvider: class {
async complete(messages: unknown[], options?: { caller?: string }) {
return {
content: `mock:${options?.caller ?? "unknown"}`,
usage: { promptTokens: 1, completionTokens: 2, totalTokens: 3 },
model: "mock-model",
messages,
};
}
},
};
});
import { handlePresetLabApi } from "../src/server/preset-lab-handlers.js";
type Captured = { status: number; body: any };
async function call(
pathname: string,
init: { method?: string; body?: unknown; query?: string } = {},
): Promise<Captured> {
const raw = init.body === undefined ? "" : JSON.stringify(init.body);
const req = Readable.from(raw ? [Buffer.from(raw, "utf8")] : []) as unknown as IncomingMessage;
(req as any).method = init.method ?? "GET";
let status = 0;
let payload = "";
const res = {
writeHead(code: number) {
status = code;
},
end(chunk: string) {
payload = chunk ?? "";
},
} as unknown as ServerResponse;
const handled = await handlePresetLabApi(req, res, pathname, new URLSearchParams(init.query ?? ""));
expect(handled).toBe(true);
return { status, body: payload ? JSON.parse(payload) : null };
}
function writeProfiles(dir: string): void {
mkdirSync(dir, { recursive: true });
const now = new Date().toISOString();
writeFileSync(
path.join(dir, "profiles.json"),
JSON.stringify({
version: 1,
profiles: [
{
id: "p1",
name: "本地模型",
baseUrl: "https://example.invalid/v1",
apiKey: "test-key",
model: "mock-model",
createdAt: now,
updatedAt: now,
},
],
}),
"utf8",
);
}
let dir = "";
beforeEach(() => {
dir = mkdtempSync(path.join(os.tmpdir(), "preset-lab-workbench-"));
process.env.WRITING_AGENT_DATA_DIR = dir;
writeProfiles(dir);
});
afterEach(() => {
delete process.env.WRITING_AGENT_DATA_DIR;
rmSync(dir, { recursive: true, force: true });
vi.restoreAllMocks();
});
describe("工作台新建与写回", () => {
it("读取带 BOM 的预设文件", () => {
const presetsDir = path.join(dir, "presets");
mkdirSync(presetsDir, { recursive: true });
const preset = createNativePreset({ id: "bom", name: "BOM" });
writeFileSync(path.join(presetsDir, "bom.json"), `\uFEFF${JSON.stringify(preset)}`, "utf8");
expect(getPreset("bom")?.name).toBe("BOM");
});
it("新建原生预设并生成根版本", async () => {
const { status, body } = await call("/api/preset-lab/presets/create", {
method: "POST",
body: { name: "新预设", id: "fresh" },
});
expect(status).toBe(201);
expect(body.preset.id).toBe("fresh");
expect(body.preset.source).toBe("native");
expect(body.tree.nodes).toHaveLength(1);
expect(body.preset.prompts.some((p: any) => p.id === "chatHistory" && p.marker)).toBe(true);
expect(body.preset.prompts.some((p: any) => p.id === "currentTurn" && p.marker)).toBe(true);
expect(getPreset("fresh")?.name).toBe("新预设");
});
it("写回前拦截结构 error,force 才落盘", async () => {
const created = await call("/api/preset-lab/presets/create", {
method: "POST",
body: { name: "写回", id: "apply-me" },
});
const preset = created.body.preset as PresetPackage;
preset.prompts[0]!.content = "{{setvar::a::1";
const blocked = await call("/api/preset-lab/preset/apply", {
method: "POST",
body: { preset },
});
expect(blocked.status).toBe(400);
expect(blocked.body.error).toContain("结构检查");
const forced = await call("/api/preset-lab/preset/apply", {
method: "POST",
body: { preset, force: true },
});
expect(forced.status).toBe(200);
expect(getPreset("apply-me")?.prompts[0]!.content).toContain("setvar");
});
it("三花括号是合法的字面量花括号,不算未闭合宏", async () => {
const created = await call("/api/preset-lab/presets/create", {
method: "POST",
body: { name: "三花括号", id: "triple" },
});
const preset = created.body.preset as PresetPackage;
preset.prompts[0]!.content = "{{{setvar::SEMOD1::}}正文";
const checked = await call("/api/preset-lab/check", {
method: "POST",
body: { preset },
});
expect(checked.body.issues.filter((i: any) => i.level === "error")).toHaveLength(0);
});
it("重复引用同一模块是 error", async () => {
const created = await call("/api/preset-lab/presets/create", {
method: "POST",
body: { name: "重复", id: "dup-order" },
});
const preset = created.body.preset as PresetPackage;
preset.promptOrder.push({ ...preset.promptOrder[0]!, orderIndex: 99 });
const checked = await call("/api/preset-lab/check", {
method: "POST",
body: { preset },
});
expect(checked.body.issues.some((i: any) => i.level === "error" && i.message.includes("重复"))).toBe(true);
});
});
describe("草稿运行", () => {
it("run 使用请求里的草稿而不是旧版本文件", async () => {
const created = await call("/api/preset-lab/presets/create", {
method: "POST",
body: { name: "草稿", id: "draft-run" },
});
const preset = created.body.preset as PresetPackage;
preset.prompts[0]!.content = "草稿规则 {{char}}";
const group = await call("/api/preset-lab/groups/save", {
method: "POST",
body: {
presetId: preset.id,
name: "组",
cases: [{ name: "开门", charName: "林", userInput: "我推门" }],
},
});
const run = await call("/api/preset-lab/run", {
method: "POST",
body: {
presetId: preset.id,
groupId: group.body.id,
profileIds: ["p1"],
preset,
},
});
expect(run.status).toBe(200);
expect(run.body.results).toHaveLength(1);
expect(run.body.results[0].status).toBe("done");
expect(run.body.results[0].caseName).toBe("开门");
expect(run.body.results[0].content).toContain("mock:preset-test:p1");
expect(run.body.requests[0].messages.map((m: any) => m.content).join("\n")).toContain("草稿规则 林");
expect(run.body.requests[0].messages.map((m: any) => m.content).join("\n")).toContain("我推门");
const runs = await call("/api/preset-lab/runs", { query: `presetId=${preset.id}` });
expect(runs.body.runs).toHaveLength(1);
expect(runs.body.runs[0].id).toBe(run.body.id);
const one = await call("/api/preset-lab/run", {
query: `presetId=${preset.id}&runId=${run.body.id}`,
});
expect(one.body.results[0].caseName).toBe("开门");
const marked = await call("/api/preset-lab/verdict", {
method: "POST",
body: {
presetId: preset.id,
runId: run.body.id,
profileId: "p1",
caseId: run.body.results[0].caseId,
verdict: "success",
},
});
expect(marked.body.results[0].verdict).toBe("success");
});
});
+177
View File
@@ -0,0 +1,177 @@
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
import os from "node:os";
import path from "node:path";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import type { PresetPackage } from "../src/types/preset.js";
import { buildCaseMessages } from "../src/preset/test-run.js";
import { getTestRun, saveTestRun, updateVerdict } from "../src/preset/test-runs.js";
import { deleteTestGroup, getTestGroup, listTestGroups, saveTestGroup } from "../src/preset/test-cases.js";
import { deleteTestCase, listTestCases, saveTestCase } from "../src/preset/test-cases.js";
import { loadPresetLabState, savePresetLabState } from "../src/preset/lab-state.js";
function preset(): PresetPackage {
return {
id: "pp",
name: "pp",
source: "native",
prompts: [
{ id: "sys", name: "规则", enabled: true, role: "system", content: "你是{{char}}的叙事者", marker: false, sourceIdentifier: "sys" },
{ id: "worldInfoBefore", name: "世界书", enabled: true, role: "system", content: "", marker: true, sourceIdentifier: "worldInfoBefore" },
{ id: "charDescription", name: "角色描述", enabled: true, role: "system", content: "", marker: true, sourceIdentifier: "charDescription" },
{ id: "chatHistory", name: "历史", enabled: true, role: "system", content: "", marker: true, sourceIdentifier: "chatHistory" },
{ id: "currentTurn", name: "本轮", enabled: true, role: "user", content: "", marker: true, sourceIdentifier: "currentTurn" },
],
promptOrder: [
{ promptId: "sys", enabled: true, orderIndex: 0 },
{ promptId: "worldInfoBefore", enabled: true, orderIndex: 1 },
{ promptId: "charDescription", enabled: true, orderIndex: 2 },
{ promptId: "chatHistory", enabled: true, orderIndex: 3 },
{ promptId: "currentTurn", enabled: true, orderIndex: 4 },
],
generation: {},
unsupported: [],
importedAt: new Date().toISOString(),
};
}
let dir = "";
beforeEach(() => {
dir = mkdtempSync(path.join(os.tmpdir(), "preset-tests-"));
process.env.WRITING_AGENT_DATA_DIR = dir;
});
afterEach(() => {
delete process.env.WRITING_AGENT_DATA_DIR;
rmSync(dir, { recursive: true, force: true });
});
describe("测试用例组", () => {
it("保存、读取、列出、删除", () => {
const g = saveTestGroup({
name: "基础",
cases: [{ name: "c1", charName: "林", charDescription: "冷静", worldBook: "古镇", userInput: "进门" }],
});
expect(g.cases[0]!.id).toBeTruthy();
expect(getTestGroup(g.id)?.cases[0]!.charName).toBe("林");
expect(listTestGroups()).toHaveLength(1);
deleteTestGroup(g.id);
expect(listTestGroups()).toHaveLength(0);
});
});
describe("用例(工作台的展示单位)", () => {
it("新用例落成只装它的一份组文件,平铺列表能读回", () => {
const saved = saveTestCase({
case: { name: "开门", userInput: "我推开门" },
});
expect(saved.groupId).toBeTruthy();
expect(saved.case.id).toBeTruthy();
expect(listTestCases().map((item) => item.case.name)).toEqual(["开门"]);
expect(listTestGroups()).toHaveLength(1);
});
it("用例全局共享:换预设也能读到同一套", () => {
saveTestCase({ case: { name: "全局用例", userInput: "甲" } });
// 没有任何 presetId 参与,读取时也不需要
expect(listTestCases().map((item) => item.case.name)).toEqual(["全局用例"]);
expect(listTestGroups()[0]!.presetId).toBe("global");
});
it("旧版按预设分目录的用例会被并进全局目录", () => {
const legacyDir = path.join(dir, "presets", "tests", "pp");
mkdirSync(legacyDir, { recursive: true });
writeFileSync(
path.join(legacyDir, "old12345.json"),
JSON.stringify({
id: "old12345",
presetId: "pp",
name: "旧组",
updatedAt: "2024-01-01T00:00:00.000Z",
cases: [{ id: "c1", name: "老用例", charName: "", charDescription: "", worldBook: "", userInput: "x", history: [] }],
}),
"utf8",
);
expect(listTestCases().map((item) => item.case.name)).toEqual(["老用例"]);
expect(getTestGroup("old12345")!.presetId).toBe("global");
});
it("存回旧组里的用例时不动同组其他用例", () => {
const group = saveTestGroup({
name: "旧组",
cases: [{ name: "A", userInput: "甲" }, { name: "B", userInput: "乙" }],
});
const target = group.cases[1]!;
saveTestCase({
groupId: group.id,
case: { ...target, userInput: "乙改" },
});
const after = getTestGroup(group.id)!.cases;
expect(after.map((item) => item.userInput)).toEqual(["甲", "乙改"]);
});
it("删除最后一份用例时把空组文件一起收掉", () => {
const saved = saveTestCase({ case: { name: "单条" } });
deleteTestCase(saved.groupId, saved.case.id);
expect(listTestCases()).toEqual([]);
expect(listTestGroups()).toEqual([]);
});
});
describe("预设的试跑状态", () => {
it("按预设记住打开的是哪条用例,重读还在", () => {
expect(loadPresetLabState("pp").selectedCaseId).toBe(null);
savePresetLabState("pp", { selectedCaseId: "c1" });
expect(loadPresetLabState("pp").selectedCaseId).toBe("c1");
// 另一个预设不受影响
expect(loadPresetLabState("qq").selectedCaseId).toBe(null);
// 只传 previewCaseId 时不抹掉 selectedCaseId
savePresetLabState("pp", { previewCaseId: "c2" });
const state = loadPresetLabState("pp");
expect(state.selectedCaseId).toBe("c1");
expect(state.previewCaseId).toBe("c2");
});
});
describe("用例消息组装", () => {
it("char 描述、世界书、历史、用户输入按顺序进入 messages,且 {{char}} 被替换", () => {
const msgs = buildCaseMessages(preset(), {
id: "c", name: "c", charName: "林", charDescription: "冷静的侦探", worldBook: "古镇夜雨",
userInput: "我推门", history: [{ role: "assistant", content: "门开了。" }],
});
const text = msgs.map((m) => `${m.role}:${m.content}`);
expect(text[0]).toContain("你是林的叙事者");
expect(text.join("\n")).toContain("古镇夜雨");
expect(text.join("\n")).toContain("冷静的侦探");
expect(text[text.length - 1]).toBe("user:我推门");
expect(text).toContain("assistant:门开了。");
});
it("关掉 currentTurn 位置后,用户输入不再进入 messages", () => {
const p = preset();
const turn = p.promptOrder.find((item) => item.promptId === "currentTurn");
if (turn) turn.enabled = false;
const msgs = buildCaseMessages(p, {
id: "c", name: "c", charName: "林", charDescription: "", worldBook: "",
userInput: "这句不该出现", history: [],
});
expect(msgs.map((m) => m.content).join("\n")).not.toContain("这句不该出现");
});
it("只替换变动项:同一预设、不同用例的 system 规则保持一致", () => {
const a = buildCaseMessages(preset(), { id: "a", name: "a", charName: "甲", charDescription: "", worldBook: "", userInput: "x", history: [] });
const b = buildCaseMessages(preset(), { id: "b", name: "b", charName: "甲", charDescription: "", worldBook: "", userInput: "y", history: [] });
// 默认整形为 strict:system 会并入相邻 user,故只比较规则文本是否都在首条里\n expect(a[0]!.content.startsWith("你是甲的叙事者")).toBe(true);\n expect(b[0]!.content.startsWith("你是甲的叙事者")).toBe(true);\n expect(a[0]!.content.replace("x", "")).toBe(b[0]!.content.replace("y", ""));
});
});
describe("运行记录与手动标记", () => {
it("保存后可以修改标记并落盘", () => {
saveTestRun({
id: "r1", presetId: "pp", presetVersionId: "v1", groupId: "g", createdAt: new Date().toISOString(),
requests: [], issues: [],
results: [{ profileId: "p", profileName: "P", model: "m", caseId: "c", status: "done", verdict: null, startedAt: "" }],
});
updateVerdict("pp", "r1", "p", "c", "success");
expect(getTestRun("pp", "r1")!.results[0]!.verdict).toBe("success");
});
});