1011 lines
31 KiB
TypeScript
1011 lines
31 KiB
TypeScript
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
|
|
|
import { AFFINITY_BACKSTORY_CHAPTER_THRESHOLDS } from '../data/affinityLevels';
|
|
import { getScenePresetsByWorld } from '../data/scenePresets';
|
|
import type {
|
|
Character,
|
|
Encounter,
|
|
SceneHostileNpc,
|
|
StoryMoment,
|
|
StoryOption,
|
|
} from '../types';
|
|
import { AnimationState, WorldType } from '../types';
|
|
|
|
const {
|
|
connectivityError,
|
|
fetchMock,
|
|
requestChatMessageContentMock,
|
|
requestPlainTextCompletionMock,
|
|
streamPlainTextCompletionMock,
|
|
timeoutError,
|
|
} = vi.hoisted(() => ({
|
|
connectivityError: new Error('LLM unavailable'),
|
|
fetchMock: vi.fn(),
|
|
requestChatMessageContentMock: vi.fn(),
|
|
requestPlainTextCompletionMock: vi.fn(),
|
|
streamPlainTextCompletionMock: vi.fn(),
|
|
timeoutError: new Error('LLM timed out'),
|
|
}));
|
|
|
|
vi.mock('./llmClient', () => ({
|
|
CUSTOM_WORLD_REQUEST_TIMEOUT_MS: 120000,
|
|
isLlmConnectivityError: (error: unknown) => error === connectivityError,
|
|
isLlmTimeoutError: (error: unknown) => error === timeoutError,
|
|
requestChatMessageContent: requestChatMessageContentMock,
|
|
requestPlainTextCompletion: requestPlainTextCompletionMock,
|
|
streamPlainTextCompletion: streamPlainTextCompletionMock,
|
|
}));
|
|
|
|
import {
|
|
generateCharacterPanelChatSuggestions,
|
|
generateCustomWorldProfile,
|
|
generateCustomWorldSceneImage,
|
|
generateInitialStory,
|
|
generateNextStep,
|
|
streamCharacterPanelChatReply,
|
|
streamNpcRecruitDialogue,
|
|
} from './ai';
|
|
import {
|
|
buildOfflineCharacterPanelChatReply,
|
|
buildOfflineCharacterPanelChatSuggestions,
|
|
buildOfflineNpcRecruitDialogue,
|
|
} from './aiFallbacks';
|
|
import type { StoryGenerationContext } from './aiTypes';
|
|
import type { CharacterChatTargetStatus } from './characterChatPrompt';
|
|
|
|
const [
|
|
BACKSTORY_UNLOCK_AFFINITY_EASED,
|
|
BACKSTORY_UNLOCK_AFFINITY_FRIENDLY,
|
|
BACKSTORY_UNLOCK_AFFINITY_TRUSTED,
|
|
BACKSTORY_UNLOCK_AFFINITY_CLOSE,
|
|
] = AFFINITY_BACKSTORY_CHAPTER_THRESHOLDS;
|
|
|
|
function createCharacter(overrides: Partial<Character> = {}): Character {
|
|
return {
|
|
id: 'hero',
|
|
name: 'Lin',
|
|
title: 'Wanderer',
|
|
description: 'A cautious traveler.',
|
|
backstory: 'Walked out of the northern mountains.',
|
|
avatar: '/avatars/lin.png',
|
|
portrait: '/portraits/lin.png',
|
|
assetFolder: 'lin',
|
|
assetVariant: 'default',
|
|
attributes: {
|
|
strength: 10,
|
|
agility: 8,
|
|
intelligence: 7,
|
|
spirit: 9,
|
|
},
|
|
personality: 'Calm, observant, and steady.',
|
|
skills: [],
|
|
adventureOpenings: {},
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function createStoryOption(overrides: Partial<StoryOption> = {}): StoryOption {
|
|
return {
|
|
functionId: 'rest',
|
|
actionText: 'Pause and recover.',
|
|
text: 'Pause and recover.',
|
|
visuals: {
|
|
playerAnimation: AnimationState.IDLE,
|
|
playerMoveMeters: 0,
|
|
playerOffsetY: 0,
|
|
playerFacing: 'right',
|
|
scrollWorld: false,
|
|
monsterChanges: [],
|
|
},
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function createContext(
|
|
overrides: Partial<StoryGenerationContext> = {},
|
|
): StoryGenerationContext {
|
|
return {
|
|
playerHp: 30,
|
|
playerMaxHp: 40,
|
|
playerMana: 12,
|
|
playerMaxMana: 20,
|
|
inBattle: false,
|
|
playerX: 0,
|
|
playerFacing: 'right',
|
|
playerAnimation: AnimationState.IDLE,
|
|
skillCooldowns: {},
|
|
sceneId: null,
|
|
sceneName: 'Forest Trail',
|
|
sceneDescription: 'A quiet mountain path.',
|
|
pendingSceneEncounter: false,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function createTargetStatus(
|
|
overrides: Partial<CharacterChatTargetStatus> = {},
|
|
): CharacterChatTargetStatus {
|
|
return {
|
|
roleLabel: 'Companion',
|
|
hp: 18,
|
|
maxHp: 20,
|
|
mana: 9,
|
|
maxMana: 12,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function createEncounter(overrides: Partial<Encounter> = {}): Encounter {
|
|
return {
|
|
npcName: 'Lan',
|
|
npcDescription: 'A sharp-eyed scout.',
|
|
npcAvatar: '/avatars/lan.png',
|
|
context: 'Campfire',
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function createPlayableNpc(index: number) {
|
|
return {
|
|
name: `角色${index + 1}`,
|
|
title: `身份${index + 1}`,
|
|
role: `世界职责${index + 1}`,
|
|
description: `角色描述${index + 1}`,
|
|
backstory: `角色背景${index + 1}`,
|
|
personality: `角色性格${index + 1}`,
|
|
motivation: `角色动机${index + 1}`,
|
|
combatStyle: `战斗风格${index + 1}`,
|
|
initialAffinity: 18,
|
|
relationshipHooks: [`接触点${index + 1}`],
|
|
tags: [`标签${index + 1}`],
|
|
backstoryReveal: {
|
|
publicSummary: `公开背景${index + 1}`,
|
|
chapters: [
|
|
{
|
|
id: `surface-${index + 1}`,
|
|
title: '表层来意',
|
|
affinityRequired: BACKSTORY_UNLOCK_AFFINITY_EASED,
|
|
teaser: `提示${index + 1}-1`,
|
|
content: `内容${index + 1}-1`,
|
|
contextSnippet: `摘要${index + 1}-1`,
|
|
},
|
|
{
|
|
id: `scar-${index + 1}`,
|
|
title: '旧事裂痕',
|
|
affinityRequired: BACKSTORY_UNLOCK_AFFINITY_FRIENDLY,
|
|
teaser: `提示${index + 1}-2`,
|
|
content: `内容${index + 1}-2`,
|
|
contextSnippet: `摘要${index + 1}-2`,
|
|
},
|
|
{
|
|
id: `hidden-${index + 1}`,
|
|
title: '隐藏执念',
|
|
affinityRequired: BACKSTORY_UNLOCK_AFFINITY_TRUSTED,
|
|
teaser: `提示${index + 1}-3`,
|
|
content: `内容${index + 1}-3`,
|
|
contextSnippet: `摘要${index + 1}-3`,
|
|
},
|
|
{
|
|
id: `final-${index + 1}`,
|
|
title: '最终底牌',
|
|
affinityRequired: BACKSTORY_UNLOCK_AFFINITY_CLOSE,
|
|
teaser: `提示${index + 1}-4`,
|
|
content: `内容${index + 1}-4`,
|
|
contextSnippet: `摘要${index + 1}-4`,
|
|
},
|
|
],
|
|
},
|
|
skills: [
|
|
{ name: `技能${index + 1}-1`, summary: '技能说明1', style: '起手压制' },
|
|
{ name: `技能${index + 1}-2`, summary: '技能说明2', style: '机动周旋' },
|
|
{ name: `技能${index + 1}-3`, summary: '技能说明3', style: '爆发终结' },
|
|
],
|
|
initialItems: [
|
|
{
|
|
name: `物品${index + 1}-1`,
|
|
category: '武器',
|
|
quantity: 1,
|
|
rarity: 'rare',
|
|
description: '物品说明1',
|
|
tags: ['物品标签1'],
|
|
},
|
|
{
|
|
name: `物品${index + 1}-2`,
|
|
category: '消耗品',
|
|
quantity: 2,
|
|
rarity: 'uncommon',
|
|
description: '物品说明2',
|
|
tags: ['物品标签2'],
|
|
},
|
|
{
|
|
name: `物品${index + 1}-3`,
|
|
category: '专属物品',
|
|
quantity: 1,
|
|
rarity: 'rare',
|
|
description: '物品说明3',
|
|
tags: ['物品标签3'],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
function createStoryNpc(index: number) {
|
|
return {
|
|
name: `世界NPC${index + 1}`,
|
|
title: `头衔${index + 1}`,
|
|
role: `职责${index + 1}`,
|
|
description: `世界NPC描述${index + 1}`,
|
|
backstory: `世界NPC背景${index + 1}`,
|
|
personality: `世界NPC性格${index + 1}`,
|
|
motivation: `世界NPC动机${index + 1}`,
|
|
combatStyle: `世界NPC战斗风格${index + 1}`,
|
|
initialAffinity: index % 4 === 0 ? -10 : 6,
|
|
relationshipHooks: [`关系${index + 1}`],
|
|
tags: [`线索${index + 1}`],
|
|
backstoryReveal: {
|
|
publicSummary: `世界公开背景${index + 1}`,
|
|
chapters: [
|
|
{
|
|
id: `surface-story-${index + 1}`,
|
|
title: '表层来意',
|
|
affinityRequired: BACKSTORY_UNLOCK_AFFINITY_EASED,
|
|
teaser: `提示${index + 1}-1`,
|
|
content: `内容${index + 1}-1`,
|
|
contextSnippet: `摘要${index + 1}-1`,
|
|
},
|
|
{
|
|
id: `scar-story-${index + 1}`,
|
|
title: '旧事裂痕',
|
|
affinityRequired: BACKSTORY_UNLOCK_AFFINITY_FRIENDLY,
|
|
teaser: `提示${index + 1}-2`,
|
|
content: `内容${index + 1}-2`,
|
|
contextSnippet: `摘要${index + 1}-2`,
|
|
},
|
|
{
|
|
id: `hidden-story-${index + 1}`,
|
|
title: '隐藏执念',
|
|
affinityRequired: BACKSTORY_UNLOCK_AFFINITY_TRUSTED,
|
|
teaser: `提示${index + 1}-3`,
|
|
content: `内容${index + 1}-3`,
|
|
contextSnippet: `摘要${index + 1}-3`,
|
|
},
|
|
{
|
|
id: `final-story-${index + 1}`,
|
|
title: '最终底牌',
|
|
affinityRequired: BACKSTORY_UNLOCK_AFFINITY_CLOSE,
|
|
teaser: `提示${index + 1}-4`,
|
|
content: `内容${index + 1}-4`,
|
|
contextSnippet: `摘要${index + 1}-4`,
|
|
},
|
|
],
|
|
},
|
|
skills: [
|
|
{
|
|
name: `世界技能${index + 1}-1`,
|
|
summary: '技能说明1',
|
|
style: '起手压制',
|
|
},
|
|
{
|
|
name: `世界技能${index + 1}-2`,
|
|
summary: '技能说明2',
|
|
style: '机动周旋',
|
|
},
|
|
{
|
|
name: `世界技能${index + 1}-3`,
|
|
summary: '技能说明3',
|
|
style: '爆发终结',
|
|
},
|
|
],
|
|
initialItems: [
|
|
{
|
|
name: `世界物品${index + 1}-1`,
|
|
category: '武器',
|
|
quantity: 1,
|
|
rarity: 'rare',
|
|
description: '物品说明1',
|
|
tags: ['物品标签1'],
|
|
},
|
|
{
|
|
name: `世界物品${index + 1}-2`,
|
|
category: '消耗品',
|
|
quantity: 2,
|
|
rarity: 'uncommon',
|
|
description: '物品说明2',
|
|
tags: ['物品标签2'],
|
|
},
|
|
{
|
|
name: `世界物品${index + 1}-3`,
|
|
category: '专属物品',
|
|
quantity: 1,
|
|
rarity: 'rare',
|
|
description: '物品说明3',
|
|
tags: ['物品标签3'],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
function createLandmark(
|
|
index: number,
|
|
options?: {
|
|
storyNpcNames?: string[];
|
|
landmarkCount?: number;
|
|
},
|
|
) {
|
|
const landmarkCount = options?.landmarkCount ?? 10;
|
|
const nextName = `场景${((index + 1) % landmarkCount) + 1}`;
|
|
const prevName = `场景${((index - 1 + landmarkCount) % landmarkCount) + 1}`;
|
|
|
|
return {
|
|
name: `场景${index + 1}`,
|
|
description: `场景描述${index + 1}`,
|
|
dangerLevel: 'high',
|
|
sceneNpcNames: options?.storyNpcNames ?? [
|
|
`世界NPC${index + 1}`,
|
|
`世界NPC${index + 2}`,
|
|
`世界NPC${index + 3}`,
|
|
],
|
|
connections:
|
|
landmarkCount > 1
|
|
? [
|
|
{
|
|
targetLandmarkName: nextName,
|
|
relativePosition: 'forward',
|
|
summary: `沿主路可到${nextName}`,
|
|
},
|
|
{
|
|
targetLandmarkName: prevName,
|
|
relativePosition: 'back',
|
|
summary: `回身可返${prevName}`,
|
|
},
|
|
]
|
|
: [],
|
|
};
|
|
}
|
|
|
|
function createCustomWorldResponse(
|
|
overrides: Partial<{
|
|
name: string;
|
|
subtitle: string;
|
|
summary: string;
|
|
tone: string;
|
|
playerGoal: string;
|
|
templateWorldType: 'WUXIA' | 'XIANXIA';
|
|
playableNpcs: ReturnType<typeof createPlayableNpc>[];
|
|
storyNpcs: ReturnType<typeof createStoryNpc>[];
|
|
landmarks: ReturnType<typeof createLandmark>[];
|
|
items: Array<Record<string, unknown>>;
|
|
}> = {},
|
|
) {
|
|
const storyNpcs =
|
|
overrides.storyNpcs ??
|
|
Array.from({ length: 25 }, (_, index) => createStoryNpc(index));
|
|
const landmarks =
|
|
overrides.landmarks ??
|
|
Array.from({ length: 10 }, (_, index) =>
|
|
createLandmark(index, {
|
|
landmarkCount: 10,
|
|
storyNpcNames: [
|
|
storyNpcs[index % storyNpcs.length]?.name ?? `世界NPC${index + 1}`,
|
|
storyNpcs[(index + 1) % storyNpcs.length]?.name ??
|
|
`世界NPC${index + 2}`,
|
|
storyNpcs[(index + 2) % storyNpcs.length]?.name ??
|
|
`世界NPC${index + 3}`,
|
|
],
|
|
}),
|
|
);
|
|
|
|
return {
|
|
name: '测试世界',
|
|
subtitle: '副标题',
|
|
summary: '概述',
|
|
tone: '基调',
|
|
playerGoal: '目标',
|
|
templateWorldType: 'WUXIA' as const,
|
|
playableNpcs: Array.from({ length: 5 }, (_, index) =>
|
|
createPlayableNpc(index),
|
|
),
|
|
storyNpcs,
|
|
landmarks,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
describe('ai orchestration fallbacks', () => {
|
|
const playerCharacter = createCharacter();
|
|
const targetCharacter = createCharacter({
|
|
id: 'ally',
|
|
name: 'Lan',
|
|
title: 'Scout',
|
|
personality: 'Dry, practical, and quietly protective.',
|
|
});
|
|
const context = createContext();
|
|
const targetStatus = createTargetStatus();
|
|
const monsters: SceneHostileNpc[] = [];
|
|
const storyHistory: StoryMoment[] = [];
|
|
|
|
beforeEach(() => {
|
|
vi.stubGlobal('fetch', fetchMock);
|
|
fetchMock.mockReset();
|
|
requestChatMessageContentMock.mockReset();
|
|
requestPlainTextCompletionMock.mockReset();
|
|
streamPlainTextCompletionMock.mockReset();
|
|
});
|
|
|
|
it('falls back to the offline story response when story generation loses connectivity', async () => {
|
|
const availableOptions = [createStoryOption()];
|
|
requestChatMessageContentMock.mockRejectedValue(connectivityError);
|
|
|
|
const response = await generateInitialStory(
|
|
WorldType.WUXIA,
|
|
playerCharacter,
|
|
monsters,
|
|
context,
|
|
{ availableOptions },
|
|
);
|
|
|
|
expect(response.options).toEqual(availableOptions);
|
|
expect(response.options).not.toBe(availableOptions);
|
|
expect(response.storyText.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it('repairs mixed-language story text before returning the story response', async () => {
|
|
const availableOptions = [
|
|
createStoryOption({
|
|
functionId: 'idle_explore_forward',
|
|
actionText: '继续沿山道探路。',
|
|
text: '继续沿山道探路。',
|
|
}),
|
|
];
|
|
requestChatMessageContentMock
|
|
.mockResolvedValueOnce(
|
|
JSON.stringify({
|
|
storyText: 'The forest is quiet. 你听见远处的风声。',
|
|
encounter: null,
|
|
options: [
|
|
{
|
|
functionId: 'idle_explore_forward',
|
|
actionText: 'Move forward carefully.',
|
|
},
|
|
],
|
|
}),
|
|
)
|
|
.mockResolvedValueOnce(
|
|
JSON.stringify({
|
|
storyText: '林间重新安静下来，你听见远处的风声。',
|
|
encounter: null,
|
|
options: [
|
|
{
|
|
functionId: 'idle_explore_forward',
|
|
actionText: '继续沿山道探路。',
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const response = await generateInitialStory(
|
|
WorldType.WUXIA,
|
|
playerCharacter,
|
|
monsters,
|
|
context,
|
|
{ availableOptions },
|
|
);
|
|
|
|
expect(response.storyText).toBe('林间重新安静下来，你听见远处的风声。');
|
|
expect(response.options[0]?.actionText).toBe('继续沿山道探路。');
|
|
expect(requestChatMessageContentMock).toHaveBeenCalledTimes(2);
|
|
expect(requestChatMessageContentMock.mock.calls[1]?.[2]).toEqual(
|
|
expect.objectContaining({
|
|
debugLabel: 'story-language-repair',
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('ignores generated encounter payloads during post-battle continuations when no new scene encounter is pending', async () => {
|
|
const availableOptions = [
|
|
createStoryOption({
|
|
functionId: 'idle_explore_forward',
|
|
actionText: '先稳住呼吸，再看看前面的动静。',
|
|
text: '先稳住呼吸，再看看前面的动静。',
|
|
}),
|
|
];
|
|
const sceneWithNpc = getScenePresetsByWorld(WorldType.WUXIA).find(
|
|
(scene) => (scene.npcs?.length ?? 0) > 0,
|
|
);
|
|
const targetNpcId = sceneWithNpc?.npcs?.[0]?.id;
|
|
if (!sceneWithNpc || !targetNpcId) {
|
|
throw new Error('Expected a wuxia scene with at least one npc preset.');
|
|
}
|
|
|
|
requestChatMessageContentMock.mockResolvedValue(
|
|
JSON.stringify({
|
|
storyText: '山道总算安静下来，你收住气息，重新判断前路。',
|
|
encounter: {
|
|
kind: 'npc',
|
|
npcId: targetNpcId,
|
|
},
|
|
options: [
|
|
{
|
|
functionId: 'idle_explore_forward',
|
|
actionText: '先稳住呼吸，再看看前面的动静。',
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const response = await generateNextStep(
|
|
WorldType.WUXIA,
|
|
playerCharacter,
|
|
[],
|
|
[
|
|
{
|
|
text: '挥刀抢攻',
|
|
options: [],
|
|
historyRole: 'action',
|
|
},
|
|
{
|
|
text: '山道客已经败下阵来。',
|
|
options: [],
|
|
historyRole: 'result',
|
|
},
|
|
],
|
|
'挥刀抢攻',
|
|
createContext({
|
|
sceneId: sceneWithNpc.id,
|
|
sceneName: sceneWithNpc.name,
|
|
sceneDescription: sceneWithNpc.description,
|
|
pendingSceneEncounter: false,
|
|
}),
|
|
{ availableOptions },
|
|
);
|
|
|
|
expect(response.encounter).toBeUndefined();
|
|
expect(response.options).toEqual(availableOptions);
|
|
const userPrompt = requestChatMessageContentMock.mock.calls.at(-1)?.[1];
|
|
expect(userPrompt).toContain('encounter 必须为 null');
|
|
expect(userPrompt).toContain('战斗结束后的续写');
|
|
});
|
|
|
|
it('returns offline character chat suggestions when the plain-text client reports connectivity errors', async () => {
|
|
requestPlainTextCompletionMock.mockRejectedValue(connectivityError);
|
|
|
|
const suggestions = await generateCharacterPanelChatSuggestions(
|
|
WorldType.WUXIA,
|
|
playerCharacter,
|
|
targetCharacter,
|
|
storyHistory,
|
|
context,
|
|
[],
|
|
'',
|
|
targetStatus,
|
|
);
|
|
|
|
expect(suggestions).toEqual(
|
|
buildOfflineCharacterPanelChatSuggestions(targetCharacter),
|
|
);
|
|
});
|
|
|
|
it('streams the offline character chat reply and forwards it to onUpdate when connectivity fails', async () => {
|
|
const onUpdate = vi.fn();
|
|
const playerMessage = 'Tell me what you are really worried about.';
|
|
const conversationSummary = 'Lan has started to trust the player more.';
|
|
const fallbackReply = buildOfflineCharacterPanelChatReply(
|
|
targetCharacter,
|
|
playerMessage,
|
|
conversationSummary,
|
|
);
|
|
streamPlainTextCompletionMock.mockRejectedValue(connectivityError);
|
|
|
|
const reply = await streamCharacterPanelChatReply(
|
|
WorldType.WUXIA,
|
|
playerCharacter,
|
|
targetCharacter,
|
|
storyHistory,
|
|
context,
|
|
[],
|
|
conversationSummary,
|
|
playerMessage,
|
|
targetStatus,
|
|
{ onUpdate },
|
|
);
|
|
|
|
expect(reply).toBe(fallbackReply);
|
|
expect(onUpdate).toHaveBeenCalledOnce();
|
|
expect(onUpdate).toHaveBeenCalledWith(fallbackReply);
|
|
});
|
|
|
|
it('uses the extracted NPC recruit fallback when recruit dialogue streaming loses connectivity', async () => {
|
|
const onUpdate = vi.fn();
|
|
const encounter = createEncounter();
|
|
const fallbackReply = buildOfflineNpcRecruitDialogue(encounter);
|
|
streamPlainTextCompletionMock.mockRejectedValue(connectivityError);
|
|
|
|
const reply = await streamNpcRecruitDialogue(
|
|
WorldType.WUXIA,
|
|
playerCharacter,
|
|
encounter,
|
|
monsters,
|
|
storyHistory,
|
|
context,
|
|
'Join us.',
|
|
'The party is ready to travel together.',
|
|
{ onUpdate },
|
|
);
|
|
|
|
expect(reply).toBe(fallbackReply);
|
|
expect(onUpdate).toHaveBeenCalledOnce();
|
|
expect(onUpdate).toHaveBeenCalledWith(fallbackReply);
|
|
});
|
|
|
|
it('rejects custom world output when the model does not generate enough NPCs and scenes', async () => {
|
|
requestPlainTextCompletionMock.mockResolvedValue(
|
|
JSON.stringify(
|
|
createCustomWorldResponse({
|
|
storyNpcs: Array.from({ length: 10 }, (_, index) =>
|
|
createStoryNpc(index),
|
|
),
|
|
landmarks: Array.from({ length: 4 }, (_, index) =>
|
|
createLandmark(index, { landmarkCount: 4 }),
|
|
),
|
|
}),
|
|
),
|
|
);
|
|
|
|
await expect(
|
|
generateCustomWorldProfile('一个需要很多角色和场景的世界'),
|
|
).rejects.toThrow(
|
|
/requires at least 10 generated scenes|至少产出 10 个场景|至少需要 10 个场景/i,
|
|
);
|
|
});
|
|
|
|
it('keeps the generated custom world dossier item-free when the model output is valid', async () => {
|
|
requestPlainTextCompletionMock.mockResolvedValue(
|
|
JSON.stringify(
|
|
createCustomWorldResponse({
|
|
items: [
|
|
{
|
|
name: '不应保留的物品',
|
|
category: '材料',
|
|
rarity: 'rare',
|
|
description: '这个字段应该被清空',
|
|
tags: ['测试'],
|
|
},
|
|
],
|
|
}),
|
|
),
|
|
);
|
|
|
|
const profile =
|
|
await generateCustomWorldProfile('一个需要很多角色和场景的世界');
|
|
|
|
expect(profile.playableNpcs).toHaveLength(5);
|
|
expect(profile.storyNpcs).toHaveLength(25);
|
|
expect(profile.landmarks).toHaveLength(10);
|
|
expect(
|
|
profile.landmarks.every((landmark) => landmark.sceneNpcIds.length >= 3),
|
|
).toBe(true);
|
|
expect(
|
|
profile.landmarks.every((landmark) => landmark.connections.length > 0),
|
|
).toBe(true);
|
|
expect(profile.items).toEqual([]);
|
|
});
|
|
|
|
it('generates custom worlds through a framework stage plus segmented narrative and dossier batches', async () => {
|
|
requestPlainTextCompletionMock.mockResolvedValue(
|
|
JSON.stringify(createCustomWorldResponse()),
|
|
);
|
|
|
|
await generateCustomWorldProfile('一个需要拆分生成的世界');
|
|
|
|
const debugLabels = requestPlainTextCompletionMock.mock.calls.map(
|
|
(call) => (call[2] as { debugLabel?: string } | undefined)?.debugLabel,
|
|
);
|
|
|
|
expect(debugLabels).toContain('custom-world-framework');
|
|
expect(debugLabels).toContain('custom-world-playable-outline-batch-1');
|
|
expect(debugLabels).toContain('custom-world-story-outline-batch-1');
|
|
expect(debugLabels).toContain('custom-world-landmark-seed-batch-1');
|
|
expect(debugLabels).toContain('custom-world-landmark-network-batch-1');
|
|
expect(debugLabels).toContain('custom-world-playable-narrative-batch-1');
|
|
expect(debugLabels).toContain('custom-world-playable-dossier-batch-1');
|
|
expect(debugLabels).toContain('custom-world-story-narrative-batch-1');
|
|
expect(debugLabels).toContain('custom-world-story-dossier-batch-1');
|
|
});
|
|
|
|
it('reports staged progress while generating a custom world', async () => {
|
|
requestPlainTextCompletionMock.mockResolvedValue(
|
|
JSON.stringify(createCustomWorldResponse()),
|
|
);
|
|
const onProgress = vi.fn();
|
|
|
|
await generateCustomWorldProfile('一个需要展示真实进度的世界', {
|
|
onProgress,
|
|
});
|
|
|
|
const phaseIds = onProgress.mock.calls.map(
|
|
(call) =>
|
|
(call[0] as { phaseId?: string; overallProgress?: number }).phaseId,
|
|
);
|
|
const lastProgress = onProgress.mock.calls.at(-1)?.[0] as
|
|
| { overallProgress?: number; estimatedRemainingMs?: number | null }
|
|
| undefined;
|
|
|
|
expect(phaseIds).toContain('framework');
|
|
expect(phaseIds).toContain('playable-outline');
|
|
expect(phaseIds).toContain('story-outline');
|
|
expect(phaseIds).toContain('landmark-seed');
|
|
expect(phaseIds).toContain('landmark-network');
|
|
expect(phaseIds).toContain('playable-narrative');
|
|
expect(phaseIds).toContain('playable-dossier');
|
|
expect(phaseIds).toContain('story-narrative');
|
|
expect(phaseIds).toContain('story-dossier');
|
|
expect(phaseIds).toContain('finalize');
|
|
expect(lastProgress?.overallProgress).toBe(100);
|
|
expect(lastProgress?.estimatedRemainingMs).toBe(0);
|
|
});
|
|
|
|
it('passes abort signals through custom world generation and rejects when interrupted', async () => {
|
|
requestPlainTextCompletionMock.mockImplementation(
|
|
(_system: string, _user: string, options?: { signal?: AbortSignal }) =>
|
|
new Promise((_resolve, reject) => {
|
|
options?.signal?.addEventListener(
|
|
'abort',
|
|
() =>
|
|
reject(options.signal?.reason ?? new Error('世界生成已中断。')),
|
|
{ once: true },
|
|
);
|
|
}),
|
|
);
|
|
const abortController = new AbortController();
|
|
const generation = generateCustomWorldProfile('一个会被中断的世界', {
|
|
signal: abortController.signal,
|
|
});
|
|
|
|
abortController.abort(new Error('手动中断生成'));
|
|
|
|
await expect(generation).rejects.toThrow('手动中断生成');
|
|
expect(requestPlainTextCompletionMock).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
signal: abortController.signal,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('retries custom world generation with a longer timeout after the first timeout attempt', async () => {
|
|
requestPlainTextCompletionMock
|
|
.mockRejectedValueOnce(timeoutError)
|
|
.mockResolvedValue(
|
|
JSON.stringify(
|
|
createCustomWorldResponse({
|
|
name: '重试世界',
|
|
}),
|
|
),
|
|
);
|
|
|
|
const profile = await generateCustomWorldProfile('一个生成很慢的世界');
|
|
|
|
expect(profile.name).toBe('重试世界');
|
|
expect(requestPlainTextCompletionMock).toHaveBeenNthCalledWith(
|
|
1,
|
|
expect.any(String),
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
timeoutMs: 120000,
|
|
debugLabel: 'custom-world-framework',
|
|
}),
|
|
);
|
|
expect(requestPlainTextCompletionMock).toHaveBeenNthCalledWith(
|
|
2,
|
|
expect.any(String),
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
timeoutMs: 180000,
|
|
debugLabel: 'custom-world-framework-retry-2',
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('repairs invalid custom world json through a follow-up formatting request', async () => {
|
|
requestPlainTextCompletionMock
|
|
.mockResolvedValueOnce(
|
|
`{
|
|
"name": "修复世界",
|
|
"subtitle": "副标题",
|
|
"summary": "概述",
|
|
"tone": "基调",
|
|
"playerGoal": "目标",
|
|
"templateWorldType": "WUXIA",
|
|
"playableNpcs": [{ name: "角色1" }],
|
|
"storyNpcs": [],
|
|
"landmarks": []
|
|
}`,
|
|
)
|
|
.mockResolvedValue(
|
|
JSON.stringify(
|
|
createCustomWorldResponse({
|
|
name: '修复世界',
|
|
}),
|
|
),
|
|
);
|
|
|
|
const profile = await generateCustomWorldProfile('一个格式容易损坏的世界');
|
|
|
|
expect(profile.name).toBe('修复世界');
|
|
expect(profile.playableNpcs).toHaveLength(5);
|
|
expect(requestPlainTextCompletionMock).toHaveBeenNthCalledWith(
|
|
2,
|
|
expect.stringContaining('你是 JSON 修复器'),
|
|
expect.stringContaining(
|
|
'不要输出 playableNpcs、storyNpcs、landmarks、items',
|
|
),
|
|
expect.objectContaining({
|
|
debugLabel: 'custom-world-framework-json-repair',
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('attaches creator intent and anchor pack when generating from creator cards', async () => {
|
|
requestPlainTextCompletionMock.mockResolvedValue(
|
|
JSON.stringify(
|
|
createCustomWorldResponse({
|
|
name: '锚点世界',
|
|
}),
|
|
),
|
|
);
|
|
|
|
const profile = await generateCustomWorldProfile({
|
|
settingText: '世界一句话：一个被灵潮反复改写地形的边境世界。',
|
|
creatorIntent: {
|
|
sourceMode: 'card',
|
|
rawSettingText: '',
|
|
worldHook: '一个被灵潮反复改写地形的边境世界。',
|
|
themeKeywords: ['边境', '灵潮'],
|
|
toneDirectives: ['紧张', '潮湿'],
|
|
playerPremise: '玩家是前巡夜人。',
|
|
openingSituation: '刚进城就卷入旧案。',
|
|
coreConflicts: ['旧案名单再次出现'],
|
|
keyFactions: [],
|
|
keyCharacters: [
|
|
{
|
|
id: 'creator-character-1',
|
|
name: '沈砺',
|
|
role: '灰炬向导',
|
|
publicMask: '看起来只是个带路人',
|
|
hiddenHook: '一直在查旧撤离线',
|
|
relationToPlayer: '会先怀疑玩家身份',
|
|
notes: '',
|
|
locked: true,
|
|
},
|
|
],
|
|
keyLandmarks: [],
|
|
iconicElements: ['裂潮灯塔'],
|
|
forbiddenDirectives: ['不要出现现代枪械'],
|
|
},
|
|
});
|
|
|
|
expect(profile.name).toBe('锚点世界');
|
|
expect(profile.creatorIntent?.sourceMode).toBe('card');
|
|
expect(profile.creatorIntent?.keyCharacters[0]?.name).toBe('沈砺');
|
|
expect(profile.anchorPack?.keyCharacterAnchors[0]?.name).toBe('沈砺');
|
|
expect(profile.anchorPack?.lockedAnchorIds).toContain(
|
|
'creator-character-1',
|
|
);
|
|
});
|
|
|
|
it('generates a custom world scene image through the local proxy and returns the saved asset path', async () => {
|
|
fetchMock.mockResolvedValue({
|
|
ok: true,
|
|
text: async () =>
|
|
JSON.stringify({
|
|
ok: true,
|
|
data: {
|
|
ok: true,
|
|
imageSrc: '/generated-custom-world-scenes/world/landmark/scene.png',
|
|
assetId: 'custom-scene-1',
|
|
model: 'wan2.7-image',
|
|
size: '1280*720',
|
|
taskId: 'task-123',
|
|
prompt: '系统整理后的提示词',
|
|
actualPrompt: '扩写后的提示词',
|
|
},
|
|
error: null,
|
|
meta: {
|
|
apiVersion: '2026-04-08',
|
|
},
|
|
}),
|
|
} as Response);
|
|
|
|
const result = await generateCustomWorldSceneImage({
|
|
profile: {
|
|
id: 'custom-world-1',
|
|
name: '测试世界',
|
|
subtitle: '副标题',
|
|
summary: '世界概述',
|
|
tone: '世界基调',
|
|
playerGoal: '核心目标',
|
|
settingText: '原始设定',
|
|
},
|
|
landmark: {
|
|
id: 'landmark-1',
|
|
name: '雾潮码头',
|
|
description: '被潮雾与旧升降机包围的码头。',
|
|
dangerLevel: 'high',
|
|
},
|
|
userPrompt: '雨夜的栈桥横跨黑色海沟，塔楼灯火被潮雾吞没。',
|
|
size: '1280*720',
|
|
referenceImageSrc: '/scene_bg/reference-layout.png',
|
|
});
|
|
|
|
expect(fetchMock).toHaveBeenCalledOnce();
|
|
expect(fetchMock).toHaveBeenCalledWith(
|
|
'/api/custom-world/scene-image',
|
|
expect.objectContaining({
|
|
method: 'POST',
|
|
headers: expect.objectContaining({
|
|
'Content-Type': 'application/json',
|
|
}),
|
|
}),
|
|
);
|
|
const [, request] = fetchMock.mock.calls[0] as [string, RequestInit];
|
|
const requestBody = JSON.parse(String(request.body)) as {
|
|
prompt: string;
|
|
referenceImageSrc?: string;
|
|
};
|
|
expect(requestBody.referenceImageSrc).toBe(
|
|
'/scene_bg/reference-layout.png',
|
|
);
|
|
expect(requestBody.prompt).toContain('像素风场景背景');
|
|
expect(requestBody.prompt).toContain('画面构图必须严格按上下 1:1 分区');
|
|
expect(requestBody.prompt).toContain('下半部分严格占据整张图的 1/2 高度');
|
|
expect(requestBody.prompt).toContain('模拟 3D 游戏视角的地面近景');
|
|
expect(requestBody.prompt).toContain(
|
|
'下半部分的内容必须是明确可站立的地面本体',
|
|
);
|
|
expect(requestBody.prompt).toContain('已提供一张自定义参考图');
|
|
expect(requestBody.prompt).toContain('雨夜的栈桥横跨黑色海沟');
|
|
expect(result).toEqual({
|
|
imageSrc: '/generated-custom-world-scenes/world/landmark/scene.png',
|
|
assetId: 'custom-scene-1',
|
|
model: 'wan2.7-image',
|
|
size: '1280*720',
|
|
taskId: 'task-123',
|
|
prompt: '系统整理后的提示词',
|
|
actualPrompt: '扩写后的提示词',
|
|
});
|
|
});
|
|
|
|
it('surfaces proxy error messages when scene image generation fails', async () => {
|
|
fetchMock.mockResolvedValue({
|
|
ok: false,
|
|
text: async () =>
|
|
JSON.stringify({
|
|
error: {
|
|
message: 'DashScope API key 无效。',
|
|
},
|
|
}),
|
|
} as Response);
|
|
|
|
await expect(
|
|
generateCustomWorldSceneImage({
|
|
profile: {
|
|
id: 'custom-world-1',
|
|
name: '测试世界',
|
|
subtitle: '副标题',
|
|
summary: '世界概述',
|
|
tone: '世界基调',
|
|
playerGoal: '核心目标',
|
|
settingText: '原始设定',
|
|
},
|
|
landmark: {
|
|
id: 'landmark-1',
|
|
name: '雾潮码头',
|
|
description: '被潮雾与旧升降机包围的码头。',
|
|
dangerLevel: 'high',
|
|
},
|
|
}),
|
|
).rejects.toThrow('DashScope API key 无效。');
|
|
});
|
|
});
|