552 lines
18 KiB
TypeScript
552 lines
18 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
|
||
|
||
const streamLLMMock = vi.hoisted(() => vi.fn());
|
||
const resolveModelFromRequestMock = vi.hoisted(() => vi.fn());
|
||
const VOCATIONAL_FLAG = 'OPENMAIC_ENABLE_VOCATIONAL';
|
||
let originalVocationalFlag: string | undefined;
|
||
|
||
vi.mock('@/lib/ai/llm', () => ({
|
||
streamLLM: streamLLMMock,
|
||
}));
|
||
|
||
vi.mock('@/lib/server/resolve-model', () => ({
|
||
resolveModelFromRequest: resolveModelFromRequestMock,
|
||
}));
|
||
|
||
async function readStreamBody(response: Response) {
|
||
const reader = response.body?.getReader();
|
||
expect(reader).toBeDefined();
|
||
const decoder = new TextDecoder();
|
||
let text = '';
|
||
|
||
while (reader) {
|
||
const { done, value } = await reader.read();
|
||
if (done) break;
|
||
text += decoder.decode(value, { stream: true });
|
||
}
|
||
|
||
return text;
|
||
}
|
||
|
||
function parseSseEvents(text: string) {
|
||
return text
|
||
.split('\n')
|
||
.filter((line) => line.startsWith('data: '))
|
||
.map((line) => JSON.parse(line.slice(6)));
|
||
}
|
||
|
||
function mockRequest(requirements: Record<string, unknown>) {
|
||
return {
|
||
json: async () => ({
|
||
requirements,
|
||
pdfText: '',
|
||
pdfImages: [],
|
||
imageMapping: {},
|
||
researchContext: '',
|
||
}),
|
||
headers: {
|
||
get: () => null,
|
||
},
|
||
};
|
||
}
|
||
|
||
describe('task-engine outline route', () => {
|
||
beforeEach(() => {
|
||
originalVocationalFlag = process.env[VOCATIONAL_FLAG];
|
||
delete process.env[VOCATIONAL_FLAG];
|
||
});
|
||
|
||
afterEach(() => {
|
||
if (originalVocationalFlag === undefined) {
|
||
delete process.env[VOCATIONAL_FLAG];
|
||
} else {
|
||
process.env[VOCATIONAL_FLAG] = originalVocationalFlag;
|
||
}
|
||
});
|
||
|
||
test('uses the task-engine prompt and preserves allowed mixed task-engine scene types', async () => {
|
||
vi.resetModules();
|
||
streamLLMMock.mockReset();
|
||
resolveModelFromRequestMock.mockReset();
|
||
process.env[VOCATIONAL_FLAG] = 'true';
|
||
|
||
resolveModelFromRequestMock.mockResolvedValue({
|
||
model: { provider: 'glm.chat', modelId: 'glm-5.1' },
|
||
modelInfo: { outputWindow: 4096, capabilities: {} },
|
||
modelString: 'glm:glm-5.1',
|
||
providerId: 'glm',
|
||
modelId: 'glm-5.1',
|
||
thinkingConfig: undefined,
|
||
});
|
||
|
||
const outlineResponse = JSON.stringify({
|
||
languageDirective: '用中文授课，保持职业教育语境。',
|
||
outlines: [
|
||
{
|
||
id: 'scene_slide',
|
||
type: 'slide',
|
||
title: '高压风险边界',
|
||
description: '解释高压安全边界。',
|
||
keyPoints: ['风险边界', '安全阈值'],
|
||
order: 1,
|
||
widgetType: 'procedural-skill',
|
||
widgetOutline: {
|
||
task: 'should be removed from slide',
|
||
},
|
||
},
|
||
{
|
||
id: 'scene_procedure',
|
||
type: 'interactive',
|
||
title: 'PPE检查',
|
||
description: '完成PPE检查。',
|
||
keyPoints: ['检查绝缘手套', '确认工具状态'],
|
||
order: 2,
|
||
widgetType: 'procedural-skill',
|
||
widgetOutline: {
|
||
steps: ['确认下电', '选择PPE'],
|
||
},
|
||
},
|
||
{
|
||
id: 'scene_game',
|
||
type: 'interactive',
|
||
title: 'GO/STOP挑战',
|
||
description: '根据检测结果做安全裁决。',
|
||
keyPoints: ['读取状态', '选择GO或STOP'],
|
||
order: 3,
|
||
widgetType: 'game',
|
||
widgetOutline: {
|
||
challenge: '判断是否可以继续作业',
|
||
},
|
||
},
|
||
{
|
||
id: 'scene_diagram',
|
||
type: 'interactive',
|
||
title: '高压风险路径',
|
||
description: '查看高压风险传播路径。',
|
||
keyPoints: ['电池包', '维修开关', '测量点'],
|
||
order: 4,
|
||
widgetType: 'diagram',
|
||
widgetOutline: {
|
||
concept: '风险路径',
|
||
},
|
||
},
|
||
{
|
||
id: 'scene_simulation',
|
||
type: 'interactive',
|
||
title: '普通概念模拟',
|
||
description: '非职教 fallback 可保留 simulation。',
|
||
keyPoints: ['变量观察'],
|
||
order: 5,
|
||
widgetType: 'simulation',
|
||
widgetOutline: {
|
||
concept: 'motion',
|
||
},
|
||
},
|
||
{
|
||
id: 'scene_code',
|
||
type: 'interactive',
|
||
title: '代码练习',
|
||
description: '非职教 fallback 可保留 code。',
|
||
keyPoints: ['代码运行'],
|
||
order: 6,
|
||
widgetType: 'code',
|
||
widgetOutline: {},
|
||
},
|
||
{
|
||
id: 'scene_3d',
|
||
type: 'interactive',
|
||
title: '三维观察',
|
||
description: '非职教 fallback 可保留 visualization3d。',
|
||
keyPoints: ['空间结构'],
|
||
order: 7,
|
||
widgetType: 'visualization3d',
|
||
widgetOutline: {},
|
||
},
|
||
{
|
||
id: 'scene_illegal',
|
||
type: 'quiz',
|
||
title: '非法场景',
|
||
description: '非法类型应兜底。',
|
||
keyPoints: ['兜底'],
|
||
order: 8,
|
||
widgetOutline: {
|
||
task: '非法类型兜底任务',
|
||
},
|
||
},
|
||
],
|
||
});
|
||
|
||
streamLLMMock.mockReturnValue({
|
||
textStream: (async function* () {
|
||
yield outlineResponse;
|
||
})(),
|
||
});
|
||
|
||
const { POST } = await import('@/app/api/generate/scene-outlines-stream/route');
|
||
const response = await POST(
|
||
mockRequest({
|
||
requirement: 'NEV-A12 新能源车动力电池包更换前安全确认',
|
||
interactiveMode: true,
|
||
taskEngineMode: true,
|
||
}) as unknown as Parameters<typeof POST>[0],
|
||
);
|
||
|
||
const promptParams = streamLLMMock.mock.calls[0][0] as { system: string; prompt: string };
|
||
expect(promptParams.system).toContain('Task Engine');
|
||
expect(promptParams.system).toContain('procedural-skill');
|
||
|
||
const events = parseSseEvents(await readStreamBody(response));
|
||
const done = events.find((event) => event.type === 'done');
|
||
expect(done).toBeDefined();
|
||
expect(done.taskEngineMode).toBe(true);
|
||
expect(done.outlines).toHaveLength(8);
|
||
expect(done.outlines[0]).toMatchObject({
|
||
type: 'slide',
|
||
title: '高压风险边界',
|
||
});
|
||
expect(done.outlines[0].widgetType).toBeUndefined();
|
||
expect(done.outlines[0].widgetOutline).toBeUndefined();
|
||
expect(done.outlines[1]).toMatchObject({
|
||
type: 'interactive',
|
||
widgetType: 'procedural-skill',
|
||
});
|
||
expect(done.outlines[1].widgetOutline).toMatchObject({
|
||
task: 'NEV-A12 新能源车动力电池包更换前安全确认',
|
||
steps: ['确认下电', '选择PPE'],
|
||
});
|
||
expect(done.outlines[1].widgetOutline.tools.length).toBeGreaterThan(0);
|
||
expect(done.outlines[1].widgetOutline.successCriteria.length).toBeGreaterThan(0);
|
||
expect(done.outlines[1].widgetOutline.errorConsequences.length).toBeGreaterThan(0);
|
||
expect(done.outlines[2]).toMatchObject({
|
||
type: 'interactive',
|
||
widgetType: 'game',
|
||
});
|
||
expect(done.outlines[2].widgetOutline).toMatchObject({
|
||
challenge: '判断是否可以继续作业',
|
||
});
|
||
expect(done.outlines[2].widgetOutline.gameType).toBeUndefined();
|
||
expect(done.outlines[2].widgetOutline.playerControls).toBeUndefined();
|
||
expect(done.outlines[3]).toMatchObject({
|
||
type: 'interactive',
|
||
widgetType: 'diagram',
|
||
});
|
||
expect(done.outlines[3].widgetOutline).toMatchObject({
|
||
concept: '风险路径',
|
||
});
|
||
expect(done.outlines[3].widgetOutline.diagramType).toBeUndefined();
|
||
expect(done.outlines[3].widgetOutline.nodeCount).toBeUndefined();
|
||
expect(done.outlines[4]).toMatchObject({
|
||
type: 'interactive',
|
||
widgetType: 'simulation',
|
||
});
|
||
expect(done.outlines[4].widgetOutline).toMatchObject({
|
||
concept: 'motion',
|
||
});
|
||
expect(done.outlines[4].widgetOutline.keyVariables).toBeUndefined();
|
||
expect(done.outlines[5]).toMatchObject({
|
||
type: 'interactive',
|
||
widgetType: 'code',
|
||
});
|
||
expect(done.outlines[5].widgetOutline.language).toBeUndefined();
|
||
expect(done.outlines[5].widgetOutline.challengeType).toBeUndefined();
|
||
expect(done.outlines[6]).toMatchObject({
|
||
type: 'interactive',
|
||
widgetType: 'visualization3d',
|
||
});
|
||
expect(done.outlines[6].widgetOutline.visualizationType).toBeUndefined();
|
||
expect(done.outlines[6].widgetOutline.objects).toBeUndefined();
|
||
expect(done.outlines[6].widgetOutline.interactions).toBeUndefined();
|
||
expect(done.outlines[7]).toMatchObject({
|
||
type: 'slide',
|
||
title: '非法场景',
|
||
});
|
||
expect(done.outlines[7].widgetType).toBeUndefined();
|
||
expect(done.outlines[7].widgetOutline).toBeUndefined();
|
||
});
|
||
|
||
test('silently falls back to the existing interactive prompt when the server flag is off', async () => {
|
||
vi.resetModules();
|
||
streamLLMMock.mockReset();
|
||
resolveModelFromRequestMock.mockReset();
|
||
|
||
resolveModelFromRequestMock.mockResolvedValue({
|
||
model: { provider: 'glm.chat', modelId: 'glm-5.1' },
|
||
modelInfo: { outputWindow: 4096, capabilities: {} },
|
||
modelString: 'glm:glm-5.1',
|
||
providerId: 'glm',
|
||
modelId: 'glm-5.1',
|
||
thinkingConfig: undefined,
|
||
});
|
||
|
||
streamLLMMock.mockReturnValue({
|
||
textStream: (async function* () {
|
||
yield JSON.stringify({
|
||
languageDirective: 'Teach in English.',
|
||
outlines: [
|
||
{
|
||
id: 'scene_1',
|
||
type: 'interactive',
|
||
title: 'Interactive Scene',
|
||
description: 'Explore a concept.',
|
||
keyPoints: ['Explore'],
|
||
order: 1,
|
||
widgetType: 'simulation',
|
||
widgetOutline: { concept: 'motion', keyVariables: ['speed'] },
|
||
},
|
||
],
|
||
});
|
||
})(),
|
||
});
|
||
|
||
const { POST } = await import('@/app/api/generate/scene-outlines-stream/route');
|
||
const response = await POST(
|
||
mockRequest({
|
||
requirement: 'Teach motion with interaction',
|
||
interactiveMode: true,
|
||
taskEngineMode: true,
|
||
}) as unknown as Parameters<typeof POST>[0],
|
||
);
|
||
|
||
const promptParams = streamLLMMock.mock.calls[0][0] as { system: string; prompt: string };
|
||
expect(promptParams.system).toContain('Interactive Mode Outline Generator');
|
||
expect(promptParams.system).not.toContain('Task Engine Outline Generator');
|
||
|
||
const events = parseSseEvents(await readStreamBody(response));
|
||
const done = events.find((event) => event.type === 'done');
|
||
expect(done).toBeDefined();
|
||
expect(done.taskEngineMode).toBe(false);
|
||
});
|
||
|
||
test('sanitizes procedural-skill outlines when taskEngineMode is disabled', async () => {
|
||
vi.resetModules();
|
||
streamLLMMock.mockReset();
|
||
resolveModelFromRequestMock.mockReset();
|
||
|
||
resolveModelFromRequestMock.mockResolvedValue({
|
||
model: { provider: 'glm.chat', modelId: 'glm-5.1' },
|
||
modelInfo: { outputWindow: 4096, capabilities: {} },
|
||
modelString: 'glm:glm-5.1',
|
||
providerId: 'glm',
|
||
modelId: 'glm-5.1',
|
||
thinkingConfig: undefined,
|
||
});
|
||
|
||
streamLLMMock.mockReturnValue({
|
||
textStream: (async function* () {
|
||
yield JSON.stringify({
|
||
languageDirective: 'Teach in English.',
|
||
outlines: [
|
||
{
|
||
id: 'scene_1',
|
||
type: 'interactive',
|
||
title: 'Operation Process',
|
||
description: 'A model mistakenly emitted the gated widget type.',
|
||
keyPoints: ['Step A', 'Step B'],
|
||
order: 1,
|
||
widgetType: 'procedural-skill',
|
||
widgetOutline: {
|
||
procedureType: 'inspection',
|
||
task: 'Inspect the device',
|
||
tools: ['checklist'],
|
||
steps: ['Check A', 'Check B'],
|
||
successCriteria: ['Complete'],
|
||
},
|
||
},
|
||
],
|
||
});
|
||
})(),
|
||
});
|
||
|
||
const { POST } = await import('@/app/api/generate/scene-outlines-stream/route');
|
||
const response = await POST(
|
||
mockRequest({
|
||
requirement: 'Teach a process interactively',
|
||
interactiveMode: true,
|
||
}) as unknown as Parameters<typeof POST>[0],
|
||
);
|
||
|
||
const events = parseSseEvents(await readStreamBody(response));
|
||
const done = events.find((event) => event.type === 'done');
|
||
expect(done).toBeDefined();
|
||
expect(done.outlines[0]).toMatchObject({
|
||
type: 'interactive',
|
||
widgetType: 'diagram',
|
||
});
|
||
expect(done.outlines[0].description).toContain('process or structure diagram');
|
||
expect(done.outlines[0].widgetOutline.diagramType).toBeUndefined();
|
||
expect(done.outlines[0].widgetOutline.nodeCount).toBeUndefined();
|
||
expect(done.outlines[0].widgetOutline.procedureType).toBeUndefined();
|
||
expect(done.outlines[0].widgetOutline.task).toBeUndefined();
|
||
expect(done.outlines[0].widgetOutline.tools).toBeUndefined();
|
||
expect(done.outlines[0].widgetOutline.steps).toBeUndefined();
|
||
expect(done.outlines[0].widgetOutline.successCriteria).toBeUndefined();
|
||
});
|
||
|
||
test('preserves model-authored scenario PBL subtype through streamed outlines', async () => {
|
||
vi.resetModules();
|
||
streamLLMMock.mockReset();
|
||
resolveModelFromRequestMock.mockReset();
|
||
|
||
resolveModelFromRequestMock.mockResolvedValue({
|
||
model: { provider: 'glm.chat', modelId: 'glm-5.1' },
|
||
modelInfo: { outputWindow: 4096, capabilities: {} },
|
||
modelString: 'glm:glm-5.1',
|
||
providerId: 'glm',
|
||
modelId: 'glm-5.1',
|
||
thinkingConfig: undefined,
|
||
});
|
||
|
||
streamLLMMock.mockReturnValue({
|
||
textStream: (async function* () {
|
||
yield JSON.stringify({
|
||
languageDirective: '用中文授课。',
|
||
outlines: [
|
||
{
|
||
id: 'scene_pbl',
|
||
type: 'pbl',
|
||
title: '同理沟通练习',
|
||
description: '练习安慰压力很大的朋友。',
|
||
keyPoints: ['倾听', '回应'],
|
||
order: 1,
|
||
pblConfig: {
|
||
projectTopic: '同理沟通练习',
|
||
projectDescription: '练习安慰压力很大的朋友。',
|
||
targetSkills: ['倾听', '回应'],
|
||
issueCount: 2,
|
||
scenarioRoleplay: true,
|
||
scenarioBrief: '朋友压力很大，学习者练习倾听和支持。',
|
||
},
|
||
},
|
||
],
|
||
});
|
||
})(),
|
||
});
|
||
|
||
const { POST } = await import('@/app/api/generate/scene-outlines-stream/route');
|
||
const response = await POST(
|
||
mockRequest({
|
||
requirement: '生成一个情景模拟 PBL，练习安慰压力很大的朋友',
|
||
}) as unknown as Parameters<typeof POST>[0],
|
||
);
|
||
|
||
const events = parseSseEvents(await readStreamBody(response));
|
||
const outline = events.find((event) => event.type === 'outline');
|
||
const done = events.find((event) => event.type === 'done');
|
||
|
||
expect(outline).toBeDefined();
|
||
expect(done).toBeDefined();
|
||
expect(outline?.data.pblConfig.scenarioRoleplay).toBe(true);
|
||
expect(done?.outlines[0].pblConfig.scenarioRoleplay).toBe(true);
|
||
expect(done?.outlines[0].pblConfig.scenarioBrief).toContain('朋友压力很大');
|
||
});
|
||
|
||
test('ensures streamed outline ids are unique', async () => {
|
||
vi.resetModules();
|
||
streamLLMMock.mockReset();
|
||
resolveModelFromRequestMock.mockReset();
|
||
|
||
resolveModelFromRequestMock.mockResolvedValue({
|
||
model: { provider: 'glm.chat', modelId: 'glm-5.1' },
|
||
modelInfo: { outputWindow: 4096, capabilities: {} },
|
||
modelString: 'glm:glm-5.1',
|
||
providerId: 'glm',
|
||
modelId: 'glm-5.1',
|
||
thinkingConfig: undefined,
|
||
});
|
||
|
||
streamLLMMock.mockReturnValue({
|
||
textStream: (async function* () {
|
||
yield JSON.stringify({
|
||
languageDirective: 'Teach in English.',
|
||
outlines: [
|
||
{
|
||
id: 'scene_4',
|
||
type: 'slide',
|
||
title: 'First Scene',
|
||
description: 'First scene.',
|
||
keyPoints: ['A'],
|
||
order: 1,
|
||
},
|
||
{
|
||
id: 'scene_4',
|
||
type: 'slide',
|
||
title: 'Second Scene',
|
||
description: 'Second scene.',
|
||
keyPoints: ['B'],
|
||
order: 2,
|
||
},
|
||
],
|
||
});
|
||
})(),
|
||
});
|
||
|
||
const { POST } = await import('@/app/api/generate/scene-outlines-stream/route');
|
||
const response = await POST(
|
||
mockRequest({
|
||
requirement: 'Teach a topic',
|
||
}) as unknown as Parameters<typeof POST>[0],
|
||
);
|
||
|
||
const events = parseSseEvents(await readStreamBody(response));
|
||
const done = events.find((event) => event.type === 'done');
|
||
expect(done).toBeDefined();
|
||
const ids = done.outlines.map((outline: { id: string }) => outline.id);
|
||
expect(new Set(ids).size).toBe(ids.length);
|
||
expect(ids[0]).toBe('scene_4');
|
||
expect(ids[1]).not.toBe('scene_4');
|
||
});
|
||
|
||
test('falls back to a slide for invalid task-engine outlines without regex promotion', async () => {
|
||
vi.resetModules();
|
||
streamLLMMock.mockReset();
|
||
resolveModelFromRequestMock.mockReset();
|
||
process.env[VOCATIONAL_FLAG] = 'true';
|
||
|
||
resolveModelFromRequestMock.mockResolvedValue({
|
||
model: { provider: 'glm.chat', modelId: 'glm-5.1' },
|
||
modelInfo: { outputWindow: 4096, capabilities: {} },
|
||
modelString: 'glm:glm-5.1',
|
||
providerId: 'glm',
|
||
modelId: 'glm-5.1',
|
||
thinkingConfig: undefined,
|
||
});
|
||
|
||
streamLLMMock.mockReturnValue({
|
||
textStream: (async function* () {
|
||
yield JSON.stringify({
|
||
languageDirective: 'Teach in English.',
|
||
outlines: [
|
||
{
|
||
id: 'scene_bad',
|
||
type: 'quiz',
|
||
title: 'Pythagorean theorem recap',
|
||
description: 'A non-vocational math topic with an invalid type.',
|
||
keyPoints: ['a squared plus b squared equals c squared'],
|
||
order: 1,
|
||
},
|
||
],
|
||
});
|
||
})(),
|
||
});
|
||
|
||
const { POST } = await import('@/app/api/generate/scene-outlines-stream/route');
|
||
const response = await POST(
|
||
mockRequest({
|
||
requirement: 'Explain the Pythagorean theorem',
|
||
interactiveMode: true,
|
||
taskEngineMode: true,
|
||
}) as unknown as Parameters<typeof POST>[0],
|
||
);
|
||
|
||
const events = parseSseEvents(await readStreamBody(response));
|
||
const done = events.find((event) => event.type === 'done');
|
||
expect(done).toBeDefined();
|
||
expect(done.outlines[0]).toMatchObject({
|
||
type: 'slide',
|
||
title: 'Pythagorean theorem recap',
|
||
});
|
||
expect(done.outlines[0].widgetType).toBeUndefined();
|
||
expect(done.outlines[0].widgetOutline).toBeUndefined();
|
||
});
|
||
});
|