1281 lines
44 KiB
TypeScript
1281 lines
44 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
||
import {
|
||
DICTATE_MODULE_READ_STATE_TAG,
|
||
DICTATE_REMEDIATE_TAG,
|
||
buildDictateContext,
|
||
clipDictateDialogue,
|
||
parseDictateModuleReadState,
|
||
parseDictateRemediate,
|
||
runDictateTurn,
|
||
type DictateModuleReadPayload,
|
||
} from "../src/dictate/index.js";
|
||
import type { LlmProvider } from "../src/llm/client.js";
|
||
import type { ModuleCatalog } from "../src/skills/creation-flow.js";
|
||
|
||
function scriptedLlm(steps: unknown[]): LlmProvider {
|
||
let index = 0;
|
||
return {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools() {
|
||
const body = steps[index++] ?? {};
|
||
const select = index === 1;
|
||
return {
|
||
content: null,
|
||
toolCalls: toToolCalls(body, select),
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
};
|
||
}
|
||
|
||
function toToolCalls(body: unknown, select: boolean) {
|
||
const row = body && typeof body === "object" ? (body as Record<string, unknown>) : {};
|
||
if (select) {
|
||
return [{ id: "select", name: "select_nodes", arguments: JSON.stringify(row) }];
|
||
}
|
||
const calls: Array<{ id: string; name: string; arguments: string }> = [];
|
||
const products = row.products;
|
||
if (Array.isArray(products)) {
|
||
products.forEach((item, index) => {
|
||
const rec = item && typeof item === "object" ? (item as Record<string, unknown>) : {};
|
||
if ("tag" in rec || "position" in rec || "content" in rec || "正文" in rec) {
|
||
calls.push({
|
||
id: `ins-${index}`,
|
||
name: "insert",
|
||
arguments: JSON.stringify({
|
||
position: rec.tag ?? rec.position,
|
||
content: rec.content ?? rec.正文 ?? "",
|
||
...(rec.self_score !== undefined ? { self_score: rec.self_score } : {}),
|
||
}),
|
||
});
|
||
return;
|
||
}
|
||
Object.entries(rec).forEach(([key, value], piece) => {
|
||
const content =
|
||
typeof value === "string"
|
||
? value
|
||
: value && typeof value === "object"
|
||
? String((value as Record<string, unknown>).内容 ?? (value as Record<string, unknown>).正文 ?? (value as Record<string, unknown>).content ?? "")
|
||
: "";
|
||
calls.push({
|
||
id: `ins-${index}-${piece}`,
|
||
name: "insert",
|
||
arguments: JSON.stringify({ position: key, content }),
|
||
});
|
||
});
|
||
});
|
||
} else if (products && typeof products === "object") {
|
||
Object.entries(products as Record<string, unknown>).forEach(([key, value], index) => {
|
||
const content =
|
||
typeof value === "string"
|
||
? value
|
||
: value && typeof value === "object"
|
||
? String((value as Record<string, unknown>).正文 ?? (value as Record<string, unknown>).content ?? "")
|
||
: "";
|
||
calls.push({
|
||
id: `ins-${index}`,
|
||
name: "insert",
|
||
arguments: JSON.stringify({ position: key.startsWith("设计.") || key.startsWith("用户.") ? key : `设计.${key}`, content }),
|
||
});
|
||
});
|
||
}
|
||
for (const [key, value] of Object.entries(row)) {
|
||
if (key === "products" || key === "reply" || key === "operations") continue;
|
||
if (typeof value === "string" && (key.startsWith("设计.") || key.startsWith("用户."))) {
|
||
calls.push({
|
||
id: `extra-${key}`,
|
||
name: "insert",
|
||
arguments: JSON.stringify({ position: key, content: value }),
|
||
});
|
||
}
|
||
}
|
||
if (Array.isArray(row.operations)) {
|
||
row.operations.forEach((item, index) => {
|
||
const rec = item && typeof item === "object" ? (item as Record<string, unknown>) : {};
|
||
const nested =
|
||
rec.arguments && typeof rec.arguments === "object"
|
||
? (rec.arguments as Record<string, unknown>)
|
||
: rec;
|
||
const content = String(nested.content ?? "");
|
||
if (!content.trim()) return;
|
||
calls.push({
|
||
id: `op-${index}`,
|
||
name: "insert",
|
||
arguments: JSON.stringify({ position: nested.position ?? nested.tag, content }),
|
||
});
|
||
});
|
||
}
|
||
if (typeof row.reply === "string") {
|
||
calls.push({
|
||
id: "reply",
|
||
name: "reply_user",
|
||
arguments: JSON.stringify({ text: row.reply }),
|
||
});
|
||
}
|
||
return calls;
|
||
}
|
||
|
||
const catalog = {
|
||
modules: [
|
||
{
|
||
id: "mood",
|
||
name: "氛围",
|
||
artifact: "设计.氛围",
|
||
declaration: "细雨",
|
||
},
|
||
],
|
||
} as ModuleCatalog;
|
||
|
||
const modulePayload: DictateModuleReadPayload = {
|
||
module_id: "mood",
|
||
name: "氛围",
|
||
artifact: "设计.氛围",
|
||
version: "v-test",
|
||
task: "写氛围",
|
||
principles: "短句",
|
||
output: "一段话",
|
||
score: "",
|
||
score_dimensions: [],
|
||
libraries: [],
|
||
constraints: [],
|
||
};
|
||
|
||
describe("dictate planned round", () => {
|
||
it("puts earlier dialogue before products and the last user turn at the end", () => {
|
||
const built = buildDictateContext({
|
||
systemPrompt: "规则",
|
||
products: [{ tag: "设计.氛围", content: "旧稿", order: 0 }],
|
||
dialogue: [
|
||
{ role: "user", text: "第一句" },
|
||
{ role: "assistant", text: "记下了" },
|
||
{ role: "user", text: "改成细雨" },
|
||
],
|
||
phase: "fill",
|
||
injected: "#### task\n写氛围",
|
||
tail: "方案进度",
|
||
});
|
||
const body = built.messages[1]?.content ?? "";
|
||
expect(body.indexOf("必须调用 reply_user")).toBeLessThan(body.indexOf("第一句"));
|
||
expect(body.indexOf("第一句")).toBeLessThan(body.indexOf("设计.氛围"));
|
||
expect(body.indexOf("设计.氛围")).toBeLessThan(body.indexOf("写氛围"));
|
||
expect(body.indexOf("写氛围")).toBeLessThan(body.indexOf("改成细雨"));
|
||
expect(body.indexOf("方案进度")).toBeLessThan(body.indexOf("改成细雨"));
|
||
expect(body.indexOf("写完下列节点后")).toBeLessThan(body.indexOf("写氛围"));
|
||
expect(built.segmentChars.products).toBeGreaterThan(0);
|
||
expect(built.segmentChars.rules).toBe("规则".length);
|
||
|
||
const select = buildDictateContext({
|
||
systemPrompt: "规则",
|
||
products: [{ tag: "设计.氛围", content: "旧稿" }],
|
||
dialogue: [
|
||
{ role: "user", text: "第一句" },
|
||
{ role: "user", text: "改成细雨" },
|
||
],
|
||
phase: "select",
|
||
tail: "方案进度",
|
||
});
|
||
const selectBody = select.messages[1]?.content ?? "";
|
||
expect(selectBody).not.toContain("旧稿");
|
||
expect(selectBody).toContain("第一句");
|
||
expect(selectBody.indexOf("第一句")).toBeLessThan(selectBody.indexOf("改成细雨"));
|
||
});
|
||
|
||
it("clips earlier dialogue to the configured history turn window", () => {
|
||
const dialogue = [
|
||
{ role: "user" as const, text: "零" },
|
||
{ role: "assistant" as const, text: "零回" },
|
||
{ role: "user" as const, text: "一" },
|
||
{ role: "assistant" as const, text: "一回" },
|
||
{ role: "user" as const, text: "二" },
|
||
{ role: "assistant" as const, text: "二回" },
|
||
{ role: "user" as const, text: "本轮" },
|
||
];
|
||
expect(clipDictateDialogue(dialogue, 2).map((item) => item.text)).toEqual([
|
||
"一",
|
||
"一回",
|
||
"二",
|
||
"二回",
|
||
"本轮",
|
||
]);
|
||
const built = buildDictateContext({
|
||
systemPrompt: "规则",
|
||
products: [],
|
||
dialogue,
|
||
phase: "select",
|
||
historyTurns: 2,
|
||
});
|
||
const body = built.messages[1]?.content ?? "";
|
||
expect(body).not.toContain("【用户】\n零");
|
||
expect(body).toContain("一");
|
||
expect(body).toContain("本轮");
|
||
});
|
||
|
||
it("injects the spec, stamps the read credential, and writes on the single fill", async () => {
|
||
const products: Array<{ tag: string; content: string }> = [];
|
||
const tags = new Map<string, string>();
|
||
const result = await runDictateTurn({
|
||
llm: scriptedLlm([
|
||
{
|
||
clarify: [],
|
||
inserts: [{ tag: "设计.氛围", module_id: "mood" }],
|
||
deletes: [],
|
||
},
|
||
{
|
||
products: [{ tag: "设计.氛围", content: "细雨" }],
|
||
reply: "已写成细雨",
|
||
},
|
||
]),
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([
|
||
["mood", modulePayload],
|
||
["氛围", modulePayload],
|
||
]),
|
||
handlers: {
|
||
listProducts: () => products,
|
||
writeProduct: (tag, content) => {
|
||
const existing = products.find((item) => item.tag === tag);
|
||
if (existing) existing.content = content;
|
||
else products.push({ tag, content });
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
|
||
expect(result.wroteTags).toEqual(["设计.氛围"]);
|
||
expect(products).toEqual([{ tag: "设计.氛围", content: "细雨" }]);
|
||
expect(result.reply).toContain("已写成细雨");
|
||
expect(result.iterations).toBe(2);
|
||
const state = parseDictateModuleReadState(tags.get(DICTATE_MODULE_READ_STATE_TAG));
|
||
expect(state.modules.mood).toBe("v-test");
|
||
expect(tags.get(DICTATE_REMEDIATE_TAG) ?? "").toBe("");
|
||
});
|
||
|
||
it("stops after the select step when the plan is a clarification", async () => {
|
||
let writes = 0;
|
||
const result = await runDictateTurn({
|
||
llm: scriptedLlm([
|
||
{
|
||
clarify: ["沿用冷色", "改成暖色"],
|
||
inserts: [],
|
||
deletes: [],
|
||
},
|
||
]),
|
||
dialogue: [{ role: "user", text: "氛围还没定" }],
|
||
handlers: {
|
||
listProducts: () => [],
|
||
writeProduct: () => {
|
||
writes += 1;
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: () => undefined,
|
||
writeTag: () => undefined,
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
expect(writes).toBe(0);
|
||
expect(result.iterations).toBe(1);
|
||
expect(result.reply).toContain("沿用冷色");
|
||
expect(result.reply).toContain("改成暖色");
|
||
});
|
||
|
||
it("returns an answer without writing when the first call is reply_user", async () => {
|
||
let writes = 0;
|
||
let calls = 0;
|
||
const result = await runDictateTurn({
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools() {
|
||
calls += 1;
|
||
return {
|
||
content: null,
|
||
toolCalls: [
|
||
{
|
||
id: "reply",
|
||
name: "reply_user",
|
||
arguments: JSON.stringify({ text: "下风位最适合先改顾晚棠。" }),
|
||
},
|
||
],
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "先不要落盘，告诉我该改谁" }],
|
||
handlers: {
|
||
listProducts: () => [],
|
||
writeProduct: () => {
|
||
writes += 1;
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: () => undefined,
|
||
writeTag: () => undefined,
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
expect(writes).toBe(0);
|
||
expect(calls).toBe(1);
|
||
expect(result.wroteTags).toEqual([]);
|
||
expect(result.iterations).toBe(1);
|
||
expect(result.reply).toContain("顾晚棠");
|
||
expect(result.reply).not.toContain("没有写入产物");
|
||
});
|
||
|
||
it("returns a question without writing when the first call is reply_user", async () => {
|
||
let calls = 0;
|
||
const result = await runDictateTurn({
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools() {
|
||
calls += 1;
|
||
return {
|
||
content: null,
|
||
toolCalls: [
|
||
{
|
||
id: "reply",
|
||
name: "reply_user",
|
||
arguments: JSON.stringify({
|
||
text: "先改顾晚棠，还是先改表世界的同辈？",
|
||
}),
|
||
},
|
||
],
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "先讨论，不要落盘" }],
|
||
handlers: {
|
||
listProducts: () => [],
|
||
writeProduct: () => undefined,
|
||
deleteProduct: () => false,
|
||
readTag: () => undefined,
|
||
writeTag: () => undefined,
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
expect(calls).toBe(1);
|
||
expect(result.wroteTags).toEqual([]);
|
||
expect(result.iterations).toBe(1);
|
||
expect(result.reply).toContain("顾晚棠");
|
||
});
|
||
|
||
it("follows a select result with a fill request that carries specs and products", async () => {
|
||
const seen: string[] = [];
|
||
const steps = [
|
||
{
|
||
schema: "creation-plan.v1",
|
||
items: [{ module_id: "mood", tier: "必须", why: "细雨", missing: "", instances: [] }],
|
||
},
|
||
{
|
||
products: [{ tag: "设计.本局创作方案", content: "{\"schema\":\"creation-plan.v1\"}" }],
|
||
reply: "已写方案",
|
||
},
|
||
];
|
||
let index = 0;
|
||
const llm: LlmProvider = {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools(messages) {
|
||
seen.push(messages.map((message) => message.content ?? "").join("\n"));
|
||
const body = steps[index++] ?? {};
|
||
return {
|
||
content: null,
|
||
toolCalls: toToolCalls(body, index === 1),
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
};
|
||
const products = [{ tag: "设计.舞台", content: "已有舞台" }];
|
||
await runDictateTurn({
|
||
llm,
|
||
dialogue: [{ role: "user", text: "超级英雄的世界" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([
|
||
[
|
||
"creation-plan",
|
||
{
|
||
...modulePayload,
|
||
module_id: "creation-plan",
|
||
artifact: "设计.本局创作方案",
|
||
task: "规格任务正文",
|
||
principles: "规格原则正文",
|
||
},
|
||
],
|
||
]),
|
||
handlers: {
|
||
listProducts: () => products,
|
||
writeProduct: (tag, content) => {
|
||
const existing = products.find((item) => item.tag === tag);
|
||
if (existing) existing.content = content;
|
||
else products.push({ tag, content });
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: () => undefined,
|
||
writeTag: () => undefined,
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
|
||
expect(seen.length).toBeGreaterThanOrEqual(2);
|
||
expect(seen[0]).not.toContain("已有舞台");
|
||
expect(seen[0]).not.toContain("规格任务正文");
|
||
expect(seen[1]).toContain("已有舞台");
|
||
expect(seen[1]).toContain("规格任务正文");
|
||
expect(seen[1]).toContain("规格原则正文");
|
||
expect(seen[1]).toContain("#### output");
|
||
expect(seen[1]).toContain("设计.本局创作方案");
|
||
});
|
||
|
||
it("treats operations as the selection, injects the node table, and writes every returned item", async () => {
|
||
const seen: string[] = [];
|
||
const steps = [
|
||
{
|
||
operations: [
|
||
{ name: "insert", arguments: { position: "设计.氛围", module_id: "mood" } },
|
||
],
|
||
reply: "先写氛围",
|
||
},
|
||
{
|
||
operations: [
|
||
{ position: "设计.氛围", content: "细雨" },
|
||
{ tag: "设计.旁白", content: "旁白一句" },
|
||
],
|
||
reply: "写了两份",
|
||
},
|
||
];
|
||
let index = 0;
|
||
const llm: LlmProvider = {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools(messages) {
|
||
seen.push(messages.map((message) => message.content ?? "").join("\n"));
|
||
const body = steps[index++] ?? {};
|
||
return {
|
||
content: null,
|
||
toolCalls: toToolCalls(body, index === 1),
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
};
|
||
const products: Array<{ tag: string; content: string }> = [
|
||
{ tag: "设计.舞台", content: "已有舞台" },
|
||
];
|
||
const tags = new Map<string, string>();
|
||
const result = await runDictateTurn({
|
||
llm,
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([["mood", modulePayload]]),
|
||
handlers: {
|
||
listProducts: () => products,
|
||
writeProduct: (tag, content) => {
|
||
const existing = products.find((item) => item.tag === tag);
|
||
if (existing) existing.content = content;
|
||
else products.push({ tag, content });
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
|
||
expect(seen.length).toBeGreaterThanOrEqual(2);
|
||
expect(seen[0]).not.toContain("已有舞台");
|
||
expect(seen[0]).not.toContain("写氛围");
|
||
expect(seen[1]).toContain("本轮节点表");
|
||
expect(seen[1]).toContain("写氛围");
|
||
expect(seen[1]).toContain("已有舞台");
|
||
expect(result.wroteTags).toEqual(expect.arrayContaining(["设计.氛围", "设计.旁白"]));
|
||
expect(result.reply).toContain("写了两份");
|
||
});
|
||
|
||
it("persists products named by module or keyed outside the products array", async () => {
|
||
const resultProducts: Array<{ tag: string; content: string }> = [];
|
||
const tags = new Map<string, string>();
|
||
const result = await runDictateTurn({
|
||
llm: scriptedLlm([
|
||
{
|
||
inserts: [{ tag: "设计.氛围", module_id: "mood" }],
|
||
deletes: [],
|
||
},
|
||
{
|
||
reply: "写了",
|
||
products: { 氛围: { 正文: "细雨连绵" } },
|
||
"设计.旁白": "旁白一句",
|
||
},
|
||
]),
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([["mood", modulePayload]]),
|
||
handlers: {
|
||
listProducts: () => resultProducts,
|
||
writeProduct: (tag, content) => {
|
||
resultProducts.push({ tag, content });
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
expect(resultProducts.map((item) => item.tag).sort()).toEqual(["设计.旁白", "设计.氛围"]);
|
||
expect(resultProducts.find((item) => item.tag === "设计.氛围")?.content).toBe("细雨连绵");
|
||
expect(result.reply).toContain("写了");
|
||
expect(result.reply).not.toContain("未给出");
|
||
});
|
||
|
||
it("selects node ids first, then writes them with the user text and the node specs", async () => {
|
||
const seen: string[] = [];
|
||
const steps = [
|
||
{ nodes: [{ module_id: "mood" }] },
|
||
{
|
||
products: [{ tag: "设计.氛围", content: "细雨" }],
|
||
reply: "已写氛围。可能还缺主角设定。",
|
||
},
|
||
];
|
||
let index = 0;
|
||
const llm: LlmProvider = {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools(messages) {
|
||
seen.push(messages.map((message) => message.content ?? "").join("\n"));
|
||
const body = steps[index++] ?? {};
|
||
return {
|
||
content: null,
|
||
toolCalls: toToolCalls(body, index === 1),
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
};
|
||
const products: Array<{ tag: string; content: string }> = [];
|
||
const tags = new Map<string, string>();
|
||
const result = await runDictateTurn({
|
||
llm,
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([["mood", modulePayload]]),
|
||
handlers: {
|
||
listProducts: () => products,
|
||
writeProduct: (tag, content) => {
|
||
products.push({ tag, content });
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
|
||
expect(seen).toHaveLength(2);
|
||
expect(seen[0]).toContain("只做选题");
|
||
expect(seen[0]).toContain("写成细雨");
|
||
expect(seen[0]).not.toContain("declare_variable");
|
||
expect(seen[1]).toContain("写成细雨");
|
||
expect(seen[1]).toContain("写氛围");
|
||
expect(seen[1]).toContain("本轮选定的节点：mood");
|
||
expect(seen[1]).toContain("还可能缺哪些节点");
|
||
expect(result.wroteTags).toEqual(["设计.氛围"]);
|
||
expect(result.reply).toContain("可能还缺主角设定");
|
||
});
|
||
|
||
it("maps a user-prefixed tag onto the catalog artifact and reads Chinese content fields", async () => {
|
||
const narration: DictateModuleReadPayload = {
|
||
...modulePayload,
|
||
module_id: "narration",
|
||
name: "旁白",
|
||
artifact: "设计.旁白",
|
||
task: "写旁白",
|
||
};
|
||
const products: Array<{ tag: string; content: string }> = [];
|
||
const tags = new Map<string, string>();
|
||
const seen: string[] = [];
|
||
const result = await runDictateTurn({
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools(messages) {
|
||
seen.push(messages.map((message) => message.content ?? "").join("\n"));
|
||
const step = seen.length;
|
||
const body =
|
||
step === 1
|
||
? { nodes: [{ tag: "用户.氛围" }, { module_id: "narration" }] }
|
||
: {
|
||
products: [{ "用户.氛围": { 内容: "细雨连绵" }, "设计.旁白": "旁白一句" }],
|
||
reply: "写了两份",
|
||
};
|
||
return {
|
||
content: null,
|
||
toolCalls: toToolCalls(body, step === 1),
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: {
|
||
modules: [
|
||
...catalog.modules,
|
||
{ id: "narration", name: "旁白", artifact: "设计.旁白", declaration: "旁白" },
|
||
],
|
||
} as ModuleCatalog,
|
||
moduleReadIndex: new Map([
|
||
["mood", modulePayload],
|
||
["narration", narration],
|
||
]),
|
||
handlers: {
|
||
listProducts: () => products,
|
||
writeProduct: (tag, content) => {
|
||
products.push({ tag, content });
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
|
||
expect(seen[1]).toContain("产物 tag：设计.氛围");
|
||
expect(seen[1]).toContain("产物 tag：设计.旁白");
|
||
expect(products.map((item) => item.tag).sort()).toEqual(["设计.旁白", "设计.氛围"]);
|
||
expect(products.find((item) => item.tag === "设计.氛围")?.content).toBe("细雨连绵");
|
||
expect(result.reply).not.toContain("未给出");
|
||
});
|
||
|
||
it("asks for self_score dimensions before a write can land", async () => {
|
||
const scored: DictateModuleReadPayload = {
|
||
...modulePayload,
|
||
score_dimensions: ["短句"],
|
||
};
|
||
const products: Array<{ tag: string; content: string }> = [];
|
||
const tags = new Map<string, string>();
|
||
const seen: string[] = [];
|
||
const result = await runDictateTurn({
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools(messages) {
|
||
seen.push(messages.map((message) => message.content ?? "").join("\n"));
|
||
const body =
|
||
seen.length === 1
|
||
? { nodes: [{ module_id: "mood" }] }
|
||
: { products: [{ tag: "设计.氛围", content: "细雨" }], reply: "已落盘" };
|
||
return {
|
||
content: null,
|
||
toolCalls: toToolCalls(body, seen.length === 1),
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([["mood", scored]]),
|
||
handlers: {
|
||
listProducts: () => products,
|
||
writeProduct: (tag, content) => {
|
||
products.push({ tag, content });
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
|
||
expect(seen).toHaveLength(2);
|
||
expect(seen[1]).toContain("self_score 维度（这次写入必填，name 必须一致）：短句");
|
||
expect(products).toHaveLength(0);
|
||
expect(result.reply).toContain("失败待补（下轮继续）");
|
||
expect(result.reply).toContain("self_score 必填");
|
||
expect(result.reply).toContain("短句");
|
||
expect(result.reply).not.toContain("未给出");
|
||
const remediate = parseDictateRemediate(tags.get(DICTATE_REMEDIATE_TAG));
|
||
expect(remediate.items.map((item) => item.tag)).toEqual(["设计.氛围"]);
|
||
});
|
||
|
||
it("defers failed tags to the next turn instead of same-turn fill-retry", async () => {
|
||
const narration: DictateModuleReadPayload = {
|
||
...modulePayload,
|
||
module_id: "narration",
|
||
name: "旁白",
|
||
artifact: "设计.旁白",
|
||
task: "写旁白",
|
||
score_dimensions: ["一句"],
|
||
};
|
||
const writes: string[] = [];
|
||
const tags = new Map<string, string>();
|
||
const seen: string[] = [];
|
||
const rounds = [
|
||
[{ id: "select", name: "select_nodes", arguments: JSON.stringify({ nodes: [{ module_id: "mood" }, { module_id: "narration" }] }) }],
|
||
[
|
||
{ id: "a", name: "insert", arguments: JSON.stringify({ position: "设计.氛围", content: "细雨" }) },
|
||
{ id: "b", name: "insert", arguments: JSON.stringify({ position: "设计.旁白", content: "旁白" }) },
|
||
{ id: "r1", name: "reply_user", arguments: JSON.stringify({ text: "氛围先落下" }) },
|
||
],
|
||
];
|
||
let index = 0;
|
||
const result = await runDictateTurn({
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools(messages) {
|
||
seen.push(messages.map((message) => message.content ?? "").join("\n"));
|
||
return {
|
||
content: null,
|
||
toolCalls: rounds[index++] ?? [],
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: {
|
||
modules: [
|
||
...catalog.modules,
|
||
{ id: "narration", name: "旁白", artifact: "设计.旁白", declaration: "旁白" },
|
||
],
|
||
} as ModuleCatalog,
|
||
moduleReadIndex: new Map([
|
||
["mood", modulePayload],
|
||
["narration", narration],
|
||
]),
|
||
handlers: {
|
||
listProducts: () => [],
|
||
writeProduct: (tag, content) => {
|
||
writes.push(`${tag}:${content}`);
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
|
||
expect(seen).toHaveLength(2);
|
||
expect(writes).toEqual(["设计.氛围:细雨"]);
|
||
expect(result.reply).toContain("失败待补（下轮继续）");
|
||
expect(result.reply).toContain("设计.旁白");
|
||
const remediate = parseDictateRemediate(tags.get(DICTATE_REMEDIATE_TAG));
|
||
expect(remediate.items).toEqual([
|
||
expect.objectContaining({ tag: "设计.旁白", kind: "insert" }),
|
||
]);
|
||
});
|
||
|
||
it("merges prior失败待补 into the next fill even if select omits them", async () => {
|
||
const tags = new Map<string, string>([
|
||
[
|
||
DICTATE_REMEDIATE_TAG,
|
||
JSON.stringify({
|
||
schema: "dictate-remediate.v1",
|
||
items: [{ tag: "设计.氛围", moduleId: "mood", error: "self_score 必填", kind: "insert" }],
|
||
}),
|
||
],
|
||
]);
|
||
const products: Array<{ tag: string; content: string }> = [];
|
||
const seen: string[] = [];
|
||
const steps = [
|
||
{ nodes: [{ module_id: "narration" }] },
|
||
{
|
||
products: [
|
||
{ tag: "设计.氛围", content: "细雨" },
|
||
{ tag: "设计.旁白", content: "旁白" },
|
||
],
|
||
reply: "都补上了",
|
||
},
|
||
];
|
||
let index = 0;
|
||
const result = await runDictateTurn({
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools(messages) {
|
||
seen.push(messages.map((message) => message.content ?? "").join("\n"));
|
||
const body = steps[index++] ?? {};
|
||
return {
|
||
content: null,
|
||
toolCalls: toToolCalls(body, index === 1),
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "继续" }],
|
||
moduleCatalog: {
|
||
modules: [
|
||
...catalog.modules,
|
||
{ id: "narration", name: "旁白", artifact: "设计.旁白", declaration: "旁白" },
|
||
],
|
||
} as ModuleCatalog,
|
||
moduleReadIndex: new Map([
|
||
["mood", modulePayload],
|
||
[
|
||
"narration",
|
||
{
|
||
...modulePayload,
|
||
module_id: "narration",
|
||
artifact: "设计.旁白",
|
||
task: "写旁白",
|
||
},
|
||
],
|
||
]),
|
||
handlers: {
|
||
listProducts: () => products,
|
||
writeProduct: (tag, content) => {
|
||
products.push({ tag, content });
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: (tag) => tags.delete(tag),
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
|
||
expect(seen[0]).toContain("失败待补");
|
||
expect(seen[1]).toContain("设计.氛围");
|
||
expect(seen[1]).toContain("写氛围");
|
||
expect(result.wroteTags).toEqual(expect.arrayContaining(["设计.氛围", "设计.旁白"]));
|
||
expect(tags.has(DICTATE_REMEDIATE_TAG)).toBe(false);
|
||
expect(result.reply).toContain("都补上了");
|
||
});
|
||
|
||
it("puts reply_user guidance early in the fill prompt and does not mention a fallback reply step", async () => {
|
||
const seen: string[] = [];
|
||
const products: Array<{ tag: string; content: string }> = [];
|
||
const rounds = [
|
||
[{ id: "select", name: "select_nodes", arguments: JSON.stringify({ nodes: [{ module_id: "mood" }] }) }],
|
||
[
|
||
{ id: "a", name: "insert", arguments: JSON.stringify({ position: "设计.氛围", content: "细雨" }) },
|
||
{ id: "r", name: "reply_user", arguments: JSON.stringify({ text: "细雨留下了" }) },
|
||
],
|
||
];
|
||
let index = 0;
|
||
const tags = new Map<string, string>();
|
||
await runDictateTurn({
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools(messages) {
|
||
seen.push(messages.map((message) => message.content ?? "").join("\n"));
|
||
return {
|
||
content: null,
|
||
toolCalls: rounds[index++] ?? [],
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([["mood", modulePayload]]),
|
||
handlers: {
|
||
listProducts: () => products,
|
||
writeProduct: (tag, content) => {
|
||
products.push({ tag, content });
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
|
||
expect(seen).toHaveLength(2);
|
||
const fill = seen[1] ?? "";
|
||
expect(fill.indexOf("填写收尾")).toBeLessThan(fill.indexOf("写入规则"));
|
||
expect(fill.indexOf("本步收尾")).toBeLessThan(fill.indexOf("更早的对话"));
|
||
expect(fill.indexOf("同一次请求必须调用 reply_user")).toBeLessThan(fill.indexOf("写氛围"));
|
||
expect(fill).toContain("分数一般或还有更好写法的缺口");
|
||
expect(fill).toContain("下一步可以提及哪些");
|
||
expect(fill).not.toContain("本轮刚落盘");
|
||
expect(fill).not.toContain("你只生成给用户看的综合回复");
|
||
});
|
||
|
||
it("silently asks for reply_user with only this round's products when fill omitted it", async () => {
|
||
const products: Array<{ tag: string; content: string }> = [
|
||
{ tag: "设计.舞台", content: "旧舞台不应进入回复请求" },
|
||
];
|
||
const seen: string[] = [];
|
||
const choices: Array<unknown> = [];
|
||
let index = 0;
|
||
const tags = new Map<string, string>();
|
||
const result = await runDictateTurn({
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools(messages, options) {
|
||
seen.push(messages.map((message) => message.content ?? "").join("\n"));
|
||
choices.push(options?.toolChoice);
|
||
const step = index++;
|
||
if (step === 0) {
|
||
return {
|
||
content: null,
|
||
toolCalls: [
|
||
{
|
||
id: "select",
|
||
name: "select_nodes",
|
||
arguments: JSON.stringify({ nodes: [{ module_id: "mood" }] }),
|
||
},
|
||
],
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
}
|
||
if (step === 1) {
|
||
return {
|
||
content: "细雨留下了，接下来可以定主角怎么进城。",
|
||
toolCalls: [
|
||
{
|
||
id: "a",
|
||
name: "insert",
|
||
arguments: JSON.stringify({
|
||
position: "设计.氛围",
|
||
content: "细雨",
|
||
self_score: {
|
||
dims: [{ name: "短句", score: 3, gap: "还缺进城方式", options: ["步行", "马车"] }],
|
||
},
|
||
}),
|
||
},
|
||
],
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
}
|
||
return {
|
||
content: null,
|
||
toolCalls: [
|
||
{
|
||
id: "r",
|
||
name: "reply_user",
|
||
arguments: JSON.stringify({ text: "细雨已落盘，接下来可以定进城方式。" }),
|
||
},
|
||
],
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([
|
||
["mood", { ...modulePayload, score_dimensions: ["短句"] }],
|
||
]),
|
||
handlers: {
|
||
listProducts: () => products,
|
||
writeProduct: (tag, content, _order, metadata) => {
|
||
products.push({
|
||
tag,
|
||
content,
|
||
...(metadata?.selfScore ? { selfScore: metadata.selfScore } : {}),
|
||
});
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
lookupInsertFeedback: (tag) =>
|
||
tag === "设计.氛围"
|
||
? `# 本轮关注 · 氛围\n\n## 写入用户回复时做什么\n1. 自然回应\n3. 结合 self_score 说明最强处与关键缺口\n\n## 自评关注\n- 短句`
|
||
: undefined,
|
||
},
|
||
});
|
||
|
||
expect(result.reply).toBe("细雨已落盘，接下来可以定进城方式。");
|
||
expect(result.iterations).toBe(3);
|
||
expect(seen).toHaveLength(3);
|
||
const replyReq = seen[2] ?? "";
|
||
expect(replyReq).toContain("本轮刚落盘");
|
||
expect(replyReq).toContain("细雨");
|
||
expect(replyReq).toContain("self_score");
|
||
expect(replyReq).toContain("还缺进城方式");
|
||
expect(replyReq).toContain("本轮关注");
|
||
expect(replyReq).toContain("结合 self_score 说明最强处与关键缺口");
|
||
expect(replyReq).toContain("每个缺口写三样");
|
||
expect(replyReq).toContain("2～3 个可以接着说的选项");
|
||
expect(replyReq).not.toContain("旧舞台不应进入回复请求");
|
||
expect(replyReq).not.toContain("#### task");
|
||
expect(choices[2]).toEqual({ type: "function", function: { name: "reply_user" } });
|
||
});
|
||
|
||
it("retries a failed fill in the same turn and patches from the previous draft", async () => {
|
||
const products: Array<{ tag: string; content: string }> = [];
|
||
const tags = new Map<string, string>();
|
||
const seen: string[] = [];
|
||
const rounds = [
|
||
[{ id: "select", name: "select_nodes", arguments: JSON.stringify({ nodes: [{ module_id: "mood" }] }) }],
|
||
[
|
||
{
|
||
id: "a",
|
||
name: "insert",
|
||
arguments: JSON.stringify({
|
||
position: "设计.氛围",
|
||
content: "细雨连绵，石板发亮",
|
||
self_score: { dims: [{ name: "短句", score: 4 }] },
|
||
}),
|
||
},
|
||
],
|
||
[
|
||
{
|
||
id: "b",
|
||
name: "insert",
|
||
arguments: JSON.stringify({
|
||
position: "设计.氛围",
|
||
content: "细雨连绵，石板发亮",
|
||
self_score: {
|
||
dims: [
|
||
{ name: "短句", score: 4 },
|
||
{ name: "画面", score: 5 },
|
||
],
|
||
},
|
||
}),
|
||
},
|
||
{ id: "r", name: "reply_user", arguments: JSON.stringify({ text: "氛围补上了" }) },
|
||
],
|
||
];
|
||
let index = 0;
|
||
const result = await runDictateTurn({
|
||
fillRetries: 1,
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools(messages) {
|
||
seen.push(JSON.stringify(messages));
|
||
return {
|
||
content: null,
|
||
toolCalls: rounds[index++] ?? [],
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([
|
||
["mood", { ...modulePayload, score_dimensions: ["短句", "画面"] }],
|
||
]),
|
||
handlers: {
|
||
listProducts: () => products,
|
||
writeProduct: (tag, content) => {
|
||
products.push({ tag, content });
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: (tag) => tags.delete(tag),
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
|
||
expect(seen).toHaveLength(3);
|
||
expect(seen[2]).toContain("同轮补写");
|
||
expect(seen[2]).toContain("细雨连绵，石板发亮");
|
||
expect(seen[2]).toContain("只改失败点");
|
||
expect(seen[2]).toContain("已接受、请原样保留：短句");
|
||
expect(products).toEqual([{ tag: "设计.氛围", content: "细雨连绵，石板发亮" }]);
|
||
expect(result.reply).toContain("氛围补上了");
|
||
expect(tags.has(DICTATE_REMEDIATE_TAG)).toBe(false);
|
||
});
|
||
|
||
it("keeps accepted self_score dims when a later attempt drops them", async () => {
|
||
const scores: unknown[] = [];
|
||
const rounds = [
|
||
[{ id: "select", name: "select_nodes", arguments: JSON.stringify({ nodes: [{ module_id: "mood" }] }) }],
|
||
[
|
||
{
|
||
id: "a",
|
||
name: "insert",
|
||
arguments: JSON.stringify({
|
||
position: "设计.氛围",
|
||
content: "细雨",
|
||
self_score: { dims: [{ name: "短句", score: 4 }] },
|
||
}),
|
||
},
|
||
],
|
||
[
|
||
{
|
||
id: "b",
|
||
name: "insert",
|
||
arguments: JSON.stringify({
|
||
position: "设计.氛围",
|
||
content: "细雨",
|
||
self_score: { dims: [{ name: "画面", score: 5 }] },
|
||
}),
|
||
},
|
||
{ id: "r", name: "reply_user", arguments: JSON.stringify({ text: "补上了" }) },
|
||
],
|
||
];
|
||
let index = 0;
|
||
const tags = new Map<string, string>();
|
||
await runDictateTurn({
|
||
fillRetries: 1,
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools() {
|
||
return {
|
||
content: null,
|
||
toolCalls: rounds[index++] ?? [],
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([
|
||
["mood", { ...modulePayload, score_dimensions: ["短句", "画面"] }],
|
||
]),
|
||
handlers: {
|
||
listProducts: () => [],
|
||
writeProduct: (_tag, _content, _order, metadata) => {
|
||
scores.push(metadata?.selfScore);
|
||
},
|
||
deleteProduct: () => false,
|
||
readTag: (tag) => tags.get(tag),
|
||
writeTag: (tag, content) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
},
|
||
});
|
||
|
||
expect(scores).toHaveLength(1);
|
||
const dims = (scores[0] as { dims: Array<{ name: string }> }).dims.map((dim) => dim.name).sort();
|
||
expect(dims).toEqual(["画面", "短句"]);
|
||
});
|
||
|
||
it("stores the failed draft and feeds it to the next turn", async () => {
|
||
const tags = new Map<string, string>();
|
||
const seen: string[] = [];
|
||
const first = [
|
||
[{ id: "select", name: "select_nodes", arguments: JSON.stringify({ nodes: [{ module_id: "mood" }] }) }],
|
||
[
|
||
{
|
||
id: "a",
|
||
name: "insert",
|
||
arguments: JSON.stringify({ position: "设计.氛围", content: "细雨连绵" }),
|
||
},
|
||
],
|
||
];
|
||
let index = 0;
|
||
const handlers = {
|
||
listProducts: () => [],
|
||
writeProduct: () => undefined,
|
||
deleteProduct: () => false,
|
||
readTag: (tag: string) => tags.get(tag),
|
||
writeTag: (tag: string, content: string) => {
|
||
tags.set(tag, content);
|
||
},
|
||
deleteTag: () => false,
|
||
clearDialogue: () => undefined,
|
||
};
|
||
const failed = await runDictateTurn({
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools() {
|
||
return {
|
||
content: null,
|
||
toolCalls: first[index++] ?? [],
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "写成细雨" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([["mood", { ...modulePayload, score_dimensions: ["短句"] }]]),
|
||
handlers,
|
||
});
|
||
expect(failed.reply).toContain("失败待补（下轮继续）");
|
||
expect(failed.reply).not.toContain("已同轮补写");
|
||
const stored = parseDictateRemediate(tags.get(DICTATE_REMEDIATE_TAG));
|
||
expect(stored.items[0]?.draft).toBe("细雨连绵");
|
||
|
||
const second = [
|
||
[{ id: "select2", name: "select_nodes", arguments: JSON.stringify({ nodes: [] }) }],
|
||
[
|
||
{
|
||
id: "b",
|
||
name: "insert",
|
||
arguments: JSON.stringify({
|
||
position: "设计.氛围",
|
||
content: "细雨连绵",
|
||
self_score: { dims: [{ name: "短句", score: 4 }] },
|
||
}),
|
||
},
|
||
{ id: "r2", name: "reply_user", arguments: JSON.stringify({ text: "补上了" }) },
|
||
],
|
||
];
|
||
index = 0;
|
||
await runDictateTurn({
|
||
llm: {
|
||
async complete() {
|
||
throw new Error("对话落盘走工具，不走纯文本完成");
|
||
},
|
||
async completeWithTools(messages) {
|
||
seen.push(messages.map((message) => message.content ?? "").join("\n"));
|
||
return {
|
||
content: null,
|
||
toolCalls: second[index++] ?? [],
|
||
usage: { promptTokens: 10, completionTokens: 4, totalTokens: 14 },
|
||
};
|
||
},
|
||
},
|
||
dialogue: [{ role: "user", text: "继续" }],
|
||
moduleCatalog: catalog,
|
||
moduleReadIndex: new Map([["mood", { ...modulePayload, score_dimensions: ["短句"] }]]),
|
||
handlers,
|
||
});
|
||
expect(seen[1]).toContain("底稿");
|
||
expect(seen[1]).toContain("细雨连绵");
|
||
expect(seen[1]).toContain("只改失败点");
|
||
});
|
||
});
|