1313 lines
43 KiB
JavaScript
1313 lines
43 KiB
JavaScript
import assert from "node:assert/strict";
|
||
import { spawn } from "node:child_process";
|
||
import { mkdirSync, rmSync } from "node:fs";
|
||
import { DatabaseSync } from "node:sqlite";
|
||
import path from "node:path";
|
||
import { fileURLToPath } from "node:url";
|
||
import {
|
||
classifyContinuationReply,
|
||
detectConversationContinuation,
|
||
isActionableSkillContinuation,
|
||
isLikelySkillContinuationReply,
|
||
} from "../src/lib/skill-continuation.ts";
|
||
import {
|
||
findUnsupportedSkillCapabilities,
|
||
getSkillCapabilityViolations,
|
||
} from "../src/lib/skill-capabilities.ts";
|
||
import { isSuggestionWithinNodeScope } from "../src/lib/skill-recommendation-scope.ts";
|
||
import {
|
||
evaluateSkillNodeQuality,
|
||
getSkillNodeQualityIssues,
|
||
} from "../src/lib/skill-node-quality.ts";
|
||
import { estimateDeepSeekCallUsage } from "../src/lib/model-usage.ts";
|
||
|
||
const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
|
||
const port = 3310 + (process.pid % 200);
|
||
const baseUrl = `http://127.0.0.1:${port}`;
|
||
const tempDir = path.join(root, ".acceptance");
|
||
const databasePath = path.join(tempDir, `skillloom-${process.pid}.db`);
|
||
const nextBin = path.join(root, "node_modules", "next", "dist", "bin", "next");
|
||
|
||
mkdirSync(tempDir, { recursive: true });
|
||
const legacyDatabase = new DatabaseSync(databasePath);
|
||
legacyDatabase.exec(`
|
||
CREATE TABLE conversations (
|
||
id TEXT PRIMARY KEY,
|
||
title TEXT NOT NULL,
|
||
retained_skill_ids TEXT NOT NULL DEFAULT '[]',
|
||
created_at TEXT NOT NULL,
|
||
updated_at TEXT NOT NULL
|
||
);
|
||
INSERT INTO conversations
|
||
(id, title, retained_skill_ids, created_at, updated_at)
|
||
VALUES
|
||
('legacy_conversation', '', '["skill_sql_guard"]',
|
||
'2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z');
|
||
`);
|
||
legacyDatabase.close();
|
||
|
||
const server = spawn(process.execPath, [nextBin, "start", "-p", String(port)], {
|
||
cwd: root,
|
||
env: {
|
||
...process.env,
|
||
DATABASE_PATH: databasePath,
|
||
DEEPSEEK_API_KEY: "",
|
||
NEXT_TELEMETRY_DISABLED: "1",
|
||
},
|
||
stdio: ["ignore", "pipe", "pipe"],
|
||
});
|
||
|
||
let serverLog = "";
|
||
server.stdout.on("data", (chunk) => {
|
||
serverLog += chunk.toString();
|
||
});
|
||
server.stderr.on("data", (chunk) => {
|
||
serverLog += chunk.toString();
|
||
});
|
||
|
||
async function waitForServer() {
|
||
for (let attempt = 0; attempt < 60; attempt += 1) {
|
||
try {
|
||
const response = await fetch(`${baseUrl}/api/chat`);
|
||
if (response.ok) return;
|
||
} catch {
|
||
// The server has not opened its port yet.
|
||
}
|
||
await new Promise((resolve) => setTimeout(resolve, 250));
|
||
}
|
||
throw new Error(`测试服务未启动：\n${serverLog}`);
|
||
}
|
||
|
||
async function jsonRequest(url, init) {
|
||
const response = await fetch(`${baseUrl}${url}`, init);
|
||
const payload = await response.json().catch(() => null);
|
||
if (!response.ok) {
|
||
throw new Error(`${init?.method ?? "GET"} ${url}: ${JSON.stringify(payload)}`);
|
||
}
|
||
return payload;
|
||
}
|
||
|
||
async function readSse(response) {
|
||
assert.equal(response.ok, true, `SSE 请求失败：${response.status}`);
|
||
assert.ok(response.body, "SSE 响应没有 body");
|
||
const reader = response.body.getReader();
|
||
const decoder = new TextDecoder();
|
||
let buffer = "";
|
||
const events = [];
|
||
|
||
while (true) {
|
||
const { done, value } = await reader.read();
|
||
if (done) break;
|
||
buffer += decoder.decode(value, { stream: true });
|
||
const blocks = buffer.split(/\r?\n\r?\n/);
|
||
buffer = blocks.pop() ?? "";
|
||
for (const block of blocks) {
|
||
const data = block
|
||
.split(/\r?\n/)
|
||
.filter((line) => line.startsWith("data:"))
|
||
.map((line) => line.slice(5).trim())
|
||
.join("\n");
|
||
if (data) events.push(JSON.parse(data));
|
||
}
|
||
}
|
||
return events;
|
||
}
|
||
|
||
async function readFirstSseBatch(response) {
|
||
assert.ok(response.body, "SSE 响应没有 body");
|
||
const reader = response.body.getReader();
|
||
const decoder = new TextDecoder();
|
||
const { value } = await reader.read();
|
||
await reader.cancel();
|
||
const text = decoder.decode(value);
|
||
return text
|
||
.split(/\r?\n\r?\n/)
|
||
.map((block) =>
|
||
block
|
||
.split(/\r?\n/)
|
||
.filter((line) => line.startsWith("data:"))
|
||
.map((line) => line.slice(5).trim())
|
||
.join("\n"),
|
||
)
|
||
.filter(Boolean)
|
||
.map((data) => JSON.parse(data));
|
||
}
|
||
|
||
const definitions = [
|
||
["trigger", "触发条件", "什么时候应该使用这个 Skill，以及不适用的边界。"],
|
||
["inputs", "输入参数", "执行所需的信息、字段、格式和默认值。"],
|
||
["steps", "执行步骤", "AI 应严格遵循的行动顺序与关键判断。"],
|
||
["output", "输出格式", "最终交付物的结构、字段、语气和示例。"],
|
||
["constraints", "约束与测试", "禁止事项、质量门槛、失败处理和验收用例。"],
|
||
];
|
||
|
||
let nodes = definitions.map(([key, title, description]) => ({
|
||
key,
|
||
title,
|
||
description,
|
||
content: "",
|
||
ready: false,
|
||
completed: false,
|
||
}));
|
||
let skillName = "未命名 Skill";
|
||
let skillDescription = "";
|
||
let builderMessages = [];
|
||
let pendingProposal = null;
|
||
|
||
async function builderTurn(message) {
|
||
const clientRequestId = `acceptance_builder_${crypto.randomUUID()}`;
|
||
const requestBody = (afterSeq) =>
|
||
JSON.stringify({
|
||
clientRequestId,
|
||
afterSeq,
|
||
skillId: null,
|
||
message,
|
||
skillName,
|
||
skillDescription,
|
||
pendingProposal,
|
||
nodes,
|
||
messages: builderMessages,
|
||
});
|
||
const response = await fetch(`${baseUrl}/api/skills/builder`, {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: requestBody(0),
|
||
});
|
||
|
||
let events;
|
||
if (builderMessages.length === 0) {
|
||
const firstEvents = await readFirstSseBatch(response);
|
||
const cursor = Math.max(...firstEvents.map((event) => event.seq ?? 0));
|
||
const resumed = await fetch(`${baseUrl}/api/skills/builder`, {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: requestBody(cursor),
|
||
});
|
||
events = [...firstEvents, ...(await readSse(resumed))];
|
||
const sequences = events.map((event) => event.seq).filter(Boolean);
|
||
assert.equal(
|
||
new Set(sequences).size,
|
||
sequences.length,
|
||
"Builder 重连不得重复事件",
|
||
);
|
||
} else {
|
||
events = await readSse(response);
|
||
}
|
||
const update = events.find((event) => event.type === "builder_update");
|
||
assert.ok(update, "Builder 必须返回结构化节点更新");
|
||
assert.ok(
|
||
Array.isArray(update.evaluation.suggestions) &&
|
||
update.evaluation.suggestions.length >= 2 &&
|
||
update.evaluation.suggestions.length <= 4,
|
||
"Builder 必须返回 2-4 条结构化 AI 智能建议",
|
||
);
|
||
assert.equal(
|
||
update.evaluation.suggestionNodeKey,
|
||
update.evaluation.activeNode,
|
||
"Builder 推荐必须明确归属于当前待完善节点",
|
||
);
|
||
assert.equal(
|
||
update.evaluation.nodeQuality.length,
|
||
5,
|
||
"Builder 必须返回五节点质量判定，便于排查进度原因",
|
||
);
|
||
assert.ok(
|
||
events.some((event) => event.type === "complete"),
|
||
"Builder 必须发出完成事件",
|
||
);
|
||
nodes = update.evaluation.nodes;
|
||
skillName = update.evaluation.skillName;
|
||
skillDescription = update.evaluation.skillDescription;
|
||
pendingProposal = update.evaluation.proposal;
|
||
const reply = events
|
||
.filter((event) => event.type === "token")
|
||
.map((event) => event.token)
|
||
.join("");
|
||
builderMessages.push(
|
||
{ role: "user", content: message },
|
||
{ role: "assistant", content: reply },
|
||
);
|
||
return { evaluation: update.evaluation, reply };
|
||
}
|
||
|
||
async function runAcceptance() {
|
||
await waitForServer();
|
||
console.log("✓ 测试服务与独立 SQLite 已启动");
|
||
|
||
const initialPageResponse = await fetch(baseUrl);
|
||
const initialPageHtml = await initialPageResponse.text();
|
||
assert.equal(initialPageResponse.ok, true, "工作台首屏必须可以直接访问");
|
||
assert.doesNotMatch(
|
||
initialPageHtml,
|
||
/正在打开工作台/,
|
||
"首屏不得依赖客户端 effect 才能离开加载状态",
|
||
);
|
||
assert.match(
|
||
initialPageHtml,
|
||
/有什么我可以帮你/,
|
||
"服务端首屏必须直接输出可用的工作台内容",
|
||
);
|
||
console.log("✓ 工作台首屏由服务端数据直接渲染，不会卡在加载状态");
|
||
|
||
const migratedChat = await jsonRequest("/api/chat");
|
||
assert.equal(migratedChat.continuation.state, "awaiting_input");
|
||
assert.deepEqual(migratedChat.continuation.skillIds, ["skill_sql_guard"]);
|
||
assert.equal(migratedChat.continuation.source, "fallback");
|
||
console.log("✓ 旧版 retained_skill_ids 已兼容迁移为显式续接状态");
|
||
|
||
const pricedUsage = estimateDeepSeekCallUsage({
|
||
model: "deepseek-v4-flash",
|
||
promptTokens: 3_000,
|
||
promptCacheHitTokens: 1_000,
|
||
promptCacheMissTokens: 2_000,
|
||
completionTokens: 800,
|
||
});
|
||
assert.equal(pricedUsage.totalTokens, 3_800);
|
||
assert.equal(
|
||
pricedUsage.estimatedCostMicros,
|
||
3_620,
|
||
"费用必须分别按缓存命中输入、未命中输入和输出计算",
|
||
);
|
||
console.log("✓ Token 用量按模型价格快照计算预计费用");
|
||
|
||
const concreteOffer =
|
||
"需要我根据你的实际可用时间调整这份学习计划吗？";
|
||
assert.equal(
|
||
isActionableSkillContinuation(concreteOffer),
|
||
true,
|
||
"带有明确动作和对象的后续提议必须保留 Skill",
|
||
);
|
||
assert.equal(
|
||
detectConversationContinuation(concreteOffer)?.state,
|
||
"offer_pending",
|
||
"具体后续提议必须显式记录为等待确认",
|
||
);
|
||
assert.equal(classifyContinuationReply("需要"), "accept");
|
||
assert.equal(classifyContinuationReply("每天 1 小时"), "answer");
|
||
assert.equal(classifyContinuationReply("不用了"), "decline");
|
||
assert.equal(
|
||
isActionableSkillContinuation("如果需要，我可以继续帮助你。"),
|
||
false,
|
||
"泛泛的礼貌性邀请不得让 Skill 一直保留",
|
||
);
|
||
assert.equal(
|
||
isLikelySkillContinuationReply("需要", [
|
||
{ role: "assistant", content: concreteOffer },
|
||
]),
|
||
true,
|
||
"简短的接受回复必须识别为上一轮的延续",
|
||
);
|
||
assert.equal(
|
||
isLikelySkillContinuationReply("帮我查一下天气", [
|
||
{ role: "assistant", content: concreteOffer },
|
||
]),
|
||
false,
|
||
"用户切换到新任务时不得强制沿用旧 Skill",
|
||
);
|
||
console.log("✓ 具体后续提议可续接，礼貌邀请与新话题不会粘住 Skill");
|
||
|
||
assert.deepEqual(
|
||
findUnsupportedSkillCapabilities(
|
||
"自动调用外部 API 获取数据，再运行 Python 脚本生成报告。",
|
||
),
|
||
["运行脚本、代码或命令", "调用外部 API 或第三方服务"],
|
||
"必须识别当前工作台无法执行的能力承诺",
|
||
);
|
||
assert.deepEqual(
|
||
findUnsupportedSkillCapabilities(
|
||
"审阅用户提供的 API 文档；不得调用外部 API 或运行本地脚本。",
|
||
),
|
||
[],
|
||
"允许审阅 API/脚本内容，也允许把禁止调用写入约束",
|
||
);
|
||
assert.deepEqual(
|
||
findUnsupportedSkillCapabilities(
|
||
"指导用户如何调用 API，并要求用户手动运行脚本后粘贴结果。",
|
||
),
|
||
[],
|
||
"允许提供手动操作指导，只禁止 Skill 声称自行执行",
|
||
);
|
||
console.log("✓ Skill 能力边界只拦截执行承诺，不误伤审阅类任务");
|
||
|
||
assert.equal(
|
||
isSuggestionWithinNodeScope(
|
||
"trigger",
|
||
"当用户需要把会议记录整理成行动项时触发",
|
||
),
|
||
true,
|
||
);
|
||
assert.equal(
|
||
isSuggestionWithinNodeScope(
|
||
"trigger",
|
||
"输出使用 Markdown 表格并包含责任人字段",
|
||
),
|
||
false,
|
||
"触发条件阶段不得推荐输出格式内容",
|
||
);
|
||
assert.equal(
|
||
isSuggestionWithinNodeScope(
|
||
"output",
|
||
"新增一个资源推荐模块并给出部署方案",
|
||
),
|
||
false,
|
||
"不得推荐五个节点以外的额外模块或部署方案",
|
||
);
|
||
console.log("✓ 推荐内容严格归属于当前五节点之一");
|
||
|
||
assert.equal(
|
||
evaluateSkillNodeQuality("steps", "分析内容并生成结果").complete,
|
||
false,
|
||
"没有明确顺序和多个动作的执行步骤不得完成",
|
||
);
|
||
assert.equal(
|
||
evaluateSkillNodeQuality(
|
||
"steps",
|
||
"先检查输入，再提取关键信息，然后生成结果并复核。",
|
||
).complete,
|
||
true,
|
||
"满足确定性标准的执行步骤应当完成",
|
||
);
|
||
console.log("✓ 节点完成度由确定性质量标准复核");
|
||
|
||
const initialSuggestions = await jsonRequest(
|
||
"/api/skills/builder/suggestions",
|
||
{
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
skillName,
|
||
skillDescription,
|
||
nodes,
|
||
}),
|
||
},
|
||
);
|
||
assert.equal(
|
||
initialSuggestions.source,
|
||
"demo",
|
||
"无 AI 配置时必须明确标记为演示建议",
|
||
);
|
||
assert.equal(
|
||
initialSuggestions.nodeKey,
|
||
"trigger",
|
||
"推荐结果必须明确声明所属节点",
|
||
);
|
||
assert.ok(
|
||
initialSuggestions.suggestions.length >= 2 &&
|
||
initialSuggestions.suggestions.length <= 4,
|
||
"节点进入时必须返回 2-4 条可直接发送的建议",
|
||
);
|
||
assert.equal(
|
||
initialSuggestions.suggestions.some(
|
||
(suggestion) =>
|
||
findUnsupportedSkillCapabilities(suggestion).length > 0 ||
|
||
!isSuggestionWithinNodeScope("trigger", suggestion),
|
||
),
|
||
false,
|
||
"节点推荐不得越出当前节点或包含不支持的能力",
|
||
);
|
||
console.log("✓ 节点进入建议有明确来源和严格结构");
|
||
|
||
const guidanceTurn = await builderTurn("有哪些典型任务");
|
||
assert.equal(
|
||
guidanceTurn.evaluation.intent,
|
||
"request_guidance",
|
||
"向 AI 索要示例时必须识别为求助意图",
|
||
);
|
||
assert.equal(
|
||
guidanceTurn.evaluation.updatedNodeKeys.length,
|
||
0,
|
||
"求助问题不得写入任何 Skill 节点",
|
||
);
|
||
assert.equal(
|
||
nodes.filter((node) => node.completed).length,
|
||
0,
|
||
"求助问题不得完成当前节点",
|
||
);
|
||
assert.match(
|
||
guidanceTurn.reply,
|
||
/例如|比如|常见/,
|
||
"AI 应先提供示例或解释，再继续追问",
|
||
);
|
||
console.log("✓ 求助/索要示例不会写入或完成 Skill 节点");
|
||
|
||
const unsupportedTurn = await builderTurn(
|
||
"执行步骤：调用外部 API 获取实时数据，再运行 Python 脚本生成报告。",
|
||
);
|
||
assert.equal(
|
||
unsupportedTurn.evaluation.intent,
|
||
"request_guidance",
|
||
"超出工作台能力边界的要求必须转为引导",
|
||
);
|
||
assert.deepEqual(
|
||
unsupportedTurn.evaluation.updatedNodeKeys,
|
||
[],
|
||
"脚本执行和外部 API 调用不得写入 Skill 节点",
|
||
);
|
||
assert.match(
|
||
unsupportedTurn.reply,
|
||
/不支持|用户.*提供|手动/,
|
||
"必须解释限制并提供对话内可执行的替代方案",
|
||
);
|
||
console.log("✓ Builder 拒绝脚本/API 执行能力并给出可行替代");
|
||
|
||
const incompleteTurn = await builderTurn("做一套清单");
|
||
assert.equal(
|
||
incompleteTurn.evaluation.action,
|
||
"proposed",
|
||
"规范内容必须先作为待确认提案返回",
|
||
);
|
||
assert.equal(
|
||
nodes.every((node) => node.content === ""),
|
||
true,
|
||
"用户确认前不得写入任何节点内容",
|
||
);
|
||
assert.match(
|
||
incompleteTurn.reply,
|
||
/待确认|确认写入/,
|
||
"聊天回复必须明确展示待确认状态",
|
||
);
|
||
const confirmedIncompleteTurn = await builderTurn("确认写入");
|
||
assert.equal(
|
||
confirmedIncompleteTurn.evaluation.action,
|
||
"applied",
|
||
"用户确认后才允许写入提案",
|
||
);
|
||
assert.equal(
|
||
nodes.filter((node) => node.completed).length,
|
||
0,
|
||
"信息不足时节点不能提前完成",
|
||
);
|
||
assert.match(
|
||
confirmedIncompleteTurn.reply,
|
||
/[？?]/,
|
||
"确认写入的信息仍不足时 AI 必须继续追问",
|
||
);
|
||
|
||
const multiNodeTurn = await builderTurn(
|
||
[
|
||
"触发条件：当用户需要把产品需求整理成验收清单时触发，不处理闲聊。",
|
||
"输入参数：必填产品需求和目标用户，可选优先级、平台与发布日期。",
|
||
"执行步骤：先拆目标，再识别用户路径，然后生成正常、异常和边界场景。",
|
||
"约束与测试：不得臆测未给出的业务规则，每条必须可独立执行并包含反例。",
|
||
].join("；"),
|
||
);
|
||
assert.deepEqual(
|
||
multiNodeTurn.evaluation.proposedNodeKeys,
|
||
["trigger", "inputs", "steps", "constraints"],
|
||
"一条连贯消息涵盖多个节点时，AI 必须一次归类全部提案内容",
|
||
);
|
||
assert.deepEqual(
|
||
multiNodeTurn.evaluation.updatedNodeKeys,
|
||
[],
|
||
"多节点提案确认前不得产生实际更新",
|
||
);
|
||
assert.equal(
|
||
nodes.filter((node) => node.completed).length,
|
||
0,
|
||
"多节点提案确认前进度不得变化",
|
||
);
|
||
|
||
const revisedMultiNodeTurn = await builderTurn(
|
||
"输入参数改为：必填产品需求、目标用户和验收环境，可选优先级与发布日期。",
|
||
);
|
||
assert.equal(
|
||
revisedMultiNodeTurn.evaluation.action,
|
||
"proposed",
|
||
"修改意见必须生成新版提案，而不是直接写入",
|
||
);
|
||
assert.match(
|
||
pendingProposal.updates.find((update) => update.nodeKey === "inputs")
|
||
?.content ?? "",
|
||
/验收环境/,
|
||
"新版提案必须吸收用户的修改意见",
|
||
);
|
||
assert.equal(
|
||
nodes.filter((node) => node.completed).length,
|
||
0,
|
||
"修改待确认提案时节点仍不得变化",
|
||
);
|
||
|
||
const confirmedMultiNodeTurn = await builderTurn("确认写入");
|
||
assert.deepEqual(
|
||
confirmedMultiNodeTurn.evaluation.updatedNodeKeys,
|
||
["trigger", "inputs", "steps", "constraints"],
|
||
"确认后必须一次写入完整的多节点提案",
|
||
);
|
||
assert.equal(
|
||
nodes.filter((node) => node.completed).length,
|
||
3,
|
||
"第 4 节点缺失时，只能连续完成第 1-3 节点",
|
||
);
|
||
assert.equal(
|
||
nodes.find((node) => node.key === "constraints")?.ready,
|
||
true,
|
||
"第 5 节点的合格内容必须保留为待解锁",
|
||
);
|
||
assert.equal(
|
||
nodes.find((node) => node.key === "constraints")?.completed,
|
||
false,
|
||
"存在第 4 节点缺口时不得跳到第 5 节点",
|
||
);
|
||
|
||
const filledGap = await builderTurn(
|
||
"输出格式：输出 Markdown 表格，字段为编号、前置条件、操作、预期结果。",
|
||
);
|
||
assert.deepEqual(
|
||
filledGap.evaluation.proposedNodeKeys,
|
||
["output"],
|
||
"补充缺口时 AI 应先提议更新第 4 节点",
|
||
);
|
||
assert.equal(
|
||
nodes.filter((node) => node.completed).length,
|
||
3,
|
||
"补充缺口的提案确认前不得改变进度",
|
||
);
|
||
const confirmedGap = await builderTurn("确认写入");
|
||
assert.deepEqual(
|
||
confirmedGap.evaluation.updatedNodeKeys,
|
||
["output"],
|
||
"确认后才应更新第 4 节点",
|
||
);
|
||
assert.equal(
|
||
nodes.filter((node) => node.completed).length,
|
||
5,
|
||
"第 4 节点补齐后，已准备好的第 5 节点必须自动完成",
|
||
);
|
||
assert.doesNotMatch(
|
||
confirmedGap.reply,
|
||
/约束与测试[^。]*[？?]/,
|
||
"全部节点自动完成后不得继续追问已经解锁的节点",
|
||
);
|
||
console.log(
|
||
"✓ 节点内容先展示提案，支持修改，确认后再写入并按顺序解锁",
|
||
);
|
||
|
||
assert.deepEqual(
|
||
getSkillNodeQualityIssues(nodes),
|
||
[],
|
||
"全部完成的五个节点必须通过发布质量标准",
|
||
);
|
||
const lowQualityNodes = nodes.map((node) =>
|
||
node.key === "steps"
|
||
? { ...node, content: "分析内容并生成结果", completed: true }
|
||
: node,
|
||
);
|
||
const lowQualitySaveResponse = await fetch(`${baseUrl}/api/skills`, {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
name: `${skillName}质量测试`,
|
||
description: skillDescription,
|
||
nodes: lowQualityNodes,
|
||
status: "active",
|
||
}),
|
||
});
|
||
assert.equal(
|
||
lowQualitySaveResponse.status,
|
||
409,
|
||
"即使前端标记 completed，低质量节点也不得发布",
|
||
);
|
||
assert.match(
|
||
(await lowQualitySaveResponse.json()).error,
|
||
/尚未达到可发布标准|明确顺序/,
|
||
);
|
||
console.log("✓ 保存接口独立复核五节点质量");
|
||
|
||
const duplicateNodeResponse = await fetch(`${baseUrl}/api/skills`, {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
name: `${skillName}重复节点测试`,
|
||
description: skillDescription,
|
||
nodes: nodes.map((node) => ({ ...node, key: "trigger" })),
|
||
status: "active",
|
||
}),
|
||
});
|
||
assert.equal(
|
||
duplicateNodeResponse.status,
|
||
400,
|
||
"五个重复节点不得绕过固定流程校验",
|
||
);
|
||
assert.match(
|
||
JSON.stringify(await duplicateNodeResponse.json()),
|
||
/必须且只能包含/,
|
||
);
|
||
console.log("✓ 保存接口强制五种节点各一个");
|
||
|
||
const unsupportedNodes = nodes.map((node) =>
|
||
node.key === "steps"
|
||
? {
|
||
...node,
|
||
content: "调用外部 API 获取实时数据，再运行 Python 脚本生成报告。",
|
||
}
|
||
: node,
|
||
);
|
||
assert.ok(
|
||
getSkillCapabilityViolations({
|
||
name: skillName,
|
||
description: skillDescription,
|
||
nodes: unsupportedNodes,
|
||
}).length >= 2,
|
||
"保存前能力校验必须定位违规节点",
|
||
);
|
||
const unsupportedSaveResponse = await fetch(`${baseUrl}/api/skills`, {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
name: `${skillName}越界测试`,
|
||
description: skillDescription,
|
||
nodes: unsupportedNodes,
|
||
status: "active",
|
||
}),
|
||
});
|
||
const unsupportedSavePayload = await unsupportedSaveResponse.json();
|
||
assert.equal(
|
||
unsupportedSaveResponse.status,
|
||
409,
|
||
"绕过 Builder 直接保存越界 Skill 时也必须拒绝",
|
||
);
|
||
assert.match(unsupportedSavePayload.error, /不支持.*脚本.*API/);
|
||
console.log("✓ 保存接口拒绝包含脚本/API 执行承诺的 Skill");
|
||
|
||
const created = await jsonRequest("/api/skills", {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
name: skillName,
|
||
description: skillDescription,
|
||
nodes,
|
||
status: "active",
|
||
}),
|
||
});
|
||
const skillId = created.skill.id;
|
||
assert.ok(skillId, "必须自动创建 Skill");
|
||
console.log("✓ 自动创建 Skill");
|
||
|
||
const editedTurn = await builderTurn(
|
||
"补充规则：当需求只有一句话时，先追问目标用户再生成清单。",
|
||
);
|
||
assert.ok(
|
||
editedTurn.evaluation.proposedNodeKeys.includes("trigger"),
|
||
"编辑时也必须由 AI 自动判断待修改的目标节点",
|
||
);
|
||
const nodesBeforeDiscard = structuredClone(nodes);
|
||
const discardedTurn = await builderTurn("放弃提案");
|
||
assert.equal(discardedTurn.evaluation.action, "discarded");
|
||
assert.deepEqual(nodes, nodesBeforeDiscard, "放弃提案不得改变现有节点");
|
||
|
||
const confirmedEditProposal = await builderTurn(
|
||
"补充规则：当需求只有一句话时，先追问目标用户再生成清单。",
|
||
);
|
||
assert.ok(
|
||
confirmedEditProposal.evaluation.proposedNodeKeys.includes("trigger"),
|
||
);
|
||
const confirmedEdit = await builderTurn("确认写入");
|
||
assert.ok(
|
||
confirmedEdit.evaluation.updatedNodeKeys.includes("trigger"),
|
||
"编辑提案也必须在确认后才写入目标节点",
|
||
);
|
||
await jsonRequest(`/api/skills/${skillId}`, {
|
||
method: "PUT",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
name: skillName,
|
||
description: skillDescription,
|
||
nodes,
|
||
status: "active",
|
||
}),
|
||
});
|
||
const edited = await jsonRequest(`/api/skills/${skillId}`);
|
||
assert.match(edited.skill.nodes[0].content, /目标用户/);
|
||
console.log("✓ 只能通过 Builder 对话并由 AI 自动归类编辑 Skill 内容");
|
||
|
||
const chat = await jsonRequest("/api/chat");
|
||
assert.equal(chat.conversation.title, "", "新会话默认标题必须为空");
|
||
|
||
const firstChatClientRequestId = `acceptance_${crypto.randomUUID()}`;
|
||
const firstChatRequestBody = {
|
||
conversationId: chat.conversation.id,
|
||
message: "产品需求 验收清单 输入参数 输出格式，请帮我整理。",
|
||
selectedSkillIds: [skillId],
|
||
clientRequestId: firstChatClientRequestId,
|
||
};
|
||
const runPayload = await jsonRequest("/api/chat", {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify(firstChatRequestBody),
|
||
});
|
||
const runId = runPayload.run.id;
|
||
|
||
const firstResponse = await fetch(
|
||
`${baseUrl}/api/chat/runs/${runId}/stream?after=0`,
|
||
);
|
||
const firstEvents = await readFirstSseBatch(firstResponse);
|
||
const cursor = Math.max(...firstEvents.map((event) => event.seq ?? 0));
|
||
assert.ok(cursor > 0, "断连前必须拿到可恢复序号");
|
||
|
||
await new Promise((resolve) => setTimeout(resolve, 180));
|
||
const resumedResponse = await fetch(
|
||
`${baseUrl}/api/chat/runs/${runId}/stream?after=${cursor}`,
|
||
);
|
||
const resumedEvents = await readSse(resumedResponse);
|
||
const allEvents = [...firstEvents, ...resumedEvents];
|
||
const sequences = allEvents.map((event) => event.seq).filter(Boolean);
|
||
assert.equal(new Set(sequences).size, sequences.length, "重连不得重复事件");
|
||
const usage = allEvents.find((event) => event.type === "skill_usage");
|
||
assert.deepEqual(usage?.skillIds, [skillId], "必须反馈实际用到的 Skill");
|
||
assert.equal(usage?.source, "keyword_fallback");
|
||
assert.ok(usage?.reason, "Skill 使用事件必须记录判断来源和原因");
|
||
const usageSummary = allEvents
|
||
.filter((event) => event.type === "usage")
|
||
.at(-1)?.usage;
|
||
assert.equal(
|
||
usageSummary?.status,
|
||
"demo",
|
||
"本地演示回答必须明确标记为零费用演示用量",
|
||
);
|
||
assert.equal(usageSummary?.totalTokens, 0);
|
||
assert.equal(usageSummary?.estimatedCostMicros, 0);
|
||
assert.ok(
|
||
usageSummary?.durationMs >= 0,
|
||
"每轮回答必须记录端到端用时",
|
||
);
|
||
const completedRetention = allEvents.find(
|
||
(event) => event.type === "skill_retention",
|
||
);
|
||
assert.equal(
|
||
completedRetention?.state,
|
||
"complete",
|
||
"任务已交付完成时必须清空 Skill",
|
||
);
|
||
assert.deepEqual(completedRetention?.skillIds, []);
|
||
assert.ok(
|
||
allEvents.some((event) => event.type === "complete"),
|
||
"聊天必须完成",
|
||
);
|
||
assert.ok(
|
||
allEvents.some(
|
||
(event) => event.type === "conversation_title" && event.title,
|
||
),
|
||
"第一轮结束后必须自动生成标题",
|
||
);
|
||
const generatedTitle = allEvents.find(
|
||
(event) => event.type === "conversation_title",
|
||
)?.title;
|
||
assert.equal(
|
||
generatedTitle,
|
||
"产品需求与验收梳理",
|
||
"标题必须提炼主题，不能直接截断用户原句",
|
||
);
|
||
assert.ok(generatedTitle.length <= 18, "自动标题不得超过 18 个字符");
|
||
const chatAfterMeasuredRun = await jsonRequest("/api/chat");
|
||
const persistedUsage = chatAfterMeasuredRun.messages.find(
|
||
(message) => message.id === runPayload.run.assistantMessageId,
|
||
)?.usage;
|
||
assert.equal(
|
||
persistedUsage?.status,
|
||
"demo",
|
||
"刷新后必须恢复回答的 Token 与费用摘要",
|
||
);
|
||
assert.equal(
|
||
persistedUsage?.durationMs,
|
||
usageSummary.durationMs,
|
||
"刷新后必须恢复本轮用时",
|
||
);
|
||
const messagesBeforeIdempotentRetry =
|
||
chatAfterMeasuredRun.messages.length;
|
||
const idempotentRetry = await jsonRequest("/api/chat", {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify(firstChatRequestBody),
|
||
});
|
||
assert.equal(
|
||
idempotentRetry.run.id,
|
||
runPayload.run.id,
|
||
"相同 clientRequestId 重试必须返回原 Run",
|
||
);
|
||
assert.equal(
|
||
(await jsonRequest("/api/chat")).messages.length,
|
||
messagesBeforeIdempotentRetry,
|
||
"幂等重试不得重复写入消息",
|
||
);
|
||
console.log("✓ Skill 选择、实际调用反馈与 SSE 断线续传");
|
||
|
||
const unusedSkillPayload = await jsonRequest("/api/chat", {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
conversationId: chat.conversation.id,
|
||
message: "请写一句关于春天的问候。",
|
||
selectedSkillIds: [skillId],
|
||
clientRequestId: `acceptance_unused_skill_${crypto.randomUUID()}`,
|
||
}),
|
||
});
|
||
const unusedSkillEvents = await readSse(
|
||
await fetch(
|
||
`${baseUrl}/api/chat/runs/${unusedSkillPayload.run.id}/stream?after=0`,
|
||
),
|
||
);
|
||
const unusedSkillUsage = unusedSkillEvents.find(
|
||
(event) => event.type === "skill_usage",
|
||
);
|
||
assert.deepEqual(
|
||
unusedSkillUsage?.skillIds,
|
||
[],
|
||
"不相关任务不得调用已选择的 Skill",
|
||
);
|
||
const unusedSkillStatuses = unusedSkillEvents
|
||
.filter((event) => event.type === "status")
|
||
.map((event) => event.label);
|
||
assert.ok(
|
||
unusedSkillStatuses.includes("正在思考"),
|
||
"未调用 Skill 时应使用普通思考状态",
|
||
);
|
||
assert.equal(
|
||
unusedSkillStatuses.some((label) => /无需调用|未使用 Skill/.test(label)),
|
||
false,
|
||
"未调用 Skill 时不得展示内部路由结论",
|
||
);
|
||
console.log("✓ 未调用 Skill 时只展示普通思考状态");
|
||
|
||
const staleUserMessageId = `stale_user_${crypto.randomUUID()}`;
|
||
const staleAssistantMessageId = `stale_assistant_${crypto.randomUUID()}`;
|
||
const staleRunId = `stale_run_${crypto.randomUUID()}`;
|
||
const staleDatabase = new DatabaseSync(databasePath);
|
||
staleDatabase.exec("PRAGMA busy_timeout = 5000;");
|
||
const insertSyntheticMessage = staleDatabase.prepare(`
|
||
INSERT INTO messages
|
||
(id, conversation_id, role, content, selected_skill_ids,
|
||
used_skill_ids, status, error_message, usage_json, created_at)
|
||
VALUES (?, ?, ?, ?, '[]', '[]', ?, '', '', ?)
|
||
`);
|
||
insertSyntheticMessage.run(
|
||
staleUserMessageId,
|
||
chat.conversation.id,
|
||
"user",
|
||
"模拟服务重启前的用户消息",
|
||
"complete",
|
||
"2026-01-01T00:00:00.000Z",
|
||
);
|
||
insertSyntheticMessage.run(
|
||
staleAssistantMessageId,
|
||
chat.conversation.id,
|
||
"assistant",
|
||
"",
|
||
"streaming",
|
||
"2026-01-01T00:00:00.001Z",
|
||
);
|
||
staleDatabase
|
||
.prepare(
|
||
`INSERT INTO chat_runs
|
||
(id, client_request_id, conversation_id, user_message_id,
|
||
assistant_message_id, status, cancel_requested, created_at, updated_at)
|
||
VALUES (?, ?, ?, ?, ?, 'running', 0, ?, ?)`,
|
||
)
|
||
.run(
|
||
staleRunId,
|
||
`stale_client_${crypto.randomUUID()}`,
|
||
chat.conversation.id,
|
||
staleUserMessageId,
|
||
staleAssistantMessageId,
|
||
"2026-01-01T00:00:00.000Z",
|
||
"2026-01-01T00:00:00.000Z",
|
||
);
|
||
staleDatabase.close();
|
||
const staleRunEvents = await readSse(
|
||
await fetch(`${baseUrl}/api/chat/runs/${staleRunId}/stream?after=0`),
|
||
);
|
||
assert.ok(
|
||
staleRunEvents.some(
|
||
(event) =>
|
||
event.type === "error" && /服务重启|超时/.test(event.message),
|
||
),
|
||
"孤儿 Run 必须自动进入错误终态并关闭 SSE",
|
||
);
|
||
const chatAfterStaleRun = await jsonRequest("/api/chat");
|
||
assert.equal(
|
||
chatAfterStaleRun.messages.find(
|
||
(message) => message.id === staleAssistantMessageId,
|
||
)?.status,
|
||
"error",
|
||
"孤儿 Run 对应的助手消息必须标记失败",
|
||
);
|
||
assert.equal(chatAfterStaleRun.continuation.state, "complete");
|
||
console.log("✓ 服务重启或超时遗留的孤儿 Run 会自动回收");
|
||
|
||
const seededSkills = await jsonRequest("/api/skills");
|
||
const sqlReviewSkill = seededSkills.skills.find(
|
||
(skill) => skill.name === "SQL 安全审阅",
|
||
);
|
||
const decisionNoteSkill = seededSkills.skills.find(
|
||
(skill) => skill.name === "决策备忘录",
|
||
);
|
||
assert.ok(sqlReviewSkill, "预置的 SQL 安全审阅 Skill 必须存在");
|
||
assert.ok(decisionNoteSkill, "预置的决策备忘录 Skill 必须存在");
|
||
const explainSkillPayload = await jsonRequest("/api/chat", {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
conversationId: chat.conversation.id,
|
||
message: "这个 Skill 是干嘛的？",
|
||
selectedSkillIds: [sqlReviewSkill.id],
|
||
clientRequestId: `acceptance_explain_skill_${crypto.randomUUID()}`,
|
||
}),
|
||
});
|
||
const explainSkillEvents = await readSse(
|
||
await fetch(
|
||
`${baseUrl}/api/chat/runs/${explainSkillPayload.run.id}/stream?after=0`,
|
||
),
|
||
);
|
||
const explainSkillUsage = explainSkillEvents.find(
|
||
(event) => event.type === "skill_usage",
|
||
);
|
||
const explainSkillContent = explainSkillEvents
|
||
.filter((event) => event.type === "token")
|
||
.map((event) => event.token)
|
||
.join("");
|
||
assert.deepEqual(
|
||
explainSkillUsage?.skillIds,
|
||
[sqlReviewSkill.id],
|
||
"询问已选 Skill 的用途时必须使用该 Skill 的真实资料",
|
||
);
|
||
assert.match(explainSkillContent, /检查 SQL 的正确性、性能风险与数据安全边界/);
|
||
assert.match(explainSkillContent, /当用户提供 SQL、查询计划或数据库变更/);
|
||
assert.match(explainSkillContent, /任何 DELETE、UPDATE、DDL 建议必须附回滚方案/);
|
||
assert.doesNotMatch(
|
||
explainSkillContent,
|
||
/报错弹窗|缺少 DLL|代理配置错误/,
|
||
"Skill 介绍不得串用其他 Skill 的内容",
|
||
);
|
||
console.log("✓ 询问 Skill 用途时严格返回已选 Skill 的真实定义");
|
||
|
||
const stagedSkillPayload = await jsonRequest("/api/chat", {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
conversationId: chat.conversation.id,
|
||
message: "请分别介绍这些 Skill 的用途",
|
||
selectedSkillIds: [decisionNoteSkill.id, sqlReviewSkill.id],
|
||
clientRequestId: `acceptance_staged_skills_${crypto.randomUUID()}`,
|
||
}),
|
||
});
|
||
const stagedSkillEvents = await readSse(
|
||
await fetch(
|
||
`${baseUrl}/api/chat/runs/${stagedSkillPayload.run.id}/stream?after=0`,
|
||
),
|
||
);
|
||
assert.deepEqual(
|
||
stagedSkillEvents
|
||
.filter(
|
||
(event) =>
|
||
event.type === "skill_started" ||
|
||
event.type === "skill_completed",
|
||
)
|
||
.map((event) => [event.type, event.skillId]),
|
||
[
|
||
["skill_started", decisionNoteSkill.id],
|
||
["skill_completed", decisionNoteSkill.id],
|
||
["skill_started", sqlReviewSkill.id],
|
||
["skill_completed", sqlReviewSkill.id],
|
||
],
|
||
"多个 Skill 必须按用户选择顺序逐个发送开始与完成事件",
|
||
);
|
||
const stagedStartedEvents = stagedSkillEvents.filter(
|
||
(event) => event.type === "skill_started",
|
||
);
|
||
const stagedCompletedEvents = stagedSkillEvents.filter(
|
||
(event) => event.type === "skill_completed",
|
||
);
|
||
assert.equal(
|
||
stagedStartedEvents[0]?.input?.request,
|
||
"请分别介绍这些 Skill 的用途",
|
||
"Skill 开始事件必须包含实际用户请求",
|
||
);
|
||
assert.match(
|
||
stagedCompletedEvents[0]?.result ?? "",
|
||
/复杂选项整理成有依据、可复盘的决策建议/,
|
||
"Skill 完成事件必须包含真实阶段产物",
|
||
);
|
||
assert.doesNotMatch(
|
||
stagedCompletedEvents[0]?.result ?? "",
|
||
/\"used\"\s*:\s*true/,
|
||
"Skill 结果不得再使用 used=true 占位",
|
||
);
|
||
const chatWithStagedExecutions = await jsonRequest("/api/chat");
|
||
const persistedStagedMessage = chatWithStagedExecutions.messages.find(
|
||
(message) => message.id === stagedSkillPayload.run.assistantMessageId,
|
||
);
|
||
assert.equal(
|
||
persistedStagedMessage?.skillExecutions.length,
|
||
2,
|
||
"助手消息必须持久化每个 Skill 的执行记录",
|
||
);
|
||
assert.ok(
|
||
persistedStagedMessage?.skillExecutions.every(
|
||
(execution) =>
|
||
execution.status === "completed" &&
|
||
execution.input.request === "请分别介绍这些 Skill 的用途" &&
|
||
typeof execution.result === "string" &&
|
||
execution.result.length > 0,
|
||
),
|
||
"刷新后仍应读取真实 Skill 输入与结果",
|
||
);
|
||
console.log("✓ 多 Skill 按顺序执行并持久化真实输入与阶段结果");
|
||
|
||
const followUpPayload = await jsonRequest("/api/chat", {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
conversationId: chat.conversation.id,
|
||
message:
|
||
"产品需求 验收清单：我还没提供具体内容，请先询问我需要补充的信息。",
|
||
selectedSkillIds: [skillId, sqlReviewSkill.id],
|
||
clientRequestId: `acceptance_follow_up_${crypto.randomUUID()}`,
|
||
}),
|
||
});
|
||
const followUpEvents = await readSse(
|
||
await fetch(
|
||
`${baseUrl}/api/chat/runs/${followUpPayload.run.id}/stream?after=0`,
|
||
),
|
||
);
|
||
const followUpRetention = followUpEvents.find(
|
||
(event) => event.type === "skill_retention",
|
||
);
|
||
const followUpUsage = followUpEvents.find(
|
||
(event) => event.type === "skill_usage",
|
||
);
|
||
assert.equal(
|
||
followUpUsage?.skillIds.length,
|
||
1,
|
||
"路由器应只使用两个已勾选 Skill 中的相关子集",
|
||
);
|
||
assert.ok(
|
||
followUpUsage.skillIds.every((id) =>
|
||
[skillId, sqlReviewSkill.id].includes(id),
|
||
),
|
||
"实际使用项不得超出用户勾选集合",
|
||
);
|
||
assert.equal(
|
||
followUpRetention?.state,
|
||
"awaiting_input",
|
||
"AI 要求用户补充必要信息时，任务必须保持继续状态",
|
||
);
|
||
assert.deepEqual(
|
||
followUpRetention?.skillIds,
|
||
[skillId, sqlReviewSkill.id],
|
||
"未完成的需求必须保留全部勾选 Skill，不能丢弃当轮未使用项",
|
||
);
|
||
const chatWithRetainedSkill = await jsonRequest("/api/chat");
|
||
assert.deepEqual(
|
||
chatWithRetainedSkill.retainedSkillIds,
|
||
[skillId, sqlReviewSkill.id],
|
||
"刷新页面后仍必须恢复待继续任务的 Skill",
|
||
);
|
||
assert.equal(
|
||
chatWithRetainedSkill.continuation.state,
|
||
"awaiting_input",
|
||
"刷新后必须恢复显式续接状态",
|
||
);
|
||
assert.ok(
|
||
chatWithRetainedSkill.continuation.expectedInput,
|
||
"续接状态必须记录下一轮期待用户补充的内容",
|
||
);
|
||
assert.equal(
|
||
chatWithRetainedSkill.continuation.source,
|
||
"deterministic",
|
||
"明确追问应由确定性规则识别，不依赖 AI 猜测",
|
||
);
|
||
const followUpAssistantMessage = chatWithRetainedSkill.messages.find(
|
||
(message) => message.id === followUpPayload.run.assistantMessageId,
|
||
);
|
||
const pinnedSnapshot = followUpAssistantMessage?.skillSnapshots.find(
|
||
(snapshot) => snapshot.id === skillId,
|
||
);
|
||
assert.ok(pinnedSnapshot?.version >= 1, "消息必须保存 Skill 版本快照");
|
||
|
||
const latestSkillBeforeEdit = (
|
||
await jsonRequest(`/api/skills/${skillId}`)
|
||
).skill;
|
||
assert.equal(
|
||
pinnedSnapshot.version,
|
||
latestSkillBeforeEdit.version,
|
||
"首次进入需求时必须固定当时的 Skill 版本",
|
||
);
|
||
const updatedDuringTask = await jsonRequest(`/api/skills/${skillId}`, {
|
||
method: "PUT",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
name: latestSkillBeforeEdit.name,
|
||
description: `${latestSkillBeforeEdit.description}（新版）`,
|
||
nodes: latestSkillBeforeEdit.nodes,
|
||
status: "active",
|
||
}),
|
||
});
|
||
assert.equal(
|
||
updatedDuringTask.skill.version,
|
||
pinnedSnapshot.version + 1,
|
||
"每次编辑 Skill 必须递增版本号",
|
||
);
|
||
console.log(
|
||
"✓ AI 追问时保留全部勾选 Skill，并固定版本快照到 SQLite",
|
||
);
|
||
|
||
const continuedPayload = await jsonRequest("/api/chat", {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
conversationId: chat.conversation.id,
|
||
message: "需要",
|
||
selectedSkillIds: [skillId, sqlReviewSkill.id],
|
||
clientRequestId: `acceptance_continued_skill_${crypto.randomUUID()}`,
|
||
}),
|
||
});
|
||
const continuedEvents = await readSse(
|
||
await fetch(
|
||
`${baseUrl}/api/chat/runs/${continuedPayload.run.id}/stream?after=0`,
|
||
),
|
||
);
|
||
const continuedUsage = continuedEvents.find(
|
||
(event) => event.type === "skill_usage",
|
||
);
|
||
assert.deepEqual(
|
||
continuedUsage?.skillIds,
|
||
[skillId, sqlReviewSkill.id],
|
||
"用户用“需要”等短回复接受上一轮提议时必须继续使用保留的 Skill",
|
||
);
|
||
assert.equal(
|
||
continuedUsage?.source,
|
||
"continuation",
|
||
"省略回复必须通过显式续接状态恢复 Skill",
|
||
);
|
||
const chatAfterContinuation = await jsonRequest("/api/chat");
|
||
const continuedAssistantMessage = chatAfterContinuation.messages.find(
|
||
(message) => message.id === continuedPayload.run.assistantMessageId,
|
||
);
|
||
assert.equal(
|
||
continuedAssistantMessage?.skillSnapshots.find(
|
||
(snapshot) => snapshot.id === skillId,
|
||
)?.version,
|
||
pinnedSnapshot.version,
|
||
"进行中的需求必须继续使用旧快照，不能混入刚编辑的新版本",
|
||
);
|
||
console.log("✓ 省略回复续接所选 Skill，并沿用需求开始时的版本快照");
|
||
|
||
const stopPayload = await jsonRequest("/api/chat", {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
conversationId: chat.conversation.id,
|
||
message: "请生成一份很长的补充清单。",
|
||
selectedSkillIds: [skillId],
|
||
clientRequestId: `acceptance_stop_${crypto.randomUUID()}`,
|
||
}),
|
||
});
|
||
const conflictResponse = await fetch(`${baseUrl}/api/chat`, {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
conversationId: chat.conversation.id,
|
||
message: "这条并发冲突消息不应写入数据库。",
|
||
selectedSkillIds: [],
|
||
clientRequestId: `acceptance_conflict_${crypto.randomUUID()}`,
|
||
}),
|
||
});
|
||
assert.equal(
|
||
conflictResponse.status,
|
||
409,
|
||
"同一会话同时只能创建一个活动 Run",
|
||
);
|
||
const visibleStoppedContent = "客户端点击中止时已经显示的内容";
|
||
await jsonRequest(`/api/chat/runs/${stopPayload.run.id}/stop`, {
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ visibleContent: visibleStoppedContent }),
|
||
});
|
||
const stoppedEvents = await readSse(
|
||
await fetch(
|
||
`${baseUrl}/api/chat/runs/${stopPayload.run.id}/stream?after=0`,
|
||
),
|
||
);
|
||
assert.ok(
|
||
stoppedEvents.some((event) => event.type === "aborted"),
|
||
"中止必须作为终态被记录",
|
||
);
|
||
const chatAfterStop = await jsonRequest("/api/chat");
|
||
const stoppedMessage = chatAfterStop.messages.find(
|
||
(message) => message.id === stopPayload.run.assistantMessageId,
|
||
);
|
||
assert.equal(stoppedMessage?.status, "stopped");
|
||
assert.equal(
|
||
stoppedMessage?.content,
|
||
visibleStoppedContent,
|
||
"中止后只保留用户点击时已经看到的内容",
|
||
);
|
||
assert.ok(
|
||
stoppedMessage?.usage?.durationMs >= 0,
|
||
"中止回答也必须记录端到端用时",
|
||
);
|
||
assert.equal(
|
||
chatAfterStop.continuation.state,
|
||
"active",
|
||
"中止回答只结束 Run，不能把当前需求误判为完成",
|
||
);
|
||
assert.deepEqual(
|
||
chatAfterStop.retainedSkillIds,
|
||
[skillId],
|
||
"中止后必须维持用户勾选的 Skill",
|
||
);
|
||
assert.equal(
|
||
stoppedMessage?.skillSnapshots.find(
|
||
(snapshot) => snapshot.id === skillId,
|
||
)?.version,
|
||
updatedDuringTask.skill.version,
|
||
"上一个需求完成后，新需求必须获取 Skill 的最新版本快照",
|
||
);
|
||
assert.equal(
|
||
chatAfterStop.messages.some(
|
||
(message) => message.content === "这条并发冲突消息不应写入数据库。",
|
||
),
|
||
false,
|
||
"并发冲突事务不得留下孤立消息",
|
||
);
|
||
console.log("✓ 中止原子落库且维持当前需求的 Skill 选择");
|
||
|
||
const renamed = await jsonRequest("/api/conversation", {
|
||
method: "PATCH",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ title: "验收测试会话" }),
|
||
});
|
||
assert.equal(renamed.conversation.title, "验收测试会话");
|
||
const reset = await jsonRequest("/api/conversation", { method: "DELETE" });
|
||
assert.equal(reset.conversation.title, "");
|
||
const resetChat = await jsonRequest("/api/chat");
|
||
assert.equal(resetChat.messages.length, 0);
|
||
assert.equal(resetChat.continuation.state, "complete");
|
||
assert.deepEqual(resetChat.continuation.skillIds, []);
|
||
console.log("✓ 标题编辑与会话重置");
|
||
|
||
await fetch(`${baseUrl}/api/skills/${skillId}`, { method: "DELETE" }).then(
|
||
(response) => assert.equal(response.status, 204),
|
||
);
|
||
const skillsAfterDelete = await jsonRequest("/api/skills");
|
||
assert.equal(
|
||
skillsAfterDelete.skills.some((skill) => skill.id === skillId),
|
||
false,
|
||
);
|
||
console.log("✓ 删除 Skill 并刷新列表");
|
||
}
|
||
|
||
try {
|
||
await runAcceptance();
|
||
console.log("\n验收通过：生命周期、版本快照、中止竞态、创建编辑与重连均正常。");
|
||
} finally {
|
||
server.kill("SIGTERM");
|
||
await new Promise((resolve) => {
|
||
const timeout = setTimeout(resolve, 2_000);
|
||
server.once("exit", () => {
|
||
clearTimeout(timeout);
|
||
resolve();
|
||
});
|
||
});
|
||
rmSync(tempDir, { recursive: true, force: true });
|
||
}
|