kdletters
1850 lines
56 KiB
TypeScript
1850 lines
56 KiB
TypeScript
import type {
|
|
CustomWorldGenerationStep,
|
|
GenerateCustomWorldProfileInput,
|
|
GenerateCustomWorldProfileOptions,
|
|
} from '../../packages/shared/src/contracts/runtime';
|
|
import { unwrapApiResponse } from '../../packages/shared/src/http';
|
|
import { createSceneHostileNpcsFromEncounters } from '../data/hostileNpcs';
|
|
import { hasMixedNarrativeLanguage } from './narrativeLanguage';
|
|
import {
|
|
buildEncounterFromSceneNpc,
|
|
getScenePresetById,
|
|
isHostileSceneNpc,
|
|
} from '../data/scenePresets';
|
|
import {
|
|
FunctionAvailabilityContext,
|
|
getDefaultFunctionIdsForContext,
|
|
resolveFunctionOption,
|
|
} from '../data/stateFunctions';
|
|
import {
|
|
buildCustomWorldActorNarrativeProfileBatchJsonRepairPrompt,
|
|
buildCustomWorldActorNarrativeProfileBatchPrompt,
|
|
buildCustomWorldFrameworkJsonRepairPrompt,
|
|
buildCustomWorldFrameworkPrompt,
|
|
buildCustomWorldLandmarkSeedBatchJsonRepairPrompt,
|
|
buildCustomWorldLandmarkSeedBatchPrompt,
|
|
buildCustomWorldRoleBatchJsonRepairPrompt,
|
|
buildCustomWorldRoleBatchPrompt,
|
|
buildCustomWorldRoleOutlineBatchJsonRepairPrompt,
|
|
buildCustomWorldRoleOutlineBatchPrompt,
|
|
buildCustomWorldStoryGraphJsonRepairPrompt,
|
|
buildCustomWorldStoryGraphPrompt,
|
|
buildCustomWorldThemePackJsonRepairPrompt,
|
|
buildCustomWorldThemePackPrompt,
|
|
DEFAULT_CUSTOM_WORLD_SCENE_IMAGE_NEGATIVE_PROMPT,
|
|
} from '../prompts/customWorldPrompts';
|
|
import {
|
|
AIResponse,
|
|
Character,
|
|
CustomWorldCreatorIntent,
|
|
CustomWorldGenerationMode,
|
|
CustomWorldProfile,
|
|
SceneEncounterResult,
|
|
SceneHostileNpc,
|
|
SceneNpc,
|
|
StoryOption,
|
|
ThemePack,
|
|
WorldStoryGraph,
|
|
WorldType,
|
|
} from '../types';
|
|
import {
|
|
CustomWorldSceneImageRequest,
|
|
CustomWorldSceneImageResult,
|
|
StoryGenerationContext,
|
|
StoryRequestOptions,
|
|
TextStreamOptions,
|
|
} from './aiTypes';
|
|
import {
|
|
generateCharacterPanelChatSuggestions as generateCharacterPanelChatSuggestionsFromServer,
|
|
generateCharacterPanelChatSummary as generateCharacterPanelChatSummaryFromServer,
|
|
generateInitialStory as generateInitialStoryFromServer,
|
|
generateNextStep as generateNextStepFromServer,
|
|
streamCharacterPanelChatReply as streamCharacterPanelChatReplyFromServer,
|
|
streamNpcChatDialogue as streamNpcChatDialogueFromServer,
|
|
streamNpcRecruitDialogue as streamNpcRecruitDialogueFromServer,
|
|
} from './aiService';
|
|
import { fetchWithApiAuth } from './apiClient';
|
|
import {
|
|
buildCustomWorldRawProfileFromFramework,
|
|
type CustomWorldGenerationFramework,
|
|
type CustomWorldGenerationLandmarkOutline,
|
|
type CustomWorldGenerationRoleBatchStage,
|
|
type CustomWorldGenerationRoleBatchType,
|
|
type CustomWorldGenerationRoleOutline,
|
|
MIN_CUSTOM_WORLD_LANDMARK_COUNT,
|
|
MIN_CUSTOM_WORLD_PLAYABLE_NPC_COUNT,
|
|
MIN_CUSTOM_WORLD_STORY_NPC_COUNT,
|
|
normalizeCustomWorldGenerationFramework,
|
|
normalizeCustomWorldGenerationLandmarkOutlineBatch,
|
|
normalizeCustomWorldGenerationRoleOutlineBatch,
|
|
validateCustomWorldGenerationFramework,
|
|
validateGeneratedCustomWorldProfile,
|
|
} from './customWorld';
|
|
import { buildExpandedCustomWorldProfile } from './customWorldBuilder';
|
|
import {
|
|
buildCustomWorldAnchorPackFromIntent,
|
|
buildCustomWorldCreatorIntentGenerationText,
|
|
deriveCustomWorldLockStateFromIntent,
|
|
hasMeaningfulCustomWorldCreatorIntent,
|
|
} from './customWorldCreatorIntent';
|
|
import {
|
|
CUSTOM_WORLD_REQUEST_TIMEOUT_MS as CLIENT_CUSTOM_WORLD_REQUEST_TIMEOUT_MS,
|
|
isLlmConnectivityError as isLlmConnectivityErrorFromClient,
|
|
isLlmTimeoutError as isLlmTimeoutErrorFromClient,
|
|
requestChatMessageContent,
|
|
requestPlainTextCompletion as requestPlainTextCompletionFromClient,
|
|
streamPlainTextCompletion as streamPlainTextCompletionFromClient,
|
|
} from './llmClient';
|
|
import { parseJsonResponseText as parseJsonResponseTextFromParser } from './llmParsers';
|
|
import type { CharacterChatTargetStatus } from './rpgRuntimeChatTypes';
|
|
import {
|
|
buildFallbackActorNarrativeProfile,
|
|
normalizeActorNarrativeProfile,
|
|
} from './storyEngine/actorNarrativeProfile';
|
|
import {
|
|
buildThemePackFromWorldProfile,
|
|
normalizeThemePack,
|
|
} from './storyEngine/themePack';
|
|
import {
|
|
buildFallbackWorldStoryGraph,
|
|
normalizeWorldStoryGraph,
|
|
} from './storyEngine/worldStoryGraph';
|
|
|
|
export type {
|
|
CustomWorldGenerationProgress,
|
|
GenerateCustomWorldProfileInput,
|
|
GenerateCustomWorldProfileOptions,
|
|
} from '../../packages/shared/src/contracts/runtime';
|
|
export type {
|
|
CustomWorldSceneImageRequest,
|
|
CustomWorldSceneImageResult,
|
|
StoryGenerationContext,
|
|
StoryRequestOptions,
|
|
TextStreamOptions,
|
|
} from './aiTypes';
|
|
|
|
const ENV: Partial<ImportMetaEnv> = import.meta.env ?? {};
|
|
|
|
type RawOptionItem = {
|
|
functionId: string;
|
|
actionText?: string;
|
|
};
|
|
|
|
type MergeableCustomWorldRoleEntry = {
|
|
name: string;
|
|
};
|
|
|
|
const CUSTOM_WORLD_SCENE_IMAGE_API_BASE_URL =
|
|
ENV.VITE_SCENE_IMAGE_PROXY_BASE_URL || '/api/runtime/custom-world/scene-image';
|
|
const CUSTOM_WORLD_JSON_REPAIR_SYSTEM_PROMPT = `你是 JSON 修复器。
|
|
你会收到一段本应为单个 JSON 对象的文本。
|
|
你的唯一任务是把它修复成能被 JSON.parse 直接解析的单个 JSON 对象。
|
|
不要输出 Markdown、代码块、解释、注释或额外文字。
|
|
尽量保留原始语义，只修复格式问题；必要时可以补齐缺失的引号、逗号、括号、数组闭合或缺失字段。`;
|
|
const STORY_LANGUAGE_REPAIR_SYSTEM_PROMPT = `你是 RPG 中文叙事文本修复器。
|
|
你会收到一个已经解析过的剧情 JSON 对象。
|
|
你的唯一任务是把 storyText 和 options[].actionText 中的英文句子、中英混杂句式、英文解释改写成自然中文。
|
|
必须保持 JSON 结构、encounter、options 数量、options 顺序以及每个 functionId 完全不变。
|
|
只输出一个 JSON 对象，不要输出 Markdown、代码块、解释、注释或额外文字。`;
|
|
const CUSTOM_WORLD_GENERATION_JSON_ONLY_SYSTEM_PROMPT = `你是严格的自定义世界 JSON 生成器。
|
|
只输出一个 JSON 对象，不要输出 Markdown、代码块、解释或额外文字。`;
|
|
const CUSTOM_WORLD_FRAMEWORK_PLAYABLE_OUTLINE_BATCH_SIZE = 5;
|
|
const CUSTOM_WORLD_FRAMEWORK_STORY_OUTLINE_BATCH_SIZE = 5;
|
|
const CUSTOM_WORLD_FRAMEWORK_LANDMARK_SEED_BATCH_SIZE = 5;
|
|
const CUSTOM_WORLD_PLAYABLE_BATCH_SIZE = 3;
|
|
const CUSTOM_WORLD_STORY_BATCH_SIZE = 5;
|
|
const CUSTOM_WORLD_SCENE_IMAGE_REQUEST_TIMEOUT_MS = (() => {
|
|
const rawValue = Number(ENV.VITE_SCENE_IMAGE_REQUEST_TIMEOUT_MS);
|
|
return Number.isFinite(rawValue) && rawValue > 0 ? rawValue : 150000;
|
|
})();
|
|
|
|
const CUSTOM_WORLD_GENERATION_STAGE_DEFINITIONS = [
|
|
{
|
|
id: 'framework',
|
|
label: '世界框架',
|
|
detail: '解析设定文本，确定世界主题、主目标与基础模板。',
|
|
total: 1,
|
|
weight: 1,
|
|
},
|
|
{
|
|
id: 'theme-pack',
|
|
label: '题材适配层',
|
|
detail: '提炼制度词汇、禁忌词与命名范式。',
|
|
total: 1,
|
|
weight: 1,
|
|
},
|
|
{
|
|
id: 'story-graph',
|
|
label: '世界线程图谱',
|
|
detail: '补出明线、暗线、旧伤与意象母题。',
|
|
total: 1,
|
|
weight: 1,
|
|
},
|
|
{
|
|
id: 'playable-outline',
|
|
label: '可扮演角色骨架',
|
|
detail: '先生成可扮演角色名单与核心定位。',
|
|
total: MIN_CUSTOM_WORLD_PLAYABLE_NPC_COUNT,
|
|
weight: Math.max(
|
|
1,
|
|
Math.ceil(
|
|
MIN_CUSTOM_WORLD_PLAYABLE_NPC_COUNT /
|
|
CUSTOM_WORLD_FRAMEWORK_PLAYABLE_OUTLINE_BATCH_SIZE,
|
|
),
|
|
),
|
|
},
|
|
{
|
|
id: 'story-outline',
|
|
label: '场景角色骨架',
|
|
detail: '补齐世界里的关键角色与势力关系。',
|
|
total: MIN_CUSTOM_WORLD_STORY_NPC_COUNT,
|
|
weight: Math.max(
|
|
1,
|
|
Math.ceil(
|
|
MIN_CUSTOM_WORLD_STORY_NPC_COUNT /
|
|
CUSTOM_WORLD_FRAMEWORK_STORY_OUTLINE_BATCH_SIZE,
|
|
),
|
|
),
|
|
},
|
|
{
|
|
id: 'landmark-seed',
|
|
label: '场景骨架',
|
|
detail: '生成地标、区域描述、场景角色与连接关系。',
|
|
total: MIN_CUSTOM_WORLD_LANDMARK_COUNT,
|
|
weight: Math.max(
|
|
1,
|
|
Math.ceil(
|
|
MIN_CUSTOM_WORLD_LANDMARK_COUNT /
|
|
CUSTOM_WORLD_FRAMEWORK_LANDMARK_SEED_BATCH_SIZE,
|
|
),
|
|
),
|
|
},
|
|
{
|
|
id: 'playable-narrative',
|
|
label: '可扮演角色叙事',
|
|
detail: '为可扮演角色补充公开背景、动机与风格。',
|
|
total: MIN_CUSTOM_WORLD_PLAYABLE_NPC_COUNT,
|
|
weight: Math.max(
|
|
1,
|
|
Math.ceil(
|
|
MIN_CUSTOM_WORLD_PLAYABLE_NPC_COUNT / CUSTOM_WORLD_PLAYABLE_BATCH_SIZE,
|
|
),
|
|
),
|
|
},
|
|
{
|
|
id: 'playable-dossier',
|
|
label: '可扮演角色档案',
|
|
detail: '补齐技能、好感章节与初始携带信息。',
|
|
total: MIN_CUSTOM_WORLD_PLAYABLE_NPC_COUNT,
|
|
weight: Math.max(
|
|
1,
|
|
Math.ceil(
|
|
MIN_CUSTOM_WORLD_PLAYABLE_NPC_COUNT / CUSTOM_WORLD_PLAYABLE_BATCH_SIZE,
|
|
),
|
|
),
|
|
},
|
|
{
|
|
id: 'playable-profile',
|
|
label: '可扮演角色叙事档案',
|
|
detail: '为可扮演角色生成首遇面具、当前压力和暗线钩子。',
|
|
total: MIN_CUSTOM_WORLD_PLAYABLE_NPC_COUNT,
|
|
weight: Math.max(
|
|
1,
|
|
Math.ceil(
|
|
MIN_CUSTOM_WORLD_PLAYABLE_NPC_COUNT / CUSTOM_WORLD_PLAYABLE_BATCH_SIZE,
|
|
),
|
|
),
|
|
},
|
|
{
|
|
id: 'story-narrative',
|
|
label: '场景角色叙事',
|
|
detail: '扩写场景角色的关系钩子与叙事位置。',
|
|
total: MIN_CUSTOM_WORLD_STORY_NPC_COUNT,
|
|
weight: Math.max(
|
|
1,
|
|
Math.ceil(
|
|
MIN_CUSTOM_WORLD_STORY_NPC_COUNT / CUSTOM_WORLD_STORY_BATCH_SIZE,
|
|
),
|
|
),
|
|
},
|
|
{
|
|
id: 'story-profile',
|
|
label: '场景角色叙事档案',
|
|
detail: '为场景角色生成首遇面具、当前压力和暗线钩子。',
|
|
total: MIN_CUSTOM_WORLD_STORY_NPC_COUNT,
|
|
weight: Math.max(
|
|
1,
|
|
Math.ceil(
|
|
MIN_CUSTOM_WORLD_STORY_NPC_COUNT / CUSTOM_WORLD_STORY_BATCH_SIZE,
|
|
),
|
|
),
|
|
},
|
|
{
|
|
id: 'story-dossier',
|
|
label: '场景角色档案',
|
|
detail: '补齐场景角色档案与互动素材。',
|
|
total: MIN_CUSTOM_WORLD_STORY_NPC_COUNT,
|
|
weight: Math.max(
|
|
1,
|
|
Math.ceil(
|
|
MIN_CUSTOM_WORLD_STORY_NPC_COUNT / CUSTOM_WORLD_STORY_BATCH_SIZE,
|
|
),
|
|
),
|
|
},
|
|
{
|
|
id: 'finalize',
|
|
label: '归档世界',
|
|
detail: '整理最终世界档案并做完整性校验。',
|
|
total: 1,
|
|
weight: 1,
|
|
},
|
|
] as const;
|
|
|
|
export type CustomWorldGenerationStageId =
|
|
(typeof CUSTOM_WORLD_GENERATION_STAGE_DEFINITIONS)[number]['id'];
|
|
|
|
const FAST_CUSTOM_WORLD_PLAYABLE_COUNT = 3;
|
|
const FAST_CUSTOM_WORLD_STORY_COUNT = 8;
|
|
const FAST_CUSTOM_WORLD_LANDMARK_COUNT = 4;
|
|
|
|
class CustomWorldGenerationAbortedError extends Error {
|
|
constructor(message = '世界生成已中断。') {
|
|
super(message);
|
|
this.name = 'CustomWorldGenerationAbortedError';
|
|
}
|
|
}
|
|
|
|
function normalizeApiErrorMessage(
|
|
responseText: string,
|
|
fallbackMessage: string,
|
|
) {
|
|
if (!responseText.trim()) {
|
|
return fallbackMessage;
|
|
}
|
|
|
|
try {
|
|
const parsed = JSON.parse(responseText) as {
|
|
error?: { message?: string };
|
|
message?: string;
|
|
};
|
|
if (
|
|
typeof parsed.error?.message === 'string' &&
|
|
parsed.error.message.trim()
|
|
) {
|
|
return parsed.error.message;
|
|
}
|
|
if (typeof parsed.message === 'string' && parsed.message.trim()) {
|
|
return parsed.message;
|
|
}
|
|
} catch {
|
|
// Fall through to the raw response text below.
|
|
}
|
|
|
|
return responseText;
|
|
}
|
|
|
|
function resolveCustomWorldGenerationInput(
|
|
input: string | GenerateCustomWorldProfileInput,
|
|
): {
|
|
settingText: string;
|
|
generationSeedText: string;
|
|
creatorIntent: CustomWorldCreatorIntent | null;
|
|
generationMode: CustomWorldGenerationMode;
|
|
} {
|
|
if (typeof input === 'string') {
|
|
return {
|
|
settingText: input.trim(),
|
|
generationSeedText: input.trim(),
|
|
creatorIntent: null as CustomWorldCreatorIntent | null,
|
|
generationMode: 'full' as CustomWorldGenerationMode,
|
|
};
|
|
}
|
|
|
|
const normalizedSettingText = input.settingText.trim();
|
|
const creatorIntent =
|
|
(input.creatorIntent as CustomWorldCreatorIntent | null | undefined) ??
|
|
null;
|
|
const generationSeedText =
|
|
creatorIntent && hasMeaningfulCustomWorldCreatorIntent(creatorIntent)
|
|
? buildCustomWorldCreatorIntentGenerationText(creatorIntent)
|
|
: normalizedSettingText;
|
|
|
|
return {
|
|
settingText: normalizedSettingText,
|
|
generationSeedText: generationSeedText.trim(),
|
|
creatorIntent,
|
|
generationMode:
|
|
input.generationMode === 'fast' ? ('fast' as const) : ('full' as const),
|
|
};
|
|
}
|
|
|
|
function getCustomWorldGenerationTargets(
|
|
generationMode: CustomWorldGenerationMode,
|
|
) {
|
|
if (generationMode === 'fast') {
|
|
return {
|
|
playableCount: FAST_CUSTOM_WORLD_PLAYABLE_COUNT,
|
|
storyCount: FAST_CUSTOM_WORLD_STORY_COUNT,
|
|
landmarkCount: FAST_CUSTOM_WORLD_LANDMARK_COUNT,
|
|
generationStatus: 'key_only' as const,
|
|
};
|
|
}
|
|
|
|
return {
|
|
playableCount: MIN_CUSTOM_WORLD_PLAYABLE_NPC_COUNT,
|
|
storyCount: MIN_CUSTOM_WORLD_STORY_NPC_COUNT,
|
|
landmarkCount: MIN_CUSTOM_WORLD_LANDMARK_COUNT,
|
|
generationStatus: 'complete' as const,
|
|
};
|
|
}
|
|
|
|
function sanitizeJsonLikeText(text: string) {
|
|
const trimmed = text.trim();
|
|
if (!trimmed) {
|
|
return '';
|
|
}
|
|
|
|
const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/iu);
|
|
const unfenced = fencedMatch?.[1]?.trim() || trimmed;
|
|
const firstBrace = unfenced.indexOf('{');
|
|
const lastBrace = unfenced.lastIndexOf('}');
|
|
const extracted =
|
|
firstBrace >= 0 && lastBrace > firstBrace
|
|
? unfenced.slice(firstBrace, lastBrace + 1)
|
|
: unfenced;
|
|
|
|
return extracted
|
|
.replace(/^\uFEFF/u, '')
|
|
.replace(/[\u201C\u201D]/gu, '"')
|
|
.replace(/[\u2018\u2019]/gu, "'")
|
|
.replace(/\u00A0/gu, ' ')
|
|
.replace(/,\s*([}\]])/gu, '$1')
|
|
.trim();
|
|
}
|
|
|
|
function toRecordArray(value: unknown) {
|
|
return Array.isArray(value)
|
|
? (value.filter((item) => item && typeof item === 'object') as Array<
|
|
Record<string, unknown>
|
|
>)
|
|
: [];
|
|
}
|
|
|
|
function getNamedRecordKey(value: unknown) {
|
|
return typeof value === 'string' ? value.trim() : '';
|
|
}
|
|
|
|
function chunkArray<T>(items: T[], size: number) {
|
|
if (size <= 0) {
|
|
return [items];
|
|
}
|
|
|
|
const chunks: T[][] = [];
|
|
for (let index = 0; index < items.length; index += size) {
|
|
chunks.push(items.slice(index, index + size));
|
|
}
|
|
return chunks;
|
|
}
|
|
|
|
function mergeRoleBatchDetails<T extends MergeableCustomWorldRoleEntry>(
|
|
baseEntries: T[],
|
|
detailEntries: Array<Record<string, unknown>>,
|
|
) {
|
|
const nextEntries = baseEntries.map((entry) => ({ ...entry })) as T[];
|
|
const availableIndexes = new Set(nextEntries.map((_, index) => index));
|
|
const indexByName = new Map<string, number>();
|
|
|
|
nextEntries.forEach((entry, index) => {
|
|
const name = getNamedRecordKey(entry.name);
|
|
if (name) {
|
|
indexByName.set(name, index);
|
|
}
|
|
});
|
|
|
|
detailEntries.forEach((detail) => {
|
|
const detailName = getNamedRecordKey(detail.name);
|
|
let targetIndex =
|
|
detailName && indexByName.has(detailName)
|
|
? indexByName.get(detailName)
|
|
: undefined;
|
|
|
|
if (targetIndex === undefined) {
|
|
for (const index of availableIndexes) {
|
|
targetIndex = index;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (targetIndex === undefined) {
|
|
return;
|
|
}
|
|
|
|
const baseEntry = nextEntries[targetIndex];
|
|
if (!baseEntry) {
|
|
return;
|
|
}
|
|
|
|
nextEntries[targetIndex] = {
|
|
...baseEntry,
|
|
...detail,
|
|
name: getNamedRecordKey(baseEntry.name) || detailName || baseEntry.name,
|
|
} as T;
|
|
availableIndexes.delete(targetIndex);
|
|
});
|
|
|
|
return nextEntries;
|
|
}
|
|
|
|
function appendUniqueNamedEntries<T extends MergeableCustomWorldRoleEntry>(
|
|
baseEntries: T[],
|
|
nextEntries: T[],
|
|
maxCount: number,
|
|
) {
|
|
const merged = baseEntries.map((entry) => ({ ...entry })) as T[];
|
|
const existingNames = new Set(
|
|
merged.map((entry) => getNamedRecordKey(entry.name)).filter(Boolean),
|
|
);
|
|
|
|
nextEntries.forEach((entry) => {
|
|
if (merged.length >= maxCount) {
|
|
return;
|
|
}
|
|
|
|
const name = getNamedRecordKey(entry.name);
|
|
if (!name || existingNames.has(name)) {
|
|
return;
|
|
}
|
|
|
|
merged.push({ ...entry, name } as T);
|
|
existingNames.add(name);
|
|
});
|
|
|
|
return merged;
|
|
}
|
|
|
|
const CUSTOM_WORLD_GENERATION_STAGE_MAP = new Map(
|
|
CUSTOM_WORLD_GENERATION_STAGE_DEFINITIONS.map((stage) => [stage.id, stage]),
|
|
);
|
|
const CUSTOM_WORLD_GENERATION_TOTAL_WEIGHT =
|
|
CUSTOM_WORLD_GENERATION_STAGE_DEFINITIONS.reduce(
|
|
(sum, stage) => sum + stage.weight,
|
|
0,
|
|
);
|
|
|
|
function getCustomWorldGenerationStageIdForRoleOutline(
|
|
roleType: CustomWorldGenerationRoleBatchType,
|
|
): CustomWorldGenerationStageId {
|
|
return roleType === 'playable' ? 'playable-outline' : 'story-outline';
|
|
}
|
|
|
|
function getCustomWorldGenerationStageIdForRoleExpansion(
|
|
roleType: CustomWorldGenerationRoleBatchType,
|
|
stage: CustomWorldGenerationRoleBatchStage,
|
|
): CustomWorldGenerationStageId {
|
|
if (roleType === 'playable') {
|
|
return stage === 'narrative' ? 'playable-narrative' : 'playable-dossier';
|
|
}
|
|
|
|
return stage === 'narrative' ? 'story-narrative' : 'story-dossier';
|
|
}
|
|
|
|
function getCustomWorldGenerationStageIdForActorProfile(
|
|
roleType: CustomWorldGenerationRoleBatchType,
|
|
): CustomWorldGenerationStageId {
|
|
return roleType === 'playable' ? 'playable-profile' : 'story-profile';
|
|
}
|
|
|
|
function throwIfCustomWorldGenerationAborted(signal?: AbortSignal) {
|
|
if (!signal?.aborted) {
|
|
return;
|
|
}
|
|
|
|
throw signal.reason instanceof Error
|
|
? signal.reason
|
|
: new CustomWorldGenerationAbortedError();
|
|
}
|
|
|
|
function isCustomWorldGenerationAbortLikeError(error: unknown) {
|
|
return (
|
|
error instanceof CustomWorldGenerationAbortedError ||
|
|
(typeof DOMException !== 'undefined' &&
|
|
error instanceof DOMException &&
|
|
error.name === 'AbortError')
|
|
);
|
|
}
|
|
|
|
function createCustomWorldGenerationReporter(
|
|
onProgress?: GenerateCustomWorldProfileOptions['onProgress'],
|
|
) {
|
|
const startedAt = performance.now();
|
|
const completedByStage = Object.fromEntries(
|
|
CUSTOM_WORLD_GENERATION_STAGE_DEFINITIONS.map((stage) => [stage.id, 0]),
|
|
) as Record<CustomWorldGenerationStageId, number>;
|
|
|
|
const emit = (
|
|
stageId: CustomWorldGenerationStageId,
|
|
options: Partial<{
|
|
completed: number;
|
|
phaseDetail: string;
|
|
batchLabel: string;
|
|
}> = {},
|
|
) => {
|
|
const stage = CUSTOM_WORLD_GENERATION_STAGE_MAP.get(stageId);
|
|
if (!stage) {
|
|
return;
|
|
}
|
|
|
|
if (typeof options.completed === 'number') {
|
|
completedByStage[stageId] = Math.max(
|
|
0,
|
|
Math.min(stage.total, options.completed),
|
|
);
|
|
}
|
|
|
|
const steps = CUSTOM_WORLD_GENERATION_STAGE_DEFINITIONS.map((item) => {
|
|
const completed = Math.max(
|
|
0,
|
|
Math.min(item.total, completedByStage[item.id]),
|
|
);
|
|
return {
|
|
id: item.id,
|
|
label: item.label,
|
|
detail: item.detail,
|
|
completed,
|
|
total: item.total,
|
|
status:
|
|
completed >= item.total
|
|
? 'completed'
|
|
: item.id === stageId
|
|
? 'active'
|
|
: 'pending',
|
|
} satisfies CustomWorldGenerationStep;
|
|
});
|
|
|
|
const completedWeight = CUSTOM_WORLD_GENERATION_STAGE_DEFINITIONS.reduce(
|
|
(sum, item) =>
|
|
sum + (completedByStage[item.id] / item.total || 0) * item.weight,
|
|
0,
|
|
);
|
|
const progressFraction =
|
|
CUSTOM_WORLD_GENERATION_TOTAL_WEIGHT > 0
|
|
? completedWeight / CUSTOM_WORLD_GENERATION_TOTAL_WEIGHT
|
|
: 0;
|
|
const elapsedMs = Math.max(0, performance.now() - startedAt);
|
|
const estimatedRemainingMs =
|
|
progressFraction > 0 && progressFraction < 1
|
|
? Math.max(0, Math.round(elapsedMs / progressFraction - elapsedMs))
|
|
: progressFraction >= 1
|
|
? 0
|
|
: null;
|
|
|
|
onProgress?.({
|
|
phaseId: stage.id,
|
|
phaseLabel: stage.label,
|
|
phaseDetail: options.phaseDetail ?? stage.detail,
|
|
batchLabel: options.batchLabel,
|
|
overallProgress: Math.max(
|
|
0,
|
|
Math.min(100, Math.round(progressFraction * 100)),
|
|
),
|
|
completedWeight,
|
|
totalWeight: CUSTOM_WORLD_GENERATION_TOTAL_WEIGHT,
|
|
elapsedMs: Math.round(elapsedMs),
|
|
estimatedRemainingMs,
|
|
activeStepIndex: CUSTOM_WORLD_GENERATION_STAGE_DEFINITIONS.findIndex(
|
|
(item) => item.id === stage.id,
|
|
),
|
|
steps,
|
|
});
|
|
};
|
|
|
|
return {
|
|
begin(
|
|
stageId: CustomWorldGenerationStageId,
|
|
options: Partial<{
|
|
phaseDetail: string;
|
|
batchLabel: string;
|
|
}> = {},
|
|
) {
|
|
emit(stageId, {
|
|
completed: completedByStage[stageId],
|
|
...options,
|
|
});
|
|
},
|
|
update(
|
|
stageId: CustomWorldGenerationStageId,
|
|
completed: number,
|
|
options: Partial<{
|
|
phaseDetail: string;
|
|
batchLabel: string;
|
|
}> = {},
|
|
) {
|
|
emit(stageId, {
|
|
completed,
|
|
...options,
|
|
});
|
|
},
|
|
complete(
|
|
stageId: CustomWorldGenerationStageId,
|
|
options: Partial<{
|
|
phaseDetail: string;
|
|
batchLabel: string;
|
|
}> = {},
|
|
) {
|
|
const stage = CUSTOM_WORLD_GENERATION_STAGE_MAP.get(stageId);
|
|
if (!stage) {
|
|
return;
|
|
}
|
|
|
|
emit(stageId, {
|
|
completed: stage.total,
|
|
...options,
|
|
});
|
|
},
|
|
};
|
|
}
|
|
|
|
type CustomWorldGenerationReporter = ReturnType<
|
|
typeof createCustomWorldGenerationReporter
|
|
>;
|
|
|
|
async function generateCustomWorldRoleOutlineEntries(params: {
|
|
framework: CustomWorldGenerationFramework;
|
|
roleType: CustomWorldGenerationRoleBatchType;
|
|
totalCount: number;
|
|
batchSize: number;
|
|
reporter?: CustomWorldGenerationReporter;
|
|
signal?: AbortSignal;
|
|
}) {
|
|
const {
|
|
framework,
|
|
roleType,
|
|
totalCount,
|
|
batchSize,
|
|
reporter = createCustomWorldGenerationReporter(),
|
|
signal,
|
|
} = params;
|
|
const stageId = getCustomWorldGenerationStageIdForRoleOutline(roleType);
|
|
const plannedBatchCount = Math.max(1, Math.ceil(totalCount / batchSize));
|
|
const roleLabel = roleType === 'playable' ? '可扮演角色' : '场景角色';
|
|
let mergedEntries: CustomWorldGenerationRoleOutline[] = [];
|
|
const maxBatchAttempts = Math.max(2, Math.ceil(totalCount / batchSize) + 2);
|
|
|
|
for (
|
|
let batchIndex = 0;
|
|
batchIndex < maxBatchAttempts && mergedEntries.length < totalCount;
|
|
batchIndex += 1
|
|
) {
|
|
throwIfCustomWorldGenerationAborted(signal);
|
|
const batchCount = Math.min(batchSize, totalCount - mergedEntries.length);
|
|
reporter.update(stageId, mergedEntries.length, {
|
|
phaseDetail: `正在生成${roleLabel}，已完成 ${mergedEntries.length}/${totalCount}。`,
|
|
batchLabel: `第 ${Math.min(batchIndex + 1, plannedBatchCount)} / ${plannedBatchCount} 批`,
|
|
});
|
|
const batchRaw = await requestCustomWorldJsonStage({
|
|
userPrompt: buildCustomWorldRoleOutlineBatchPrompt({
|
|
framework,
|
|
roleType,
|
|
batchCount,
|
|
forbiddenNames: mergedEntries.map((entry) => entry.name),
|
|
}),
|
|
debugLabel: `custom-world-${roleType}-outline-batch-${batchIndex + 1}`,
|
|
repairPromptBuilder: (responseText) =>
|
|
buildCustomWorldRoleOutlineBatchJsonRepairPrompt({
|
|
responseText,
|
|
roleType,
|
|
expectedCount: batchCount,
|
|
forbiddenNames: mergedEntries.map((entry) => entry.name),
|
|
}),
|
|
repairDebugLabel: `custom-world-${roleType}-outline-batch-${batchIndex + 1}-json-repair`,
|
|
emptyResponseMessage: `自定义世界${roleType === 'playable' ? '可扮演角色' : '场景角色'}名单批次 ${batchIndex + 1} 生成失败：模型没有返回有效内容。`,
|
|
signal,
|
|
});
|
|
|
|
mergedEntries = appendUniqueNamedEntries(
|
|
mergedEntries,
|
|
normalizeCustomWorldGenerationRoleOutlineBatch(batchRaw, roleType),
|
|
totalCount,
|
|
);
|
|
reporter.update(stageId, mergedEntries.length, {
|
|
phaseDetail: `正在生成${roleLabel}，已完成 ${mergedEntries.length}/${totalCount}。`,
|
|
batchLabel: `第 ${Math.min(batchIndex + 1, plannedBatchCount)} / ${plannedBatchCount} 批`,
|
|
});
|
|
|
|
if (batchCount <= 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return mergedEntries;
|
|
}
|
|
|
|
async function generateCustomWorldLandmarkSeedEntries(params: {
|
|
framework: CustomWorldGenerationFramework;
|
|
totalCount: number;
|
|
batchSize: number;
|
|
reporter?: CustomWorldGenerationReporter;
|
|
signal?: AbortSignal;
|
|
}) {
|
|
const {
|
|
framework,
|
|
totalCount,
|
|
batchSize,
|
|
reporter = createCustomWorldGenerationReporter(),
|
|
signal,
|
|
} = params;
|
|
const plannedBatchCount = Math.max(1, Math.ceil(totalCount / batchSize));
|
|
let mergedEntries: CustomWorldGenerationLandmarkOutline[] = [];
|
|
const maxBatchAttempts = Math.max(2, Math.ceil(totalCount / batchSize) + 2);
|
|
|
|
for (
|
|
let batchIndex = 0;
|
|
batchIndex < maxBatchAttempts && mergedEntries.length < totalCount;
|
|
batchIndex += 1
|
|
) {
|
|
throwIfCustomWorldGenerationAborted(signal);
|
|
const batchCount = Math.min(batchSize, totalCount - mergedEntries.length);
|
|
reporter.update('landmark-seed', mergedEntries.length, {
|
|
phaseDetail: `正在生成场景骨架，已完成 ${mergedEntries.length}/${totalCount}。`,
|
|
batchLabel: `第 ${Math.min(batchIndex + 1, plannedBatchCount)} / ${plannedBatchCount} 批`,
|
|
});
|
|
const batchRaw = await requestCustomWorldJsonStage({
|
|
userPrompt: buildCustomWorldLandmarkSeedBatchPrompt({
|
|
framework,
|
|
batchCount,
|
|
forbiddenNames: mergedEntries.map((entry) => entry.name),
|
|
}),
|
|
debugLabel: `custom-world-landmark-seed-batch-${batchIndex + 1}`,
|
|
repairPromptBuilder: (responseText) =>
|
|
buildCustomWorldLandmarkSeedBatchJsonRepairPrompt({
|
|
responseText,
|
|
expectedCount: batchCount,
|
|
forbiddenNames: mergedEntries.map((entry) => entry.name),
|
|
}),
|
|
repairDebugLabel: `custom-world-landmark-seed-batch-${batchIndex + 1}-json-repair`,
|
|
emptyResponseMessage: `自定义世界场景骨架批次 ${batchIndex + 1} 生成失败：模型没有返回有效内容。`,
|
|
signal,
|
|
});
|
|
|
|
mergedEntries = appendUniqueNamedEntries(
|
|
mergedEntries,
|
|
normalizeCustomWorldGenerationLandmarkOutlineBatch(batchRaw),
|
|
totalCount,
|
|
);
|
|
reporter.update('landmark-seed', mergedEntries.length, {
|
|
phaseDetail: `正在生成场景骨架，已完成 ${mergedEntries.length}/${totalCount}。`,
|
|
batchLabel: `第 ${Math.min(batchIndex + 1, plannedBatchCount)} / ${plannedBatchCount} 批`,
|
|
});
|
|
|
|
if (batchCount <= 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return mergedEntries;
|
|
}
|
|
|
|
async function expandCustomWorldRoleEntries<
|
|
T extends MergeableCustomWorldRoleEntry,
|
|
>(params: {
|
|
framework: CustomWorldGenerationFramework;
|
|
roleType: CustomWorldGenerationRoleBatchType;
|
|
baseEntries: T[];
|
|
batchSize: number;
|
|
reporter?: CustomWorldGenerationReporter;
|
|
signal?: AbortSignal;
|
|
}) {
|
|
const {
|
|
framework,
|
|
roleType,
|
|
baseEntries,
|
|
batchSize,
|
|
reporter = createCustomWorldGenerationReporter(),
|
|
signal,
|
|
} = params;
|
|
const roleBatchSource =
|
|
roleType === 'playable' ? framework.playableNpcs : framework.storyNpcs;
|
|
const roleLabel = roleType === 'playable' ? '可扮演角色' : '场景角色';
|
|
let mergedEntries = baseEntries.map((entry) => ({ ...entry })) as T[];
|
|
const plannedBatchCount = Math.max(
|
|
1,
|
|
Math.ceil(roleBatchSource.length / batchSize),
|
|
);
|
|
const processedByStage: Record<CustomWorldGenerationRoleBatchStage, number> =
|
|
{
|
|
narrative: 0,
|
|
dossier: 0,
|
|
};
|
|
|
|
const requestBatchStage = async (
|
|
roleBatch: typeof roleBatchSource,
|
|
batchIndex: number,
|
|
stage: CustomWorldGenerationRoleBatchStage,
|
|
) => {
|
|
throwIfCustomWorldGenerationAborted(signal);
|
|
const stageLabel = stage === 'narrative' ? '叙事设定' : '档案补全';
|
|
const stageId = getCustomWorldGenerationStageIdForRoleExpansion(
|
|
roleType,
|
|
stage,
|
|
);
|
|
reporter.update(stageId, processedByStage[stage], {
|
|
phaseDetail: `正在补充${roleLabel}${stageLabel}，已完成 ${processedByStage[stage]}/${roleBatchSource.length}。`,
|
|
batchLabel: `第 ${batchIndex + 1} / ${plannedBatchCount} 批`,
|
|
});
|
|
const stageRaw = await requestCustomWorldJsonStage({
|
|
userPrompt: buildCustomWorldRoleBatchPrompt({
|
|
framework,
|
|
roleType,
|
|
roleBatch,
|
|
stage,
|
|
}),
|
|
debugLabel: `custom-world-${roleType}-${stage}-batch-${batchIndex + 1}`,
|
|
repairPromptBuilder: (responseText) =>
|
|
buildCustomWorldRoleBatchJsonRepairPrompt({
|
|
responseText,
|
|
roleType,
|
|
expectedNames: roleBatch.map((role) => role.name),
|
|
stage,
|
|
}),
|
|
repairDebugLabel: `custom-world-${roleType}-${stage}-batch-${batchIndex + 1}-json-repair`,
|
|
emptyResponseMessage: `自定义世界${roleLabel}批次 ${batchIndex + 1} 的${stageLabel}生成失败：模型没有返回有效内容。`,
|
|
signal,
|
|
});
|
|
|
|
mergedEntries = mergeRoleBatchDetails(
|
|
mergedEntries,
|
|
toRecordArray(
|
|
stageRaw && typeof stageRaw === 'object'
|
|
? (stageRaw as Record<string, unknown>)[
|
|
roleType === 'playable' ? 'playableNpcs' : 'storyNpcs'
|
|
]
|
|
: [],
|
|
),
|
|
);
|
|
processedByStage[stage] = Math.min(
|
|
roleBatchSource.length,
|
|
processedByStage[stage] + roleBatch.length,
|
|
);
|
|
reporter.update(stageId, processedByStage[stage], {
|
|
phaseDetail: `正在补充${roleLabel}${stageLabel}，已完成 ${processedByStage[stage]}/${roleBatchSource.length}。`,
|
|
batchLabel: `第 ${batchIndex + 1} / ${plannedBatchCount} 批`,
|
|
});
|
|
};
|
|
|
|
for (const [batchIndex, roleBatch] of chunkArray(
|
|
roleBatchSource,
|
|
batchSize,
|
|
).entries()) {
|
|
await requestBatchStage(roleBatch, batchIndex, 'narrative');
|
|
await requestBatchStage(roleBatch, batchIndex, 'dossier');
|
|
}
|
|
|
|
return mergedEntries;
|
|
}
|
|
|
|
async function generateCustomWorldThemePackWithAi(params: {
|
|
framework: CustomWorldGenerationFramework;
|
|
signal?: AbortSignal;
|
|
}) {
|
|
const { framework, signal } = params;
|
|
const fallback = buildThemePackFromWorldProfile({
|
|
...framework,
|
|
templateWorldType:
|
|
framework.templateWorldType === WorldType.XIANXIA
|
|
? WorldType.XIANXIA
|
|
: WorldType.WUXIA,
|
|
});
|
|
const raw = await requestCustomWorldJsonStage({
|
|
userPrompt: buildCustomWorldThemePackPrompt({ framework }),
|
|
debugLabel: 'custom-world-theme-pack',
|
|
repairPromptBuilder: (responseText) =>
|
|
buildCustomWorldThemePackJsonRepairPrompt({ responseText }),
|
|
repairDebugLabel: 'custom-world-theme-pack-json-repair',
|
|
emptyResponseMessage:
|
|
'自定义世界 ThemePack 生成失败：模型没有返回有效内容。',
|
|
signal,
|
|
});
|
|
|
|
return normalizeThemePack(raw, fallback);
|
|
}
|
|
|
|
async function generateCustomWorldStoryGraphWithAi(params: {
|
|
framework: CustomWorldGenerationFramework;
|
|
themePack: ThemePack;
|
|
signal?: AbortSignal;
|
|
}) {
|
|
const { framework, themePack, signal } = params;
|
|
const profileSeed = buildExpandedCustomWorldProfile(
|
|
buildCustomWorldRawProfileFromFramework(framework),
|
|
framework.settingText,
|
|
);
|
|
const fallback = buildFallbackWorldStoryGraph(
|
|
{
|
|
...profileSeed,
|
|
themePack,
|
|
},
|
|
themePack,
|
|
);
|
|
const raw = await requestCustomWorldJsonStage({
|
|
userPrompt: buildCustomWorldStoryGraphPrompt({
|
|
framework,
|
|
themePack,
|
|
}),
|
|
debugLabel: 'custom-world-story-graph',
|
|
repairPromptBuilder: (responseText) =>
|
|
buildCustomWorldStoryGraphJsonRepairPrompt({ responseText }),
|
|
repairDebugLabel: 'custom-world-story-graph-json-repair',
|
|
emptyResponseMessage:
|
|
'自定义世界 StoryGraph 生成失败：模型没有返回有效内容。',
|
|
signal,
|
|
});
|
|
|
|
return normalizeWorldStoryGraph(raw, fallback);
|
|
}
|
|
|
|
async function expandCustomWorldActorNarrativeProfiles<
|
|
T extends MergeableCustomWorldRoleEntry,
|
|
>(params: {
|
|
framework: CustomWorldGenerationFramework;
|
|
roleType: CustomWorldGenerationRoleBatchType;
|
|
baseEntries: T[];
|
|
batchSize: number;
|
|
themePack: ThemePack;
|
|
storyGraph: WorldStoryGraph;
|
|
reporter?: CustomWorldGenerationReporter;
|
|
signal?: AbortSignal;
|
|
}) {
|
|
const {
|
|
framework,
|
|
roleType,
|
|
baseEntries,
|
|
batchSize,
|
|
themePack,
|
|
storyGraph,
|
|
reporter = createCustomWorldGenerationReporter(),
|
|
signal,
|
|
} = params;
|
|
const roleBatchSource = baseEntries;
|
|
const roleLabel = roleType === 'playable' ? '可扮演角色' : '场景角色';
|
|
const stageId = getCustomWorldGenerationStageIdForActorProfile(roleType);
|
|
const plannedBatchCount = Math.max(
|
|
1,
|
|
Math.ceil(roleBatchSource.length / batchSize),
|
|
);
|
|
let mergedEntries = baseEntries.map((entry) => ({ ...entry })) as T[];
|
|
let processedCount = 0;
|
|
|
|
for (const [batchIndex, roleBatch] of chunkArray(
|
|
roleBatchSource,
|
|
batchSize,
|
|
).entries()) {
|
|
throwIfCustomWorldGenerationAborted(signal);
|
|
reporter.update(stageId, processedCount, {
|
|
phaseDetail: `正在补充${roleLabel}叙事档案，已完成 ${processedCount}/${roleBatchSource.length}。`,
|
|
batchLabel: `第 ${batchIndex + 1} / ${plannedBatchCount} 批`,
|
|
});
|
|
const stageRaw = await requestCustomWorldJsonStage({
|
|
userPrompt: buildCustomWorldActorNarrativeProfileBatchPrompt({
|
|
framework,
|
|
roleType,
|
|
roleBatch: roleBatch as Array<Record<string, unknown>>,
|
|
themePack,
|
|
storyGraph,
|
|
}),
|
|
debugLabel: `custom-world-${roleType}-actor-profile-batch-${batchIndex + 1}`,
|
|
repairPromptBuilder: (responseText) =>
|
|
buildCustomWorldActorNarrativeProfileBatchJsonRepairPrompt({
|
|
responseText,
|
|
roleType,
|
|
expectedNames: roleBatch.map((role) => getNamedRecordKey(role.name)),
|
|
}),
|
|
repairDebugLabel: `custom-world-${roleType}-actor-profile-batch-${batchIndex + 1}-json-repair`,
|
|
emptyResponseMessage: `自定义世界${roleLabel}叙事档案批次 ${batchIndex + 1} 生成失败：模型没有返回有效内容。`,
|
|
signal,
|
|
});
|
|
|
|
mergedEntries = mergeRoleBatchDetails(
|
|
mergedEntries,
|
|
toRecordArray(
|
|
stageRaw && typeof stageRaw === 'object'
|
|
? (stageRaw as Record<string, unknown>)[
|
|
roleType === 'playable' ? 'playableNpcs' : 'storyNpcs'
|
|
]
|
|
: [],
|
|
),
|
|
);
|
|
processedCount = Math.min(
|
|
roleBatchSource.length,
|
|
processedCount + roleBatch.length,
|
|
);
|
|
reporter.update(stageId, processedCount, {
|
|
phaseDetail: `正在补充${roleLabel}叙事档案，已完成 ${processedCount}/${roleBatchSource.length}。`,
|
|
batchLabel: `第 ${batchIndex + 1} / ${plannedBatchCount} 批`,
|
|
});
|
|
}
|
|
|
|
return mergedEntries.map((entry) => {
|
|
const item = entry as Record<string, unknown>;
|
|
const fallbackProfile = buildFallbackActorNarrativeProfile(
|
|
entry as unknown as CustomWorldProfile['storyNpcs'][number],
|
|
storyGraph,
|
|
themePack,
|
|
);
|
|
|
|
return {
|
|
...entry,
|
|
narrativeProfile: normalizeActorNarrativeProfile(
|
|
item.narrativeProfile,
|
|
fallbackProfile,
|
|
),
|
|
} as T;
|
|
});
|
|
}
|
|
|
|
async function parseCustomWorldStageResponseJson(params: {
|
|
responseText: string;
|
|
repairPrompt: string;
|
|
repairDebugLabel: string;
|
|
signal?: AbortSignal;
|
|
}) {
|
|
const { responseText, repairPrompt, repairDebugLabel, signal } = params;
|
|
throwIfCustomWorldGenerationAborted(signal);
|
|
try {
|
|
return parseJsonResponseTextFromParser(responseText);
|
|
} catch {
|
|
const sanitized = sanitizeJsonLikeText(responseText);
|
|
if (sanitized && sanitized !== responseText.trim()) {
|
|
try {
|
|
return parseJsonResponseTextFromParser(sanitized);
|
|
} catch {
|
|
// Fall through to model-assisted repair.
|
|
}
|
|
}
|
|
|
|
const repairedText = await requestPlainTextCompletionFromClient(
|
|
CUSTOM_WORLD_JSON_REPAIR_SYSTEM_PROMPT,
|
|
repairPrompt,
|
|
{
|
|
timeoutMs: Math.max(
|
|
30000,
|
|
Math.min(
|
|
90000,
|
|
Math.round(CLIENT_CUSTOM_WORLD_REQUEST_TIMEOUT_MS / 2),
|
|
),
|
|
),
|
|
debugLabel: repairDebugLabel,
|
|
signal,
|
|
},
|
|
);
|
|
|
|
throwIfCustomWorldGenerationAborted(signal);
|
|
return parseJsonResponseTextFromParser(
|
|
sanitizeJsonLikeText(repairedText) || repairedText,
|
|
);
|
|
}
|
|
}
|
|
|
|
async function requestCustomWorldJsonStage(params: {
|
|
userPrompt: string;
|
|
debugLabel: string;
|
|
repairPromptBuilder: (responseText: string) => string;
|
|
repairDebugLabel: string;
|
|
emptyResponseMessage: string;
|
|
signal?: AbortSignal;
|
|
}) {
|
|
const {
|
|
userPrompt,
|
|
debugLabel,
|
|
repairPromptBuilder,
|
|
repairDebugLabel,
|
|
emptyResponseMessage,
|
|
signal,
|
|
} = params;
|
|
const timeoutPlan = [
|
|
CLIENT_CUSTOM_WORLD_REQUEST_TIMEOUT_MS,
|
|
Math.max(CLIENT_CUSTOM_WORLD_REQUEST_TIMEOUT_MS, 180000),
|
|
].filter((timeoutMs, index, array) => array.indexOf(timeoutMs) === index);
|
|
|
|
let text = '';
|
|
let lastTimeoutError: unknown = null;
|
|
|
|
for (const [attemptIndex, timeoutMs] of timeoutPlan.entries()) {
|
|
try {
|
|
throwIfCustomWorldGenerationAborted(signal);
|
|
const responseText = await requestPlainTextCompletionFromClient(
|
|
CUSTOM_WORLD_GENERATION_JSON_ONLY_SYSTEM_PROMPT,
|
|
userPrompt,
|
|
{
|
|
timeoutMs,
|
|
debugLabel:
|
|
attemptIndex === 0
|
|
? debugLabel
|
|
: `${debugLabel}-retry-${attemptIndex + 1}`,
|
|
signal,
|
|
},
|
|
);
|
|
text = typeof responseText === 'string' ? responseText : '';
|
|
break;
|
|
} catch (error) {
|
|
if (
|
|
isLlmTimeoutErrorFromClient(error) &&
|
|
attemptIndex < timeoutPlan.length - 1
|
|
) {
|
|
lastTimeoutError = error;
|
|
continue;
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
if (!text.trim()) {
|
|
throw lastTimeoutError ?? new Error(emptyResponseMessage);
|
|
}
|
|
|
|
return parseCustomWorldStageResponseJson({
|
|
responseText: text,
|
|
repairPrompt: repairPromptBuilder(text),
|
|
repairDebugLabel,
|
|
signal,
|
|
});
|
|
}
|
|
|
|
function buildFunctionContext(
|
|
worldType: WorldType,
|
|
character: Character,
|
|
monsters: SceneHostileNpc[],
|
|
context: StoryGenerationContext,
|
|
): FunctionAvailabilityContext {
|
|
return {
|
|
worldType,
|
|
playerCharacter: character,
|
|
inBattle: context.inBattle,
|
|
currentSceneId: context.sceneId,
|
|
currentSceneName: context.sceneName,
|
|
monsters,
|
|
playerHp: context.playerHp,
|
|
playerMaxHp: context.playerMaxHp,
|
|
playerMana: context.playerMana,
|
|
playerMaxMana: context.playerMaxMana,
|
|
};
|
|
}
|
|
|
|
function normalizeEncounterResult(
|
|
raw: unknown,
|
|
worldType: WorldType,
|
|
context: StoryGenerationContext,
|
|
): SceneEncounterResult | undefined {
|
|
if (!raw || typeof raw !== 'object') return undefined;
|
|
|
|
const scene = getScenePresetById(worldType, context.sceneId);
|
|
const item = raw as Record<string, unknown>;
|
|
const kind = typeof item.kind === 'string' ? item.kind.trim() : '';
|
|
|
|
if (kind === 'monster') {
|
|
const fallbackHostileNpc = scene?.npcs.find((npc: SceneNpc) =>
|
|
isHostileSceneNpc(npc),
|
|
);
|
|
|
|
return fallbackHostileNpc
|
|
? { kind: 'npc', npcId: fallbackHostileNpc.id }
|
|
: { kind: 'none' };
|
|
}
|
|
|
|
if (kind === 'npc') {
|
|
const npcId = typeof item.npcId === 'string' ? item.npcId.trim() : '';
|
|
const isValidNpc =
|
|
scene?.npcs?.some((npc: SceneNpc) => npc.id === npcId) ?? false;
|
|
return isValidNpc ? { kind: 'npc', npcId } : { kind: 'none' };
|
|
}
|
|
|
|
if (kind === 'treasure') {
|
|
return {
|
|
kind: 'treasure',
|
|
treasureText:
|
|
typeof item.treasureText === 'string'
|
|
? item.treasureText.trim()
|
|
: undefined,
|
|
};
|
|
}
|
|
|
|
return { kind: 'none' };
|
|
}
|
|
|
|
function buildEncounterDrivenResolution(
|
|
worldType: WorldType,
|
|
inputMonsters: SceneHostileNpc[],
|
|
context: StoryGenerationContext,
|
|
encounter: SceneEncounterResult | undefined,
|
|
) {
|
|
const scene = getScenePresetById(worldType, context.sceneId);
|
|
|
|
if (!context.pendingSceneEncounter) {
|
|
return {
|
|
monsters: inputMonsters,
|
|
inBattle: context.inBattle,
|
|
encounter: undefined,
|
|
};
|
|
}
|
|
|
|
if (encounter?.kind === 'npc') {
|
|
const sceneNpc = scene?.npcs.find(
|
|
(npc: SceneNpc) => npc.id === encounter.npcId,
|
|
);
|
|
if (sceneNpc?.monsterPresetId && isHostileSceneNpc(sceneNpc)) {
|
|
return {
|
|
monsters: createSceneHostileNpcsFromEncounters(
|
|
worldType,
|
|
[buildEncounterFromSceneNpc(sceneNpc, context.playerX)],
|
|
context.playerX,
|
|
),
|
|
inBattle: true,
|
|
encounter,
|
|
};
|
|
}
|
|
|
|
return {
|
|
monsters: [],
|
|
inBattle: false,
|
|
encounter,
|
|
};
|
|
}
|
|
|
|
return {
|
|
monsters: [],
|
|
inBattle: false,
|
|
encounter: encounter ?? { kind: 'none' as const },
|
|
};
|
|
}
|
|
|
|
function resolveSafeGeneratedActionText(actionText: string | undefined) {
|
|
const trimmed = actionText?.trim();
|
|
if (!trimmed || hasMixedNarrativeLanguage(trimmed)) {
|
|
return undefined;
|
|
}
|
|
|
|
return trimmed;
|
|
}
|
|
|
|
function resolveOptionsFromFunctionIds(
|
|
items: RawOptionItem[],
|
|
worldType: WorldType,
|
|
character: Character,
|
|
monsters: SceneHostileNpc[],
|
|
context: StoryGenerationContext,
|
|
): StoryOption[] {
|
|
const functionContext = buildFunctionContext(
|
|
worldType,
|
|
character,
|
|
monsters,
|
|
context,
|
|
);
|
|
|
|
return items
|
|
.map((item) =>
|
|
resolveFunctionOption(
|
|
item.functionId,
|
|
functionContext,
|
|
resolveSafeGeneratedActionText(item.actionText),
|
|
),
|
|
)
|
|
.filter(Boolean) as StoryOption[];
|
|
}
|
|
|
|
function cloneStoryOption(option: StoryOption): StoryOption {
|
|
return {
|
|
...option,
|
|
visuals: {
|
|
...option.visuals,
|
|
monsterChanges: option.visuals.monsterChanges.map((change) => ({
|
|
...change,
|
|
})),
|
|
},
|
|
interaction: option.interaction ? { ...option.interaction } : undefined,
|
|
skillProbabilities: option.skillProbabilities
|
|
? { ...option.skillProbabilities }
|
|
: undefined,
|
|
};
|
|
}
|
|
|
|
function resolveOptionsFromProvidedOptions(
|
|
items: RawOptionItem[],
|
|
availableOptions: StoryOption[],
|
|
): StoryOption[] {
|
|
if (items.length === 0) {
|
|
return availableOptions.map(cloneStoryOption);
|
|
}
|
|
|
|
const optionBuckets = new Map<string, StoryOption[]>();
|
|
const consumedOptions = new Set<StoryOption>();
|
|
availableOptions.forEach((option) => {
|
|
const bucket = optionBuckets.get(option.functionId) ?? [];
|
|
bucket.push(option);
|
|
optionBuckets.set(option.functionId, bucket);
|
|
});
|
|
|
|
const resolved: StoryOption[] = [];
|
|
|
|
items.forEach((item) => {
|
|
const bucket = optionBuckets.get(item.functionId);
|
|
const matchedOption = bucket?.shift();
|
|
if (!matchedOption) return;
|
|
consumedOptions.add(matchedOption);
|
|
|
|
const rewrittenText = resolveSafeGeneratedActionText(item.actionText);
|
|
resolved.push({
|
|
...cloneStoryOption(matchedOption),
|
|
actionText: rewrittenText || matchedOption.actionText,
|
|
text: rewrittenText || matchedOption.text || matchedOption.actionText,
|
|
} satisfies StoryOption);
|
|
});
|
|
|
|
if (resolved.length === availableOptions.length) {
|
|
return resolved;
|
|
}
|
|
|
|
const remainingOptions = availableOptions.filter(
|
|
(option) => !consumedOptions.has(option),
|
|
);
|
|
|
|
return [...resolved, ...remainingOptions.map(cloneStoryOption)];
|
|
}
|
|
|
|
function resolveOptionsFromOptionCatalog(
|
|
items: RawOptionItem[],
|
|
optionCatalog: StoryOption[],
|
|
): StoryOption[] {
|
|
if (items.length === 0) {
|
|
return optionCatalog.map(cloneStoryOption);
|
|
}
|
|
|
|
const optionBuckets = new Map<string, StoryOption[]>();
|
|
optionCatalog.forEach((option) => {
|
|
const bucket = optionBuckets.get(option.functionId) ?? [];
|
|
bucket.push(option);
|
|
optionBuckets.set(option.functionId, bucket);
|
|
});
|
|
|
|
const resolved: StoryOption[] = [];
|
|
|
|
items.forEach((item) => {
|
|
const bucket = optionBuckets.get(item.functionId);
|
|
const matchedOption = bucket?.shift();
|
|
if (!matchedOption) return;
|
|
|
|
const rewrittenText = resolveSafeGeneratedActionText(item.actionText);
|
|
resolved.push({
|
|
...cloneStoryOption(matchedOption),
|
|
actionText: rewrittenText || matchedOption.actionText,
|
|
text: rewrittenText || matchedOption.text || matchedOption.actionText,
|
|
} satisfies StoryOption);
|
|
});
|
|
|
|
return resolved;
|
|
}
|
|
|
|
function getFallbackOptions(
|
|
worldType: WorldType,
|
|
character: Character,
|
|
monsters: SceneHostileNpc[],
|
|
context: StoryGenerationContext,
|
|
): StoryOption[] {
|
|
const functionContext = buildFunctionContext(
|
|
worldType,
|
|
character,
|
|
monsters,
|
|
context,
|
|
);
|
|
|
|
return resolveOptionsFromFunctionIds(
|
|
getDefaultFunctionIdsForContext(functionContext).map((functionId) => ({
|
|
functionId,
|
|
})),
|
|
worldType,
|
|
character,
|
|
monsters,
|
|
context,
|
|
);
|
|
}
|
|
|
|
export const generateInitialStoryStrict = generateInitialStoryFromServer;
|
|
|
|
export const generateNextStepStrict = generateNextStepFromServer;
|
|
|
|
export async function generateCustomWorldSceneImage({
|
|
profile,
|
|
landmark,
|
|
userPrompt,
|
|
prompt,
|
|
negativePrompt,
|
|
size = '1280*720',
|
|
referenceImageSrc,
|
|
}: CustomWorldSceneImageRequest): Promise<CustomWorldSceneImageResult> {
|
|
const resolvedPrompt = prompt?.trim() || userPrompt?.trim() || '';
|
|
const resolvedNegativePrompt =
|
|
negativePrompt?.trim() || DEFAULT_CUSTOM_WORLD_SCENE_IMAGE_NEGATIVE_PROMPT;
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(
|
|
() => controller.abort(),
|
|
CUSTOM_WORLD_SCENE_IMAGE_REQUEST_TIMEOUT_MS,
|
|
);
|
|
|
|
try {
|
|
const response = await fetchWithApiAuth(
|
|
CUSTOM_WORLD_SCENE_IMAGE_API_BASE_URL,
|
|
{
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
profileId: profile.id,
|
|
worldName: profile.name,
|
|
landmarkId: landmark.id,
|
|
landmarkName: landmark.name,
|
|
...(prompt?.trim() ? { prompt: prompt.trim() } : {}),
|
|
userPrompt: resolvedPrompt,
|
|
negativePrompt: resolvedNegativePrompt,
|
|
size,
|
|
profile: {
|
|
id: profile.id,
|
|
name: profile.name,
|
|
subtitle: profile.subtitle,
|
|
summary: profile.summary,
|
|
tone: profile.tone,
|
|
playerGoal: profile.playerGoal,
|
|
settingText: profile.settingText,
|
|
},
|
|
landmark: {
|
|
id: landmark.id,
|
|
name: landmark.name,
|
|
description: landmark.description,
|
|
},
|
|
...(referenceImageSrc?.trim()
|
|
? { referenceImageSrc: referenceImageSrc.trim() }
|
|
: {}),
|
|
}),
|
|
signal: controller.signal,
|
|
},
|
|
);
|
|
const responseText = await response.text();
|
|
|
|
if (!response.ok) {
|
|
throw new Error(
|
|
normalizeApiErrorMessage(responseText, '场景图片生成失败。'),
|
|
);
|
|
}
|
|
|
|
const data = unwrapApiResponse(
|
|
JSON.parse(responseText) as Partial<CustomWorldSceneImageResult>,
|
|
) as Partial<CustomWorldSceneImageResult>;
|
|
if (
|
|
!data.imageSrc ||
|
|
!data.assetId ||
|
|
!data.model ||
|
|
!data.size ||
|
|
!data.taskId
|
|
) {
|
|
throw new Error('场景图片生成服务返回的数据不完整，请稍后重试。');
|
|
}
|
|
|
|
return {
|
|
imageSrc: data.imageSrc,
|
|
assetId: data.assetId,
|
|
model: data.model,
|
|
size: data.size,
|
|
taskId: data.taskId,
|
|
prompt: data.prompt || resolvedPrompt,
|
|
actualPrompt:
|
|
typeof data.actualPrompt === 'string' && data.actualPrompt.trim()
|
|
? data.actualPrompt
|
|
: undefined,
|
|
};
|
|
} catch (error) {
|
|
if (
|
|
typeof DOMException !== 'undefined' &&
|
|
error instanceof DOMException &&
|
|
error.name === 'AbortError'
|
|
) {
|
|
throw new Error('场景图片生成超时，请稍后重试。');
|
|
}
|
|
if (error instanceof TypeError) {
|
|
throw new Error('无法连接场景图片生成服务，请确认本地开发服务器已启动。');
|
|
}
|
|
throw error;
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
}
|
|
}
|
|
|
|
export async function generateCustomWorldProfile(
|
|
input: string | GenerateCustomWorldProfileInput,
|
|
options: GenerateCustomWorldProfileOptions = {},
|
|
): Promise<CustomWorldProfile> {
|
|
const {
|
|
settingText: normalizedSettingText,
|
|
generationSeedText,
|
|
creatorIntent,
|
|
generationMode,
|
|
} = resolveCustomWorldGenerationInput(input);
|
|
const generationTargets = getCustomWorldGenerationTargets(generationMode);
|
|
const reporter = createCustomWorldGenerationReporter(options.onProgress);
|
|
const signal = options.signal;
|
|
|
|
try {
|
|
throwIfCustomWorldGenerationAborted(signal);
|
|
reporter.begin('framework', {
|
|
phaseDetail: '正在解析你的设定文本，准备搭建世界框架。',
|
|
});
|
|
const frameworkRaw = await requestCustomWorldJsonStage({
|
|
userPrompt: buildCustomWorldFrameworkPrompt(generationSeedText),
|
|
debugLabel: 'custom-world-framework',
|
|
repairPromptBuilder: buildCustomWorldFrameworkJsonRepairPrompt,
|
|
repairDebugLabel: 'custom-world-framework-json-repair',
|
|
emptyResponseMessage: '自定义世界框架生成失败：模型没有返回有效内容。',
|
|
signal,
|
|
});
|
|
const frameworkBase = {
|
|
...normalizeCustomWorldGenerationFramework(
|
|
frameworkRaw,
|
|
generationSeedText,
|
|
),
|
|
playableNpcs: [],
|
|
storyNpcs: [],
|
|
landmarks: [],
|
|
} satisfies CustomWorldGenerationFramework;
|
|
reporter.complete('framework', {
|
|
phaseDetail: '世界框架已确定，开始围绕你的设定继续编译题材层与关键对象。',
|
|
});
|
|
reporter.begin('theme-pack', {
|
|
phaseDetail: '正在提炼题材适配层词汇与命名范式。',
|
|
});
|
|
const themePack = await generateCustomWorldThemePackWithAi({
|
|
framework: frameworkBase,
|
|
signal,
|
|
});
|
|
reporter.complete('theme-pack', {
|
|
phaseDetail: `题材适配层已完成，当前题材包为“${themePack.displayName}”。`,
|
|
});
|
|
|
|
reporter.begin('playable-outline', {
|
|
phaseDetail: '正在生成可扮演角色骨架。',
|
|
});
|
|
const playableNpcs = (await generateCustomWorldRoleOutlineEntries({
|
|
framework: frameworkBase,
|
|
roleType: 'playable',
|
|
totalCount: generationTargets.playableCount,
|
|
batchSize: CUSTOM_WORLD_FRAMEWORK_PLAYABLE_OUTLINE_BATCH_SIZE,
|
|
reporter,
|
|
signal,
|
|
})) as CustomWorldGenerationFramework['playableNpcs'];
|
|
reporter.complete('playable-outline', {
|
|
phaseDetail: `可扮演角色骨架已完成，共 ${playableNpcs.length} 名。`,
|
|
});
|
|
const frameworkWithPlayable = {
|
|
...frameworkBase,
|
|
playableNpcs,
|
|
} satisfies CustomWorldGenerationFramework;
|
|
|
|
reporter.begin('story-outline', {
|
|
phaseDetail: '正在生成场景角色骨架。',
|
|
});
|
|
const storyNpcs = (await generateCustomWorldRoleOutlineEntries({
|
|
framework: frameworkWithPlayable,
|
|
roleType: 'story',
|
|
totalCount: generationTargets.storyCount,
|
|
batchSize: CUSTOM_WORLD_FRAMEWORK_STORY_OUTLINE_BATCH_SIZE,
|
|
reporter,
|
|
signal,
|
|
})) as CustomWorldGenerationFramework['storyNpcs'];
|
|
reporter.complete('story-outline', {
|
|
phaseDetail: `场景角色骨架已完成，共 ${storyNpcs.length} 名。`,
|
|
});
|
|
const frameworkWithStory = {
|
|
...frameworkWithPlayable,
|
|
storyNpcs,
|
|
} satisfies CustomWorldGenerationFramework;
|
|
|
|
reporter.begin('landmark-seed', {
|
|
phaseDetail: '正在生成场景骨架。',
|
|
});
|
|
const landmarkSeeds = (await generateCustomWorldLandmarkSeedEntries({
|
|
framework: frameworkWithStory,
|
|
totalCount: generationTargets.landmarkCount,
|
|
batchSize: CUSTOM_WORLD_FRAMEWORK_LANDMARK_SEED_BATCH_SIZE,
|
|
reporter,
|
|
signal,
|
|
})) as CustomWorldGenerationFramework['landmarks'];
|
|
reporter.complete('landmark-seed', {
|
|
phaseDetail: `场景已完成，共 ${landmarkSeeds.length} 个地标。`,
|
|
});
|
|
|
|
const framework = {
|
|
...frameworkWithStory,
|
|
landmarks: landmarkSeeds,
|
|
} satisfies CustomWorldGenerationFramework;
|
|
if (generationMode === 'full') {
|
|
validateCustomWorldGenerationFramework(framework);
|
|
}
|
|
reporter.begin('story-graph', {
|
|
phaseDetail: '正在生成世界线程、旧伤与意象母题。',
|
|
});
|
|
const storyGraph = await generateCustomWorldStoryGraphWithAi({
|
|
framework,
|
|
themePack,
|
|
signal,
|
|
});
|
|
reporter.complete('story-graph', {
|
|
phaseDetail: `世界线程图谱已完成，当前可见线程 ${storyGraph.visibleThreads.length} 条，暗线 ${storyGraph.hiddenThreads.length} 条。`,
|
|
});
|
|
|
|
const baseRawProfile = buildCustomWorldRawProfileFromFramework(framework);
|
|
reporter.begin('playable-narrative', {
|
|
phaseDetail: '正在补充可扮演角色的叙事设定。',
|
|
});
|
|
const mergedPlayableNpcs = await expandCustomWorldRoleEntries({
|
|
framework,
|
|
roleType: 'playable',
|
|
baseEntries: baseRawProfile.playableNpcs.map((npc) => ({ ...npc })),
|
|
batchSize: CUSTOM_WORLD_PLAYABLE_BATCH_SIZE,
|
|
reporter,
|
|
signal,
|
|
});
|
|
|
|
reporter.begin('story-narrative', {
|
|
phaseDetail: '正在补充场景角色的叙事设定。',
|
|
});
|
|
const mergedStoryNpcs = await expandCustomWorldRoleEntries({
|
|
framework,
|
|
roleType: 'story',
|
|
baseEntries: baseRawProfile.storyNpcs.map((npc) => ({ ...npc })),
|
|
batchSize: CUSTOM_WORLD_STORY_BATCH_SIZE,
|
|
reporter,
|
|
signal,
|
|
});
|
|
const profileSeed = buildExpandedCustomWorldProfile(
|
|
{
|
|
...baseRawProfile,
|
|
playableNpcs: mergedPlayableNpcs,
|
|
storyNpcs: mergedStoryNpcs,
|
|
themePack,
|
|
storyGraph,
|
|
creatorIntent,
|
|
anchorPack: buildCustomWorldAnchorPackFromIntent(creatorIntent),
|
|
generationMode,
|
|
generationStatus: generationTargets.generationStatus,
|
|
},
|
|
generationSeedText,
|
|
);
|
|
reporter.begin('playable-profile', {
|
|
phaseDetail: '正在补充可扮演角色的叙事档案。',
|
|
});
|
|
const playableNpcsWithNarrativeProfile =
|
|
await expandCustomWorldActorNarrativeProfiles({
|
|
framework,
|
|
roleType: 'playable',
|
|
baseEntries: profileSeed.playableNpcs.map((npc) => ({ ...npc })),
|
|
batchSize: CUSTOM_WORLD_PLAYABLE_BATCH_SIZE,
|
|
themePack,
|
|
storyGraph,
|
|
reporter,
|
|
signal,
|
|
});
|
|
reporter.complete('playable-profile', {
|
|
phaseDetail: `可扮演角色叙事档案已完成，共 ${playableNpcsWithNarrativeProfile.length} 名。`,
|
|
});
|
|
reporter.begin('story-profile', {
|
|
phaseDetail: '正在补充场景角色的叙事档案。',
|
|
});
|
|
const storyNpcsWithNarrativeProfile =
|
|
await expandCustomWorldActorNarrativeProfiles({
|
|
framework,
|
|
roleType: 'story',
|
|
baseEntries: profileSeed.storyNpcs.map((npc) => ({ ...npc })),
|
|
batchSize: CUSTOM_WORLD_STORY_BATCH_SIZE,
|
|
themePack,
|
|
storyGraph,
|
|
reporter,
|
|
signal,
|
|
});
|
|
reporter.complete('story-profile', {
|
|
phaseDetail: `场景角色叙事档案已完成，共 ${storyNpcsWithNarrativeProfile.length} 名。`,
|
|
});
|
|
|
|
reporter.begin('finalize', {
|
|
phaseDetail: '正在归档世界并做完整性校验。',
|
|
});
|
|
throwIfCustomWorldGenerationAborted(signal);
|
|
const profile = buildExpandedCustomWorldProfile(
|
|
{
|
|
...baseRawProfile,
|
|
playableNpcs: playableNpcsWithNarrativeProfile,
|
|
storyNpcs: storyNpcsWithNarrativeProfile,
|
|
themePack,
|
|
storyGraph,
|
|
creatorIntent,
|
|
anchorPack: buildCustomWorldAnchorPackFromIntent(creatorIntent),
|
|
generationMode,
|
|
generationStatus: generationTargets.generationStatus,
|
|
},
|
|
generationSeedText,
|
|
);
|
|
if (generationMode === 'full') {
|
|
validateGeneratedCustomWorldProfile(profile);
|
|
}
|
|
reporter.complete('finalize', {
|
|
phaseDetail: `世界“${profile.name}”已完成归档。`,
|
|
});
|
|
return {
|
|
...profile,
|
|
settingText: normalizedSettingText || profile.settingText,
|
|
creatorIntent,
|
|
anchorPack:
|
|
profile.anchorPack ??
|
|
buildCustomWorldAnchorPackFromIntent(creatorIntent),
|
|
lockState:
|
|
profile.lockState ??
|
|
deriveCustomWorldLockStateFromIntent(creatorIntent),
|
|
generationMode,
|
|
generationStatus: generationTargets.generationStatus,
|
|
items: [],
|
|
};
|
|
} catch (error) {
|
|
if (isCustomWorldGenerationAbortLikeError(error) || signal?.aborted) {
|
|
throw error instanceof Error
|
|
? error
|
|
: new CustomWorldGenerationAbortedError();
|
|
}
|
|
if (error instanceof SyntaxError) {
|
|
throw new Error(
|
|
'自定义世界生成失败：模型返回了非严格 JSON，且自动修复仍未成功，请稍后重试。',
|
|
);
|
|
}
|
|
if (isLlmTimeoutErrorFromClient(error)) {
|
|
throw new Error(
|
|
'自定义世界生成超时：分阶段生成过程中仍有批次未在限定时间内完成返回。已自动延长重试一次；如果仍失败，请稍后重试或提高 VITE_LLM_CUSTOM_WORLD_TIMEOUT_MS。',
|
|
);
|
|
}
|
|
if (isLlmConnectivityErrorFromClient(error)) {
|
|
throw new Error(
|
|
'自定义世界生成无法连接模型服务，请确认本地开发服务器、模型代理和网络连接可用后再试。',
|
|
);
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
export const streamCharacterPanelChatReply =
|
|
streamCharacterPanelChatReplyFromServer;
|
|
|
|
export const generateCharacterPanelChatSuggestions =
|
|
generateCharacterPanelChatSuggestionsFromServer;
|
|
|
|
export const generateCharacterPanelChatSummary =
|
|
generateCharacterPanelChatSummaryFromServer;
|
|
|
|
export const generateInitialStory = generateInitialStoryFromServer;
|
|
|
|
export const generateNextStep = generateNextStepFromServer;
|
|
|
|
export const streamNpcChatDialogue = streamNpcChatDialogueFromServer;
|
|
|
|
export const streamNpcRecruitDialogue = streamNpcRecruitDialogueFromServer;
|