1921 lines
62 KiB
TypeScript
1921 lines
62 KiB
TypeScript
import { AnimatePresence, motion } from 'motion/react';
|
|
import {
|
|
lazy,
|
|
Suspense,
|
|
useCallback,
|
|
useEffect,
|
|
useMemo,
|
|
useRef,
|
|
useState,
|
|
} from 'react';
|
|
|
|
import type {
|
|
CustomWorldAgentActionRequest,
|
|
CustomWorldAgentMessage,
|
|
CustomWorldAgentOperationRecord,
|
|
CustomWorldAgentSessionSnapshot,
|
|
CustomWorldWorkSummary,
|
|
SendCustomWorldAgentMessageRequest,
|
|
} from '../../../packages/shared/src/contracts/customWorldAgent';
|
|
import type {
|
|
CustomWorldGalleryCard,
|
|
CustomWorldLibraryEntry,
|
|
PlatformBrowseHistoryEntry,
|
|
PlatformBrowseHistoryWriteEntry,
|
|
ProfileDashboardSummary,
|
|
ProfileSaveArchiveSummary,
|
|
} from '../../../packages/shared/src/contracts/runtime';
|
|
import { buildCustomWorldPlayableCharacters } from '../../data/characterPresets';
|
|
import type { HydratedSavedGameSnapshot } from '../../persistence/runtimeSnapshotTypes';
|
|
import {
|
|
createCustomWorldAgentSession,
|
|
executeCustomWorldAgentAction,
|
|
getCustomWorldAgentOperation,
|
|
getCustomWorldAgentSession,
|
|
listCustomWorldWorks,
|
|
streamCustomWorldAgentMessage,
|
|
} from '../../services/aiService';
|
|
import { buildCustomWorldProfileFromAgentDraft } from '../../services/customWorldAgentDraftResult';
|
|
import {
|
|
buildAgentDraftFoundationAnchorEntries,
|
|
buildAgentDraftFoundationGenerationProgress,
|
|
buildAgentDraftFoundationSettingText,
|
|
isDraftFoundationOperation,
|
|
isDraftFoundationOperationRunning,
|
|
} from '../../services/customWorldAgentGenerationProgress';
|
|
import {
|
|
readCustomWorldAgentUiState,
|
|
writeCustomWorldAgentUiState,
|
|
} from '../../services/customWorldAgentUiState';
|
|
import { buildCustomWorldCreatorIntentFoundationText } from '../../services/customWorldCreatorIntent';
|
|
import {
|
|
deleteCustomWorldProfile,
|
|
getCustomWorldGalleryDetail,
|
|
getProfileDashboard,
|
|
listCustomWorldGallery,
|
|
listCustomWorldLibrary,
|
|
listProfileBrowseHistory,
|
|
listProfileSaveArchives,
|
|
publishCustomWorldProfile,
|
|
resumeProfileSaveArchive,
|
|
unpublishCustomWorldProfile,
|
|
upsertCustomWorldProfile,
|
|
upsertProfileBrowseHistory,
|
|
} from '../../services/storageService';
|
|
import { type CustomWorldProfile, type GameState } from '../../types';
|
|
import { useAuthUi } from '../auth/AuthUiContext';
|
|
import { CustomWorldCreationHub } from '../custom-world-home/CustomWorldCreationHub';
|
|
import { PlatformCreationTypeModal } from './PlatformCreationTypeModal';
|
|
import { type PlatformHomeTab, PlatformHomeView } from './PlatformHomeView';
|
|
import { PlatformWorldDetailView } from './PlatformWorldDetailView';
|
|
|
|
const CustomWorldGenerationView = lazy(async () => {
|
|
const module = await import('../CustomWorldGenerationView');
|
|
return {
|
|
default: module.CustomWorldGenerationView,
|
|
};
|
|
});
|
|
|
|
const CustomWorldResultView = lazy(async () => {
|
|
const module = await import('../CustomWorldResultView');
|
|
return {
|
|
default: module.CustomWorldResultView,
|
|
};
|
|
});
|
|
|
|
const CustomWorldAgentWorkspace = lazy(async () => {
|
|
const module = await import(
|
|
'../custom-world-agent/CustomWorldAgentWorkspace'
|
|
);
|
|
return {
|
|
default: module.CustomWorldAgentWorkspace,
|
|
};
|
|
});
|
|
|
|
export type SelectionStage =
|
|
| 'platform'
|
|
| 'detail'
|
|
| 'agent-workspace'
|
|
| 'custom-world-generating'
|
|
| 'custom-world-result';
|
|
|
|
type CustomWorldGenerationViewSource = 'agent-draft-foundation' | null;
|
|
|
|
type CustomWorldResultViewSource = 'saved-profile' | 'agent-draft' | null;
|
|
type CustomWorldAutoSaveState = 'idle' | 'saving' | 'saved' | 'error';
|
|
type SyncedAgentDraftResult = {
|
|
session: CustomWorldAgentSessionSnapshot | null;
|
|
profile: CustomWorldProfile | null;
|
|
};
|
|
|
|
type PreGameSelectionFlowProps = {
|
|
selectionStage: SelectionStage;
|
|
setSelectionStage: (stage: SelectionStage) => void;
|
|
gameState: GameState;
|
|
hasSavedGame: boolean;
|
|
savedSnapshot: HydratedSavedGameSnapshot | null;
|
|
handleContinueGame: (snapshot?: HydratedSavedGameSnapshot | null) => void;
|
|
handleStartNewGame: () => void;
|
|
handleCustomWorldSelect: (customWorldProfile: CustomWorldProfile) => void;
|
|
};
|
|
|
|
function resolveErrorMessage(error: unknown, fallback: string) {
|
|
return error instanceof Error ? error.message : fallback;
|
|
}
|
|
|
|
function createFailedAgentOperation(params: {
|
|
type: CustomWorldAgentOperationRecord['type'];
|
|
phaseLabel: string;
|
|
error: string;
|
|
}): CustomWorldAgentOperationRecord {
|
|
return {
|
|
operationId: `local-failed-${Date.now()}`,
|
|
type: params.type,
|
|
status: 'failed',
|
|
phaseLabel: params.phaseLabel,
|
|
phaseDetail: params.error,
|
|
progress: 100,
|
|
error: params.error,
|
|
};
|
|
}
|
|
|
|
function buildOptimisticAgentMessage(
|
|
payload: Pick<CustomWorldAgentMessage, 'id' | 'role' | 'kind' | 'text'>,
|
|
): CustomWorldAgentMessage {
|
|
return {
|
|
...payload,
|
|
createdAt: new Date().toISOString(),
|
|
relatedOperationId: null,
|
|
};
|
|
}
|
|
|
|
function normalizeAgentBackedProfile(profile: CustomWorldProfile) {
|
|
const foundationText = buildCustomWorldCreatorIntentFoundationText(
|
|
profile.creatorIntent,
|
|
).trim();
|
|
|
|
if (!foundationText || foundationText === profile.settingText.trim()) {
|
|
return profile;
|
|
}
|
|
|
|
return {
|
|
...profile,
|
|
settingText: foundationText,
|
|
} satisfies CustomWorldProfile;
|
|
}
|
|
|
|
function stringifyAgentBackedProfile(profile: CustomWorldProfile) {
|
|
return JSON.stringify(normalizeAgentBackedProfile(profile));
|
|
}
|
|
|
|
function LazyPanelFallback({ label }: { label: string }) {
|
|
return (
|
|
<div className="flex h-full min-h-0 items-center justify-center">
|
|
<div className="platform-subpanel rounded-2xl px-5 py-4 text-sm text-[var(--platform-text-base)]">
|
|
{label}
|
|
</div>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function buildCreationHubFallbackItems(
|
|
entries: CustomWorldLibraryEntry<CustomWorldProfile>[],
|
|
): CustomWorldWorkSummary[] {
|
|
return entries
|
|
.filter((entry) => entry.visibility === 'published')
|
|
.map((entry) => ({
|
|
workId: `fallback:${entry.profileId}`,
|
|
sourceType: 'published_profile',
|
|
status: 'published',
|
|
title: entry.worldName,
|
|
subtitle: entry.subtitle || '已发布作品',
|
|
summary: entry.summaryText || '继续补完这个世界的设定与游玩入口。',
|
|
coverImageSrc: entry.coverImageSrc,
|
|
coverRenderMode: 'image',
|
|
coverCharacterImageSrcs: [],
|
|
updatedAt: entry.updatedAt,
|
|
publishedAt: entry.publishedAt,
|
|
stage: null,
|
|
stageLabel: '已发布',
|
|
playableNpcCount: entry.playableNpcCount,
|
|
landmarkCount: entry.landmarkCount,
|
|
roleVisualReadyCount: 0,
|
|
roleAnimationReadyCount: 0,
|
|
roleAssetSummaryLabel: null,
|
|
sessionId: null,
|
|
profileId: entry.profileId,
|
|
canResume: false,
|
|
canEnterWorld: true,
|
|
}));
|
|
}
|
|
|
|
export function PreGameSelectionFlow({
|
|
selectionStage,
|
|
setSelectionStage,
|
|
hasSavedGame,
|
|
savedSnapshot,
|
|
handleContinueGame,
|
|
handleStartNewGame,
|
|
handleCustomWorldSelect,
|
|
}: PreGameSelectionFlowProps) {
|
|
const authUi = useAuthUi();
|
|
const initialAgentUiStateRef = useRef(readCustomWorldAgentUiState());
|
|
const hasAppliedInitialAgentWorkspaceRef = useRef(false);
|
|
const hasRequestedInitialAgentWorkspaceAuthRef = useRef(false);
|
|
const [generatedCustomWorldProfile, setGeneratedCustomWorldProfile] =
|
|
useState<CustomWorldProfile | null>(null);
|
|
const [savedCustomWorldEntries, setSavedCustomWorldEntries] = useState<
|
|
CustomWorldLibraryEntry<CustomWorldProfile>[]
|
|
>([]);
|
|
const [customWorldWorkEntries, setCustomWorldWorkEntries] = useState<
|
|
CustomWorldWorkSummary[]
|
|
>([]);
|
|
const [publishedGalleryEntries, setPublishedGalleryEntries] = useState<
|
|
CustomWorldGalleryCard[]
|
|
>([]);
|
|
const [historyEntries, setHistoryEntries] = useState<
|
|
PlatformBrowseHistoryEntry[]
|
|
>([]);
|
|
const [saveEntries, setSaveEntries] = useState<ProfileSaveArchiveSummary[]>(
|
|
[],
|
|
);
|
|
const [platformTab, setPlatformTab] = useState<PlatformHomeTab>('home');
|
|
const [selectedDetailEntry, setSelectedDetailEntry] =
|
|
useState<CustomWorldLibraryEntry<CustomWorldProfile> | null>(null);
|
|
const [showCreationTypeModal, setShowCreationTypeModal] = useState(false);
|
|
const [creationTypeError, setCreationTypeError] = useState<string | null>(
|
|
null,
|
|
);
|
|
const [isCreatingAgentSession, setIsCreatingAgentSession] = useState(false);
|
|
const [activeAgentSessionId, setActiveAgentSessionId] = useState<
|
|
string | null
|
|
>(() => initialAgentUiStateRef.current.activeSessionId ?? null);
|
|
const [activeAgentOperationId, setActiveAgentOperationId] = useState<
|
|
string | null
|
|
>(() => initialAgentUiStateRef.current.activeOperationId ?? null);
|
|
const [agentSession, setAgentSession] =
|
|
useState<CustomWorldAgentSessionSnapshot | null>(null);
|
|
const [agentOperation, setAgentOperation] =
|
|
useState<CustomWorldAgentOperationRecord | null>(null);
|
|
const [streamingAgentReplyText, setStreamingAgentReplyText] = useState('');
|
|
const [isStreamingAgentReply, setIsStreamingAgentReply] = useState(false);
|
|
const [isLoadingAgentSession, setIsLoadingAgentSession] = useState(false);
|
|
const [customWorldError, setCustomWorldError] = useState<string | null>(null);
|
|
const [platformError, setPlatformError] = useState<string | null>(null);
|
|
const [profileDashboard, setProfileDashboard] =
|
|
useState<ProfileDashboardSummary | null>(null);
|
|
const [dashboardError, setDashboardError] = useState<string | null>(null);
|
|
const [_historyError, setHistoryError] = useState<string | null>(null);
|
|
const [saveError, setSaveError] = useState<string | null>(null);
|
|
const [detailError, setDetailError] = useState<string | null>(null);
|
|
const [isLoadingPlatform, setIsLoadingPlatform] = useState(false);
|
|
const [isLoadingDashboard, setIsLoadingDashboard] = useState(false);
|
|
const [isResumingSaveWorldKey, setIsResumingSaveWorldKey] = useState<
|
|
string | null
|
|
>(null);
|
|
const [isDetailLoading, setIsDetailLoading] = useState(false);
|
|
const [isMutatingDetail, setIsMutatingDetail] = useState(false);
|
|
const [customWorldAutoSaveState, setCustomWorldAutoSaveState] =
|
|
useState<CustomWorldAutoSaveState>('idle');
|
|
const [customWorldAutoSaveError, setCustomWorldAutoSaveError] = useState<
|
|
string | null
|
|
>(null);
|
|
const [customWorldGenerationViewSource, setCustomWorldGenerationViewSource] =
|
|
useState<CustomWorldGenerationViewSource>(null);
|
|
const [customWorldResultViewSource, setCustomWorldResultViewSource] =
|
|
useState<CustomWorldResultViewSource>(null);
|
|
const [agentDraftGenerationStartedAt, setAgentDraftGenerationStartedAt] =
|
|
useState<number | null>(null);
|
|
const customWorldAutoSaveTimeoutRef = useRef<number | null>(null);
|
|
const lastAutoSavedProfileSignatureRef = useRef<string | null>(null);
|
|
const latestAutoSaveRequestIdRef = useRef(0);
|
|
const latestAgentResultSyncSignatureRef = useRef<string | null>(null);
|
|
// 用户手动返回工作区后，先抑制自动重开结果页，避免刚退出又被 session 快照顶回去。
|
|
const isAgentDraftResultAutoOpenSuppressedRef = useRef(false);
|
|
const isCustomWorldAutoSaveBusyRef = useRef(false);
|
|
const platformTabBootstrapUserIdRef = useRef<string | null | undefined>(
|
|
undefined,
|
|
);
|
|
|
|
const previewCustomWorldCharacters = useMemo(
|
|
() =>
|
|
generatedCustomWorldProfile
|
|
? buildCustomWorldPlayableCharacters(generatedCustomWorldProfile)
|
|
: [],
|
|
[generatedCustomWorldProfile],
|
|
);
|
|
|
|
const featuredGalleryEntries = useMemo(
|
|
() => publishedGalleryEntries.slice(0, 6),
|
|
[publishedGalleryEntries],
|
|
);
|
|
const isAuthenticated = Boolean(authUi?.user);
|
|
|
|
const runProtectedAction = useCallback(
|
|
(action: () => void) => {
|
|
if (!authUi?.requireAuth) {
|
|
action();
|
|
return;
|
|
}
|
|
|
|
authUi.requireAuth(action);
|
|
},
|
|
[authUi],
|
|
);
|
|
|
|
const persistAgentUiState = useCallback(
|
|
(nextSessionId: string | null, nextOperationId: string | null) => {
|
|
setActiveAgentSessionId(nextSessionId);
|
|
setActiveAgentOperationId(nextOperationId);
|
|
writeCustomWorldAgentUiState({
|
|
activeSessionId: nextSessionId,
|
|
activeOperationId: nextOperationId,
|
|
});
|
|
},
|
|
[],
|
|
);
|
|
|
|
const syncAgentSessionSnapshot = useCallback(async (sessionId: string) => {
|
|
const nextSession = await getCustomWorldAgentSession(sessionId);
|
|
setAgentSession(nextSession);
|
|
return nextSession;
|
|
}, []);
|
|
|
|
const refreshProfileDashboard = useCallback(async () => {
|
|
if (!authUi?.user) {
|
|
setProfileDashboard(null);
|
|
setDashboardError(null);
|
|
setIsLoadingDashboard(false);
|
|
return;
|
|
}
|
|
|
|
setIsLoadingDashboard(true);
|
|
setDashboardError(null);
|
|
|
|
try {
|
|
setProfileDashboard(await getProfileDashboard());
|
|
} catch (error) {
|
|
setDashboardError(resolveErrorMessage(error, '读取个人数据看板失败。'));
|
|
} finally {
|
|
setIsLoadingDashboard(false);
|
|
}
|
|
}, [authUi?.user]);
|
|
|
|
const refreshCustomWorldWorks = useCallback(async () => {
|
|
if (!authUi?.user) {
|
|
setCustomWorldWorkEntries([]);
|
|
return [];
|
|
}
|
|
|
|
const nextItems = await listCustomWorldWorks();
|
|
setCustomWorldWorkEntries(nextItems);
|
|
return nextItems;
|
|
}, [authUi?.user]);
|
|
|
|
const appendBrowseHistoryEntry = useCallback(
|
|
async (entry: PlatformBrowseHistoryWriteEntry) => {
|
|
setHistoryError(null);
|
|
|
|
try {
|
|
const syncedEntries = await upsertProfileBrowseHistory(entry);
|
|
setHistoryEntries(syncedEntries);
|
|
} catch (error) {
|
|
setHistoryError(resolveErrorMessage(error, '写入浏览历史失败。'));
|
|
}
|
|
},
|
|
[authUi?.user],
|
|
);
|
|
|
|
useEffect(() => {
|
|
const initialAgentSessionId = initialAgentUiStateRef.current.activeSessionId;
|
|
|
|
if (!initialAgentSessionId || hasAppliedInitialAgentWorkspaceRef.current) {
|
|
return;
|
|
}
|
|
|
|
setPlatformTab('create');
|
|
|
|
// URL 或 sessionStorage 中残留的共创工作区属于受保护入口，
|
|
// 未登录时只允许先唤起登录弹窗，不能直接恢复会话请求。
|
|
if (!authUi?.user) {
|
|
if (!hasRequestedInitialAgentWorkspaceAuthRef.current) {
|
|
hasRequestedInitialAgentWorkspaceAuthRef.current = true;
|
|
authUi?.openLoginModal?.(() => {
|
|
setSelectionStage('agent-workspace');
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
|
|
hasAppliedInitialAgentWorkspaceRef.current = true;
|
|
setSelectionStage('agent-workspace');
|
|
}, [authUi?.openLoginModal, authUi?.user, setSelectionStage]);
|
|
|
|
useEffect(() => {
|
|
if (!selectedDetailEntry) {
|
|
return;
|
|
}
|
|
|
|
const nextOwnedEntry = savedCustomWorldEntries.find(
|
|
(entry) =>
|
|
entry.ownerUserId === selectedDetailEntry.ownerUserId &&
|
|
entry.profileId === selectedDetailEntry.profileId,
|
|
);
|
|
if (nextOwnedEntry && nextOwnedEntry !== selectedDetailEntry) {
|
|
setSelectedDetailEntry(nextOwnedEntry);
|
|
}
|
|
}, [savedCustomWorldEntries, selectedDetailEntry]);
|
|
|
|
useEffect(() => {
|
|
let isActive = true;
|
|
|
|
void (async () => {
|
|
setHistoryEntries([]);
|
|
setHistoryError(null);
|
|
setSaveError(null);
|
|
setIsLoadingPlatform(true);
|
|
setPlatformError(null);
|
|
setIsLoadingDashboard(isAuthenticated);
|
|
setDashboardError(null);
|
|
if (!isAuthenticated) {
|
|
setSavedCustomWorldEntries([]);
|
|
setCustomWorldWorkEntries([]);
|
|
setSaveEntries([]);
|
|
setProfileDashboard(null);
|
|
}
|
|
|
|
try {
|
|
const [
|
|
libraryEntriesResult,
|
|
workEntriesResult,
|
|
galleryEntriesResult,
|
|
dashboardResult,
|
|
historyResult,
|
|
saveArchivesResult,
|
|
] = await Promise.allSettled([
|
|
isAuthenticated ? listCustomWorldLibrary() : Promise.resolve([]),
|
|
isAuthenticated ? listCustomWorldWorks() : Promise.resolve([]),
|
|
listCustomWorldGallery(),
|
|
isAuthenticated ? getProfileDashboard() : Promise.resolve(null),
|
|
isAuthenticated ? listProfileBrowseHistory() : Promise.resolve([]),
|
|
isAuthenticated ? listProfileSaveArchives() : Promise.resolve([]),
|
|
]);
|
|
if (!isActive) {
|
|
return;
|
|
}
|
|
|
|
if (libraryEntriesResult.status === 'fulfilled') {
|
|
setSavedCustomWorldEntries(libraryEntriesResult.value);
|
|
} else {
|
|
setSavedCustomWorldEntries([]);
|
|
}
|
|
|
|
if (workEntriesResult.status === 'fulfilled') {
|
|
setCustomWorldWorkEntries(workEntriesResult.value);
|
|
} else {
|
|
setCustomWorldWorkEntries([]);
|
|
}
|
|
|
|
if (galleryEntriesResult.status === 'fulfilled') {
|
|
setPublishedGalleryEntries(galleryEntriesResult.value);
|
|
} else {
|
|
setPublishedGalleryEntries([]);
|
|
}
|
|
|
|
if (
|
|
(isAuthenticated && libraryEntriesResult.status === 'rejected') ||
|
|
(isAuthenticated && workEntriesResult.status === 'rejected') ||
|
|
galleryEntriesResult.status === 'rejected'
|
|
) {
|
|
const platformFailure =
|
|
libraryEntriesResult.status === 'rejected'
|
|
? libraryEntriesResult.reason
|
|
: workEntriesResult.status === 'rejected'
|
|
? workEntriesResult.reason
|
|
: galleryEntriesResult.status === 'rejected'
|
|
? galleryEntriesResult.reason
|
|
: null;
|
|
setPlatformError(
|
|
resolveErrorMessage(platformFailure, '读取平台数据失败。'),
|
|
);
|
|
}
|
|
|
|
if (dashboardResult.status === 'fulfilled') {
|
|
setProfileDashboard(dashboardResult.value);
|
|
} else if (isAuthenticated) {
|
|
setProfileDashboard(null);
|
|
setDashboardError(
|
|
resolveErrorMessage(
|
|
dashboardResult.reason,
|
|
'读取个人数据看板失败。',
|
|
),
|
|
);
|
|
}
|
|
|
|
if (historyResult.status === 'fulfilled') {
|
|
setHistoryEntries(historyResult.value);
|
|
} else if (isAuthenticated) {
|
|
setHistoryError(
|
|
resolveErrorMessage(historyResult.reason, '读取浏览历史失败。'),
|
|
);
|
|
}
|
|
|
|
if (saveArchivesResult.status === 'fulfilled') {
|
|
setSaveEntries(saveArchivesResult.value);
|
|
} else if (isAuthenticated) {
|
|
setSaveEntries([]);
|
|
setSaveError(
|
|
resolveErrorMessage(
|
|
saveArchivesResult.reason,
|
|
'读取存档列表失败。',
|
|
),
|
|
);
|
|
}
|
|
|
|
const nextPlatformBootstrapUserId = authUi?.user?.id ?? null;
|
|
if (
|
|
platformTabBootstrapUserIdRef.current !== nextPlatformBootstrapUserId
|
|
) {
|
|
platformTabBootstrapUserIdRef.current = nextPlatformBootstrapUserId;
|
|
if (!initialAgentUiStateRef.current.activeSessionId) {
|
|
setPlatformTab(
|
|
isAuthenticated &&
|
|
saveArchivesResult.status === 'fulfilled' &&
|
|
saveArchivesResult.value.length > 0
|
|
? 'saves'
|
|
: 'home',
|
|
);
|
|
}
|
|
}
|
|
} finally {
|
|
if (isActive) {
|
|
setIsLoadingPlatform(false);
|
|
setIsLoadingDashboard(false);
|
|
}
|
|
}
|
|
})();
|
|
|
|
return () => {
|
|
isActive = false;
|
|
};
|
|
}, [authUi?.user, isAuthenticated]);
|
|
|
|
useEffect(() => {
|
|
if (
|
|
selectionStage === 'custom-world-result' &&
|
|
!generatedCustomWorldProfile
|
|
) {
|
|
setSelectionStage(selectedDetailEntry ? 'detail' : 'platform');
|
|
}
|
|
}, [
|
|
generatedCustomWorldProfile,
|
|
selectedDetailEntry,
|
|
selectionStage,
|
|
setSelectionStage,
|
|
]);
|
|
|
|
useEffect(
|
|
() => () => {
|
|
if (customWorldAutoSaveTimeoutRef.current !== null) {
|
|
window.clearTimeout(customWorldAutoSaveTimeoutRef.current);
|
|
}
|
|
},
|
|
[],
|
|
);
|
|
|
|
useEffect(() => {
|
|
if (!activeAgentSessionId) {
|
|
setAgentSession(null);
|
|
setAgentOperation(null);
|
|
setIsLoadingAgentSession(false);
|
|
setStreamingAgentReplyText('');
|
|
setIsStreamingAgentReply(false);
|
|
return;
|
|
}
|
|
|
|
if (!authUi?.user) {
|
|
setAgentSession(null);
|
|
setAgentOperation(null);
|
|
setIsLoadingAgentSession(false);
|
|
setStreamingAgentReplyText('');
|
|
setIsStreamingAgentReply(false);
|
|
return;
|
|
}
|
|
|
|
let cancelled = false;
|
|
setIsLoadingAgentSession(true);
|
|
|
|
void syncAgentSessionSnapshot(activeAgentSessionId)
|
|
.then(() => {
|
|
if (!cancelled) {
|
|
setCreationTypeError(null);
|
|
}
|
|
})
|
|
.catch((error) => {
|
|
if (cancelled) {
|
|
return;
|
|
}
|
|
|
|
setCreationTypeError(
|
|
resolveErrorMessage(error, '读取 Agent 共创工作区失败。'),
|
|
);
|
|
setAgentSession(null);
|
|
setAgentOperation(null);
|
|
setStreamingAgentReplyText('');
|
|
setIsStreamingAgentReply(false);
|
|
persistAgentUiState(null, null);
|
|
setPlatformTab('create');
|
|
setSelectionStage('platform');
|
|
})
|
|
.finally(() => {
|
|
if (!cancelled) {
|
|
setIsLoadingAgentSession(false);
|
|
}
|
|
});
|
|
|
|
return () => {
|
|
cancelled = true;
|
|
};
|
|
}, [
|
|
activeAgentSessionId,
|
|
authUi?.user,
|
|
persistAgentUiState,
|
|
setSelectionStage,
|
|
syncAgentSessionSnapshot,
|
|
]);
|
|
|
|
useEffect(() => {
|
|
if (!activeAgentSessionId || !activeAgentOperationId || !authUi?.user) {
|
|
return;
|
|
}
|
|
|
|
let cancelled = false;
|
|
|
|
const pollOperation = async () => {
|
|
try {
|
|
const nextOperation = await getCustomWorldAgentOperation(
|
|
activeAgentSessionId,
|
|
activeAgentOperationId,
|
|
);
|
|
|
|
if (cancelled) {
|
|
return;
|
|
}
|
|
|
|
setAgentOperation(nextOperation);
|
|
|
|
if (
|
|
nextOperation.status === 'completed' ||
|
|
nextOperation.status === 'failed'
|
|
) {
|
|
persistAgentUiState(activeAgentSessionId, null);
|
|
await syncAgentSessionSnapshot(activeAgentSessionId).catch(
|
|
() => null,
|
|
);
|
|
}
|
|
} catch (error) {
|
|
if (cancelled) {
|
|
return;
|
|
}
|
|
|
|
const errorMessage = resolveErrorMessage(
|
|
error,
|
|
'读取共创操作状态失败。',
|
|
);
|
|
setAgentOperation(
|
|
createFailedAgentOperation({
|
|
type: 'process_message',
|
|
phaseLabel: '读取操作状态失败',
|
|
error: errorMessage,
|
|
}),
|
|
);
|
|
persistAgentUiState(activeAgentSessionId, null);
|
|
}
|
|
};
|
|
|
|
void pollOperation();
|
|
const intervalId = window.setInterval(() => {
|
|
void pollOperation();
|
|
}, 1200);
|
|
|
|
return () => {
|
|
cancelled = true;
|
|
window.clearInterval(intervalId);
|
|
};
|
|
}, [
|
|
activeAgentOperationId,
|
|
activeAgentSessionId,
|
|
authUi?.user,
|
|
persistAgentUiState,
|
|
syncAgentSessionSnapshot,
|
|
]);
|
|
|
|
useEffect(() => {
|
|
if (
|
|
!isDraftFoundationOperationRunning(agentOperation) ||
|
|
agentDraftGenerationStartedAt
|
|
) {
|
|
return;
|
|
}
|
|
|
|
setAgentDraftGenerationStartedAt(Date.now());
|
|
}, [agentDraftGenerationStartedAt, agentOperation]);
|
|
|
|
useEffect(() => {
|
|
if (
|
|
selectionStage !== 'custom-world-generating' ||
|
|
customWorldGenerationViewSource !== 'agent-draft-foundation' ||
|
|
!isDraftFoundationOperation(agentOperation) ||
|
|
agentOperation.status !== 'completed'
|
|
) {
|
|
return;
|
|
}
|
|
|
|
let cancelled = false;
|
|
const timeoutId = window.setTimeout(() => {
|
|
void (async () => {
|
|
const latestSession = activeAgentSessionId
|
|
? await syncAgentSessionSnapshot(activeAgentSessionId).catch(
|
|
() => null,
|
|
)
|
|
: agentSession;
|
|
|
|
if (cancelled) {
|
|
return;
|
|
}
|
|
|
|
const draftResultProfile = buildCustomWorldProfileFromAgentDraft(
|
|
latestSession ?? agentSession,
|
|
);
|
|
if (!draftResultProfile) {
|
|
setAgentDraftGenerationStartedAt(null);
|
|
setCustomWorldGenerationViewSource(null);
|
|
setSelectionStage('agent-workspace');
|
|
return;
|
|
}
|
|
|
|
setGeneratedCustomWorldProfile(
|
|
normalizeAgentBackedProfile(draftResultProfile),
|
|
);
|
|
setAgentDraftGenerationStartedAt(null);
|
|
setCustomWorldGenerationViewSource(null);
|
|
setCustomWorldResultViewSource('agent-draft');
|
|
setSelectionStage('custom-world-result');
|
|
})();
|
|
}, 900);
|
|
|
|
return () => {
|
|
cancelled = true;
|
|
window.clearTimeout(timeoutId);
|
|
};
|
|
}, [
|
|
activeAgentSessionId,
|
|
agentOperation,
|
|
customWorldGenerationViewSource,
|
|
agentSession,
|
|
selectionStage,
|
|
setSelectionStage,
|
|
syncAgentSessionSnapshot,
|
|
]);
|
|
|
|
const agentDraftSettingPreview = useMemo(
|
|
() => buildAgentDraftFoundationSettingText(agentSession),
|
|
[agentSession],
|
|
);
|
|
const agentDraftAnchorPreviewEntries = useMemo(
|
|
() => buildAgentDraftFoundationAnchorEntries(agentSession),
|
|
[agentSession],
|
|
);
|
|
const agentDraftResultProfile = useMemo(
|
|
() => buildCustomWorldProfileFromAgentDraft(agentSession),
|
|
[agentSession],
|
|
);
|
|
const shouldAutoOpenAgentDraftResult = useMemo(
|
|
() =>
|
|
Boolean(
|
|
agentDraftResultProfile &&
|
|
agentSession &&
|
|
(agentSession.stage === 'object_refining' ||
|
|
agentSession.stage === 'visual_refining' ||
|
|
agentSession.stage === 'long_tail_review' ||
|
|
agentSession.stage === 'ready_to_publish' ||
|
|
agentSession.stage === 'published') &&
|
|
agentSession.draftCards.length > 0,
|
|
),
|
|
[agentDraftResultProfile, agentSession],
|
|
);
|
|
|
|
useEffect(() => {
|
|
if (!shouldAutoOpenAgentDraftResult || !agentDraftResultProfile) {
|
|
return;
|
|
}
|
|
|
|
if (isAgentDraftResultAutoOpenSuppressedRef.current) {
|
|
return;
|
|
}
|
|
|
|
if (selectionStage === 'agent-workspace') {
|
|
setGeneratedCustomWorldProfile(agentDraftResultProfile);
|
|
setCustomWorldResultViewSource('agent-draft');
|
|
isAgentDraftResultAutoOpenSuppressedRef.current = false;
|
|
setSelectionStage('custom-world-result');
|
|
return;
|
|
}
|
|
|
|
if (
|
|
selectionStage === 'custom-world-result' &&
|
|
!generatedCustomWorldProfile
|
|
) {
|
|
setGeneratedCustomWorldProfile(agentDraftResultProfile);
|
|
setCustomWorldResultViewSource('agent-draft');
|
|
isAgentDraftResultAutoOpenSuppressedRef.current = false;
|
|
}
|
|
}, [
|
|
agentDraftResultProfile,
|
|
generatedCustomWorldProfile,
|
|
isAgentDraftResultAutoOpenSuppressedRef,
|
|
selectionStage,
|
|
setSelectionStage,
|
|
shouldAutoOpenAgentDraftResult,
|
|
]);
|
|
|
|
const agentDraftGenerationProgress = useMemo(
|
|
() =>
|
|
buildAgentDraftFoundationGenerationProgress(
|
|
agentOperation,
|
|
agentDraftGenerationStartedAt,
|
|
),
|
|
[agentDraftGenerationStartedAt, agentOperation],
|
|
);
|
|
|
|
const isAgentDraftGenerationView =
|
|
customWorldGenerationViewSource === 'agent-draft-foundation';
|
|
const isAgentDraftResultView = customWorldResultViewSource === 'agent-draft';
|
|
const activeGenerationSettingText = agentDraftSettingPreview;
|
|
const activeGenerationProgress = agentDraftGenerationProgress;
|
|
const isActiveGenerationRunning =
|
|
isDraftFoundationOperationRunning(agentOperation);
|
|
const activeGenerationError =
|
|
isDraftFoundationOperation(agentOperation) &&
|
|
agentOperation.status === 'failed'
|
|
? agentOperation.error || agentOperation.phaseDetail
|
|
: null;
|
|
|
|
const leaveCustomWorldResult = () => {
|
|
setGeneratedCustomWorldProfile(null);
|
|
setCustomWorldError(null);
|
|
setCustomWorldAutoSaveError(null);
|
|
setCustomWorldAutoSaveState('idle');
|
|
setCustomWorldGenerationViewSource(null);
|
|
setCustomWorldResultViewSource(null);
|
|
setSelectionStage(
|
|
isAgentDraftResultView
|
|
? 'agent-workspace'
|
|
: selectedDetailEntry
|
|
? 'detail'
|
|
: 'platform',
|
|
);
|
|
};
|
|
|
|
const openCreationTypePicker = () => {
|
|
if (isCreatingAgentSession) {
|
|
return;
|
|
}
|
|
|
|
if (!hasSavedGame) {
|
|
handleStartNewGame();
|
|
}
|
|
|
|
setCreationTypeError(null);
|
|
setShowCreationTypeModal(true);
|
|
};
|
|
|
|
const openRpgAgentWorkspace = async (seedText = '') => {
|
|
if (isCreatingAgentSession) {
|
|
return;
|
|
}
|
|
|
|
setIsCreatingAgentSession(true);
|
|
setCreationTypeError(null);
|
|
isAgentDraftResultAutoOpenSuppressedRef.current = false;
|
|
|
|
try {
|
|
const { session } = await createCustomWorldAgentSession(
|
|
seedText ? { seedText } : {},
|
|
);
|
|
setAgentSession(session);
|
|
setAgentOperation(null);
|
|
setGeneratedCustomWorldProfile(null);
|
|
setCustomWorldAutoSaveError(null);
|
|
setCustomWorldAutoSaveState('idle');
|
|
setAgentDraftGenerationStartedAt(null);
|
|
setCustomWorldGenerationViewSource(null);
|
|
setCustomWorldResultViewSource(null);
|
|
persistAgentUiState(session.sessionId, null);
|
|
setShowCreationTypeModal(false);
|
|
setPlatformTab('create');
|
|
setSelectionStage('agent-workspace');
|
|
} catch (error) {
|
|
setCreationTypeError(resolveErrorMessage(error, '开启共创工作台失败。'));
|
|
} finally {
|
|
setIsCreatingAgentSession(false);
|
|
}
|
|
};
|
|
|
|
const submitAgentMessage = async (
|
|
payload: SendCustomWorldAgentMessageRequest,
|
|
) => {
|
|
if (!activeAgentSessionId) {
|
|
return;
|
|
}
|
|
|
|
const optimisticUserMessage = buildOptimisticAgentMessage({
|
|
id: payload.clientMessageId,
|
|
role: 'user',
|
|
kind: 'chat',
|
|
text: payload.text.trim(),
|
|
});
|
|
|
|
setAgentOperation(null);
|
|
persistAgentUiState(activeAgentSessionId, null);
|
|
setStreamingAgentReplyText('');
|
|
setIsStreamingAgentReply(true);
|
|
setAgentSession((current) =>
|
|
current
|
|
? {
|
|
...current,
|
|
messages: [...current.messages, optimisticUserMessage],
|
|
updatedAt: optimisticUserMessage.createdAt,
|
|
}
|
|
: current,
|
|
);
|
|
|
|
try {
|
|
const nextSession = await streamCustomWorldAgentMessage(
|
|
activeAgentSessionId,
|
|
payload,
|
|
{
|
|
onUpdate: (text) => {
|
|
setStreamingAgentReplyText(text);
|
|
},
|
|
},
|
|
);
|
|
setAgentSession(nextSession);
|
|
setAgentOperation(null);
|
|
setStreamingAgentReplyText('');
|
|
} catch (error) {
|
|
const errorMessage = resolveErrorMessage(error, '发送共创消息失败。');
|
|
setAgentSession((current) =>
|
|
current
|
|
? {
|
|
...current,
|
|
messages: [
|
|
...current.messages,
|
|
buildOptimisticAgentMessage({
|
|
id: `message-error-${Date.now()}`,
|
|
role: 'assistant',
|
|
kind: 'warning',
|
|
text: errorMessage,
|
|
}),
|
|
],
|
|
updatedAt: new Date().toISOString(),
|
|
}
|
|
: current,
|
|
);
|
|
setStreamingAgentReplyText('');
|
|
persistAgentUiState(activeAgentSessionId, null);
|
|
} finally {
|
|
setIsStreamingAgentReply(false);
|
|
}
|
|
};
|
|
|
|
const executeAgentAction = async (payload: CustomWorldAgentActionRequest) => {
|
|
if (!activeAgentSessionId) {
|
|
return;
|
|
}
|
|
|
|
const isDraftFoundationAction = payload.action === 'draft_foundation';
|
|
|
|
if (isDraftFoundationAction) {
|
|
isAgentDraftResultAutoOpenSuppressedRef.current = false;
|
|
setGeneratedCustomWorldProfile(null);
|
|
setCustomWorldError(null);
|
|
setCustomWorldAutoSaveError(null);
|
|
setCustomWorldAutoSaveState('idle');
|
|
setCustomWorldGenerationViewSource('agent-draft-foundation');
|
|
setCustomWorldResultViewSource(null);
|
|
setAgentDraftGenerationStartedAt(Date.now());
|
|
setSelectionStage('custom-world-generating');
|
|
}
|
|
|
|
try {
|
|
const { operation } = await executeCustomWorldAgentAction(
|
|
activeAgentSessionId,
|
|
payload,
|
|
);
|
|
setAgentOperation(operation);
|
|
persistAgentUiState(activeAgentSessionId, operation.operationId);
|
|
} catch (error) {
|
|
const errorMessage = resolveErrorMessage(error, '执行共创操作失败。');
|
|
setAgentOperation(
|
|
createFailedAgentOperation({
|
|
type:
|
|
payload.action === 'draft_foundation'
|
|
? 'draft_foundation'
|
|
: payload.action,
|
|
phaseLabel: '执行操作失败',
|
|
error: errorMessage,
|
|
}),
|
|
);
|
|
persistAgentUiState(activeAgentSessionId, null);
|
|
}
|
|
};
|
|
|
|
const leaveAgentWorkspace = () => {
|
|
setPlatformTab('create');
|
|
setAgentOperation(null);
|
|
setStreamingAgentReplyText('');
|
|
setIsStreamingAgentReply(false);
|
|
setGeneratedCustomWorldProfile(null);
|
|
setCustomWorldAutoSaveError(null);
|
|
setCustomWorldAutoSaveState('idle');
|
|
setAgentDraftGenerationStartedAt(null);
|
|
setCustomWorldGenerationViewSource(null);
|
|
setCustomWorldResultViewSource(null);
|
|
persistAgentUiState(activeAgentSessionId, null);
|
|
setSelectionStage('platform');
|
|
};
|
|
|
|
const leaveAgentDraftGeneration = () => {
|
|
if (isDraftFoundationOperationRunning(agentOperation)) {
|
|
return;
|
|
}
|
|
|
|
setAgentDraftGenerationStartedAt(null);
|
|
setCustomWorldGenerationViewSource(null);
|
|
setSelectionStage('agent-workspace');
|
|
};
|
|
|
|
const leaveAgentDraftResult = () => {
|
|
isAgentDraftResultAutoOpenSuppressedRef.current = true;
|
|
setGeneratedCustomWorldProfile(null);
|
|
setCustomWorldError(null);
|
|
setCustomWorldAutoSaveError(null);
|
|
setCustomWorldAutoSaveState('idle');
|
|
setCustomWorldGenerationViewSource(null);
|
|
setCustomWorldResultViewSource(null);
|
|
setPlatformTab('create');
|
|
setSelectionStage('platform');
|
|
};
|
|
|
|
const retryAgentDraftGeneration = () => {
|
|
void executeAgentAction({
|
|
action: 'draft_foundation',
|
|
});
|
|
};
|
|
|
|
const openCustomWorldCreator = () => {
|
|
openCreationTypePicker();
|
|
};
|
|
|
|
const openLibraryDetail = useCallback(
|
|
(entry: CustomWorldLibraryEntry<CustomWorldProfile>) => {
|
|
if (entry.visibility === 'published') {
|
|
void appendBrowseHistoryEntry({
|
|
ownerUserId: entry.ownerUserId,
|
|
profileId: entry.profileId,
|
|
worldName: entry.worldName,
|
|
subtitle: entry.subtitle,
|
|
summaryText: entry.summaryText,
|
|
coverImageSrc: entry.coverImageSrc,
|
|
themeMode: entry.themeMode,
|
|
authorDisplayName: entry.authorDisplayName,
|
|
});
|
|
}
|
|
setSelectedDetailEntry(entry);
|
|
setDetailError(null);
|
|
setSelectionStage('detail');
|
|
},
|
|
[appendBrowseHistoryEntry, setSelectionStage],
|
|
);
|
|
|
|
const handleOpenCreationWork = useCallback(
|
|
async (work: CustomWorldWorkSummary) => {
|
|
if (work.status === 'draft' && work.sessionId) {
|
|
persistAgentUiState(work.sessionId, null);
|
|
setCustomWorldError(null);
|
|
setCustomWorldAutoSaveError(null);
|
|
setCustomWorldAutoSaveState('idle');
|
|
setCustomWorldGenerationViewSource(null);
|
|
|
|
const shouldOpenAgentWorkspace =
|
|
work.playableNpcCount <= 0 && work.landmarkCount <= 0;
|
|
|
|
if (shouldOpenAgentWorkspace) {
|
|
// 仅八锚点未整理成底稿时才恢复 Agent 对话工作区。
|
|
isAgentDraftResultAutoOpenSuppressedRef.current = true;
|
|
setGeneratedCustomWorldProfile(null);
|
|
setCustomWorldResultViewSource(null);
|
|
setPlatformTab('create');
|
|
setSelectionStage('agent-workspace');
|
|
return;
|
|
}
|
|
|
|
isAgentDraftResultAutoOpenSuppressedRef.current = false;
|
|
const latestSession = await syncAgentSessionSnapshot(work.sessionId);
|
|
const nextProfile = buildCustomWorldProfileFromAgentDraft(latestSession);
|
|
if (!nextProfile) {
|
|
setPlatformError('当前草稿还没有可编辑的结果页数据，请先继续补齐锚点。');
|
|
setPlatformTab('create');
|
|
setSelectionStage('agent-workspace');
|
|
return;
|
|
}
|
|
|
|
setGeneratedCustomWorldProfile(normalizeAgentBackedProfile(nextProfile));
|
|
setCustomWorldResultViewSource('agent-draft');
|
|
setPlatformTab('create');
|
|
setSelectionStage('custom-world-result');
|
|
return;
|
|
}
|
|
|
|
if (!work.profileId) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
let matchedEntry = savedCustomWorldEntries.find(
|
|
(entry) => entry.profileId === work.profileId,
|
|
);
|
|
|
|
if (!matchedEntry && authUi?.user) {
|
|
const latestLibraryEntries = await listCustomWorldLibrary();
|
|
setSavedCustomWorldEntries(latestLibraryEntries);
|
|
matchedEntry = latestLibraryEntries.find(
|
|
(entry) => entry.profileId === work.profileId,
|
|
);
|
|
}
|
|
|
|
if (matchedEntry) {
|
|
openLibraryDetail(matchedEntry);
|
|
return;
|
|
}
|
|
|
|
setPlatformError('未找到对应作品，请刷新后重试。');
|
|
} catch (error) {
|
|
setPlatformError(resolveErrorMessage(error, '读取作品详情失败。'));
|
|
}
|
|
},
|
|
[
|
|
authUi?.user,
|
|
openLibraryDetail,
|
|
persistAgentUiState,
|
|
savedCustomWorldEntries,
|
|
syncAgentSessionSnapshot,
|
|
setSelectionStage,
|
|
],
|
|
);
|
|
|
|
const openGalleryDetail = async (entry: CustomWorldGalleryCard) => {
|
|
setSelectionStage('detail');
|
|
setIsDetailLoading(true);
|
|
setDetailError(null);
|
|
try {
|
|
const detailEntry = await getCustomWorldGalleryDetail(
|
|
entry.ownerUserId,
|
|
entry.profileId,
|
|
);
|
|
setSelectedDetailEntry(detailEntry);
|
|
void appendBrowseHistoryEntry({
|
|
ownerUserId: detailEntry.ownerUserId,
|
|
profileId: detailEntry.profileId,
|
|
worldName: detailEntry.worldName,
|
|
subtitle: detailEntry.subtitle,
|
|
summaryText: detailEntry.summaryText,
|
|
coverImageSrc: detailEntry.coverImageSrc,
|
|
themeMode: detailEntry.themeMode,
|
|
authorDisplayName: detailEntry.authorDisplayName,
|
|
});
|
|
} catch (error) {
|
|
setSelectedDetailEntry(null);
|
|
setDetailError(resolveErrorMessage(error, '读取作品详情失败。'));
|
|
} finally {
|
|
setIsDetailLoading(false);
|
|
}
|
|
};
|
|
|
|
const handleResumeSaveEntry = useCallback(
|
|
async (entry: ProfileSaveArchiveSummary) => {
|
|
if (!authUi?.user || isResumingSaveWorldKey) {
|
|
return;
|
|
}
|
|
|
|
setIsResumingSaveWorldKey(entry.worldKey);
|
|
setSaveError(null);
|
|
|
|
try {
|
|
const resumedArchive = await resumeProfileSaveArchive(entry.worldKey);
|
|
setSaveEntries((currentEntries) =>
|
|
currentEntries.map((currentEntry) =>
|
|
currentEntry.worldKey === resumedArchive.entry.worldKey
|
|
? resumedArchive.entry
|
|
: currentEntry,
|
|
),
|
|
);
|
|
handleContinueGame(resumedArchive.snapshot);
|
|
} catch (error) {
|
|
setSaveError(resolveErrorMessage(error, '恢复存档失败。'));
|
|
} finally {
|
|
setIsResumingSaveWorldKey(null);
|
|
}
|
|
},
|
|
[authUi?.user, handleContinueGame, isResumingSaveWorldKey],
|
|
);
|
|
|
|
const saveGeneratedCustomWorld = useCallback(
|
|
async (profile = generatedCustomWorldProfile) => {
|
|
if (!profile) {
|
|
return null;
|
|
}
|
|
|
|
const normalizedProfile = normalizeAgentBackedProfile(profile);
|
|
const profileSignature = stringifyAgentBackedProfile(normalizedProfile);
|
|
const requestId = latestAutoSaveRequestIdRef.current + 1;
|
|
latestAutoSaveRequestIdRef.current = requestId;
|
|
setCustomWorldAutoSaveState('saving');
|
|
setCustomWorldAutoSaveError(null);
|
|
|
|
try {
|
|
const mutation = await upsertCustomWorldProfile(normalizedProfile);
|
|
if (latestAutoSaveRequestIdRef.current !== requestId) {
|
|
return mutation;
|
|
}
|
|
|
|
lastAutoSavedProfileSignatureRef.current = profileSignature;
|
|
setSavedCustomWorldEntries(mutation.entries);
|
|
if (authUi?.user) {
|
|
void refreshCustomWorldWorks().catch(() => {});
|
|
}
|
|
setSelectedDetailEntry((current) => {
|
|
if (!current || current.profileId === mutation.entry.profileId) {
|
|
return mutation.entry;
|
|
}
|
|
|
|
return current;
|
|
});
|
|
setCustomWorldAutoSaveState('saved');
|
|
setCustomWorldAutoSaveError(null);
|
|
return mutation;
|
|
} catch (error) {
|
|
if (latestAutoSaveRequestIdRef.current !== requestId) {
|
|
return null;
|
|
}
|
|
|
|
setCustomWorldAutoSaveState('error');
|
|
setCustomWorldAutoSaveError(
|
|
resolveErrorMessage(error, '保存自定义世界失败。'),
|
|
);
|
|
return null;
|
|
}
|
|
},
|
|
[authUi?.user, generatedCustomWorldProfile, refreshCustomWorldWorks],
|
|
);
|
|
|
|
const syncAgentDraftResultProfile = useCallback(
|
|
async (profile: CustomWorldProfile) => {
|
|
if (!activeAgentSessionId) {
|
|
return {
|
|
session: null,
|
|
profile: null,
|
|
} satisfies SyncedAgentDraftResult;
|
|
}
|
|
|
|
const normalizedProfile = normalizeAgentBackedProfile(profile);
|
|
const profileSignature = stringifyAgentBackedProfile(normalizedProfile);
|
|
const latestSessionProfileSignature =
|
|
agentSession && buildCustomWorldProfileFromAgentDraft(agentSession)
|
|
? stringifyAgentBackedProfile(
|
|
buildCustomWorldProfileFromAgentDraft(agentSession)!,
|
|
)
|
|
: '';
|
|
if (latestSessionProfileSignature === profileSignature) {
|
|
latestAgentResultSyncSignatureRef.current = profileSignature;
|
|
return {
|
|
session: agentSession,
|
|
profile: normalizeAgentBackedProfile(
|
|
buildCustomWorldProfileFromAgentDraft(agentSession) ?? profile,
|
|
),
|
|
} satisfies SyncedAgentDraftResult;
|
|
}
|
|
if (latestAgentResultSyncSignatureRef.current === profileSignature) {
|
|
return {
|
|
session: agentSession,
|
|
profile: normalizeAgentBackedProfile(
|
|
buildCustomWorldProfileFromAgentDraft(agentSession) ?? profile,
|
|
),
|
|
} satisfies SyncedAgentDraftResult;
|
|
}
|
|
|
|
const { operation } = await executeCustomWorldAgentAction(
|
|
activeAgentSessionId,
|
|
{
|
|
action: 'sync_result_profile',
|
|
profile: normalizedProfile as unknown as Record<string, unknown>,
|
|
},
|
|
);
|
|
setAgentOperation(operation);
|
|
persistAgentUiState(activeAgentSessionId, operation.operationId);
|
|
|
|
for (let attempt = 0; attempt < 60; attempt += 1) {
|
|
const latestOperation = await getCustomWorldAgentOperation(
|
|
activeAgentSessionId,
|
|
operation.operationId,
|
|
);
|
|
setAgentOperation(latestOperation);
|
|
|
|
if (latestOperation.status === 'failed') {
|
|
throw new Error(
|
|
latestOperation.error ||
|
|
latestOperation.phaseDetail ||
|
|
'同步结果页世界快照失败。',
|
|
);
|
|
}
|
|
|
|
if (latestOperation.status === 'completed') {
|
|
persistAgentUiState(activeAgentSessionId, null);
|
|
const latestSession = await syncAgentSessionSnapshot(
|
|
activeAgentSessionId,
|
|
);
|
|
// 同步完成后统一从最新 session 重编译结果，保证结果页、作品库和进入世界吃同一份快照。
|
|
const latestProfile = normalizeAgentBackedProfile(
|
|
buildCustomWorldProfileFromAgentDraft(latestSession) ?? profile,
|
|
);
|
|
if (latestProfile) {
|
|
setGeneratedCustomWorldProfile(latestProfile);
|
|
}
|
|
latestAgentResultSyncSignatureRef.current = profileSignature;
|
|
return {
|
|
session: latestSession,
|
|
profile: latestProfile,
|
|
} satisfies SyncedAgentDraftResult;
|
|
}
|
|
|
|
await new Promise((resolve) => window.setTimeout(resolve, 200));
|
|
}
|
|
|
|
throw new Error('同步结果页世界快照超时。');
|
|
},
|
|
[
|
|
activeAgentSessionId,
|
|
agentSession,
|
|
persistAgentUiState,
|
|
syncAgentSessionSnapshot,
|
|
],
|
|
);
|
|
|
|
useEffect(() => {
|
|
if (!generatedCustomWorldProfile) {
|
|
setCustomWorldAutoSaveState('idle');
|
|
setCustomWorldAutoSaveError(null);
|
|
lastAutoSavedProfileSignatureRef.current = null;
|
|
latestAgentResultSyncSignatureRef.current = null;
|
|
if (customWorldAutoSaveTimeoutRef.current !== null) {
|
|
window.clearTimeout(customWorldAutoSaveTimeoutRef.current);
|
|
customWorldAutoSaveTimeoutRef.current = null;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (selectionStage !== 'custom-world-result') {
|
|
return;
|
|
}
|
|
|
|
if (isCustomWorldAutoSaveBusyRef.current) {
|
|
return;
|
|
}
|
|
|
|
const nextSignature = stringifyAgentBackedProfile(generatedCustomWorldProfile);
|
|
if (nextSignature === lastAutoSavedProfileSignatureRef.current) {
|
|
return;
|
|
}
|
|
|
|
setCustomWorldAutoSaveState('saving');
|
|
if (customWorldAutoSaveTimeoutRef.current !== null) {
|
|
window.clearTimeout(customWorldAutoSaveTimeoutRef.current);
|
|
}
|
|
|
|
const profileToSave = generatedCustomWorldProfile;
|
|
customWorldAutoSaveTimeoutRef.current = window.setTimeout(() => {
|
|
void (async () => {
|
|
isCustomWorldAutoSaveBusyRef.current = true;
|
|
try {
|
|
let latestProfileToSave = normalizeAgentBackedProfile(profileToSave);
|
|
if (isAgentDraftResultView) {
|
|
const syncedResult =
|
|
await syncAgentDraftResultProfile(profileToSave);
|
|
// 作品库自动保存优先落同步后 session 重编译出的结果，避免继续保存旧的前端内存态。
|
|
latestProfileToSave = normalizeAgentBackedProfile(
|
|
syncedResult.profile ?? profileToSave,
|
|
);
|
|
}
|
|
await saveGeneratedCustomWorld(latestProfileToSave);
|
|
} catch (error) {
|
|
setCustomWorldAutoSaveState('error');
|
|
setCustomWorldAutoSaveError(
|
|
resolveErrorMessage(error, '保存自定义世界失败。'),
|
|
);
|
|
} finally {
|
|
isCustomWorldAutoSaveBusyRef.current = false;
|
|
}
|
|
})();
|
|
customWorldAutoSaveTimeoutRef.current = null;
|
|
}, 600);
|
|
|
|
return () => {
|
|
if (customWorldAutoSaveTimeoutRef.current !== null) {
|
|
window.clearTimeout(customWorldAutoSaveTimeoutRef.current);
|
|
customWorldAutoSaveTimeoutRef.current = null;
|
|
}
|
|
};
|
|
}, [
|
|
generatedCustomWorldProfile,
|
|
isAgentDraftResultView,
|
|
saveGeneratedCustomWorld,
|
|
selectionStage,
|
|
syncAgentDraftResultProfile,
|
|
]);
|
|
|
|
const openSavedCustomWorldEditor = (
|
|
entry: CustomWorldLibraryEntry<CustomWorldProfile>,
|
|
) => {
|
|
setSelectedDetailEntry(entry);
|
|
const normalizedProfile = normalizeAgentBackedProfile(entry.profile);
|
|
setGeneratedCustomWorldProfile(normalizedProfile);
|
|
lastAutoSavedProfileSignatureRef.current =
|
|
JSON.stringify(normalizedProfile);
|
|
setCustomWorldAutoSaveState('saved');
|
|
setCustomWorldAutoSaveError(null);
|
|
setCustomWorldError(null);
|
|
setCustomWorldGenerationViewSource(null);
|
|
setCustomWorldResultViewSource('saved-profile');
|
|
setSelectionStage('custom-world-result');
|
|
};
|
|
|
|
const handleStartSelectedWorld = () => {
|
|
if (!selectedDetailEntry) {
|
|
return;
|
|
}
|
|
|
|
runProtectedAction(() => {
|
|
handleCustomWorldSelect(selectedDetailEntry.profile);
|
|
});
|
|
};
|
|
|
|
const handlePublishSelectedWorld = async () => {
|
|
if (!selectedDetailEntry || isMutatingDetail) {
|
|
return;
|
|
}
|
|
|
|
setIsMutatingDetail(true);
|
|
setDetailError(null);
|
|
try {
|
|
const mutation = await publishCustomWorldProfile(
|
|
selectedDetailEntry.profileId,
|
|
);
|
|
setSavedCustomWorldEntries(mutation.entries);
|
|
await refreshCustomWorldWorks().catch(() => []);
|
|
setSelectedDetailEntry(mutation.entry);
|
|
setPublishedGalleryEntries(await listCustomWorldGallery());
|
|
} catch (error) {
|
|
setDetailError(resolveErrorMessage(error, '发布自定义世界失败。'));
|
|
} finally {
|
|
setIsMutatingDetail(false);
|
|
}
|
|
};
|
|
|
|
const handleUnpublishSelectedWorld = async () => {
|
|
if (!selectedDetailEntry || isMutatingDetail) {
|
|
return;
|
|
}
|
|
|
|
setIsMutatingDetail(true);
|
|
setDetailError(null);
|
|
try {
|
|
const mutation = await unpublishCustomWorldProfile(
|
|
selectedDetailEntry.profileId,
|
|
);
|
|
setSavedCustomWorldEntries(mutation.entries);
|
|
await refreshCustomWorldWorks().catch(() => []);
|
|
setSelectedDetailEntry(mutation.entry);
|
|
setPublishedGalleryEntries(await listCustomWorldGallery());
|
|
} catch (error) {
|
|
setDetailError(resolveErrorMessage(error, '下架自定义世界失败。'));
|
|
} finally {
|
|
setIsMutatingDetail(false);
|
|
}
|
|
};
|
|
|
|
const handleDeleteSelectedWorld = async () => {
|
|
if (!selectedDetailEntry || isMutatingDetail) {
|
|
return;
|
|
}
|
|
|
|
const confirmed = window.confirm(
|
|
`确认删除作品《${selectedDetailEntry.worldName}》吗？删除后会从你的作品列表和公开广场中移除。`,
|
|
);
|
|
if (!confirmed) {
|
|
return;
|
|
}
|
|
|
|
setIsMutatingDetail(true);
|
|
setDetailError(null);
|
|
try {
|
|
const entries = await deleteCustomWorldProfile(
|
|
selectedDetailEntry.profileId,
|
|
);
|
|
setSavedCustomWorldEntries(entries);
|
|
await refreshCustomWorldWorks().catch(() => []);
|
|
setSelectedDetailEntry(null);
|
|
setPlatformTab('create');
|
|
setSelectionStage('platform');
|
|
setPublishedGalleryEntries(await listCustomWorldGallery());
|
|
} catch (error) {
|
|
setDetailError(resolveErrorMessage(error, '删除自定义世界失败。'));
|
|
} finally {
|
|
setIsMutatingDetail(false);
|
|
}
|
|
};
|
|
|
|
const isSelectedWorldOwned = Boolean(
|
|
selectedDetailEntry &&
|
|
savedCustomWorldEntries.some(
|
|
(entry) =>
|
|
entry.ownerUserId === selectedDetailEntry.ownerUserId &&
|
|
entry.profileId === selectedDetailEntry.profileId,
|
|
),
|
|
);
|
|
const resultViewError = customWorldAutoSaveError ?? customWorldError;
|
|
const creationHubItems =
|
|
customWorldWorkEntries.length > 0
|
|
? customWorldWorkEntries
|
|
: buildCreationHubFallbackItems(savedCustomWorldEntries);
|
|
const creationHubContent = (
|
|
<CustomWorldCreationHub
|
|
items={creationHubItems}
|
|
loading={isLoadingPlatform}
|
|
error={isLoadingPlatform ? null : (platformError ?? creationTypeError)}
|
|
onBack={() => {
|
|
setPlatformTab('home');
|
|
}}
|
|
onRetry={() => {
|
|
setPlatformError(null);
|
|
void refreshCustomWorldWorks().catch((error) => {
|
|
setPlatformError(
|
|
resolveErrorMessage(error, '读取创作作品列表失败。'),
|
|
);
|
|
});
|
|
}}
|
|
onCreateNew={openCreationTypePicker}
|
|
onOpenDraft={(item) => {
|
|
runProtectedAction(() => {
|
|
void handleOpenCreationWork(item);
|
|
});
|
|
}}
|
|
onEnterPublished={(profileId) => {
|
|
runProtectedAction(() => {
|
|
const matchedWork = creationHubItems.find(
|
|
(entry) => entry.profileId === profileId,
|
|
);
|
|
if (!matchedWork) {
|
|
return;
|
|
}
|
|
void handleOpenCreationWork(matchedWork);
|
|
});
|
|
}}
|
|
/>
|
|
);
|
|
|
|
return (
|
|
<>
|
|
<AnimatePresence mode="wait">
|
|
{selectionStage === 'platform' && (
|
|
<motion.div
|
|
key="platform-home"
|
|
initial={{ opacity: 0, y: 12 }}
|
|
animate={{ opacity: 1, y: 0 }}
|
|
exit={{ opacity: 0, y: -12 }}
|
|
className="flex h-full min-h-0 flex-col"
|
|
>
|
|
<PlatformHomeView
|
|
activeTab={platformTab}
|
|
onTabChange={setPlatformTab}
|
|
hasSavedGame={hasSavedGame}
|
|
savedSnapshot={savedSnapshot}
|
|
saveEntries={saveEntries}
|
|
saveError={saveError}
|
|
featuredEntries={featuredGalleryEntries}
|
|
latestEntries={publishedGalleryEntries}
|
|
myEntries={savedCustomWorldEntries}
|
|
historyEntries={historyEntries}
|
|
profileDashboard={profileDashboard}
|
|
isLoadingPlatform={isLoadingPlatform}
|
|
isLoadingDashboard={isLoadingDashboard}
|
|
isResumingSaveWorldKey={isResumingSaveWorldKey}
|
|
platformError={
|
|
isLoadingPlatform ? null : (platformError ?? creationTypeError)
|
|
}
|
|
dashboardError={isLoadingDashboard ? null : dashboardError}
|
|
createTabContent={creationHubContent}
|
|
onContinueGame={handleContinueGame}
|
|
onResumeSave={(entry) => {
|
|
void handleResumeSaveEntry(entry);
|
|
}}
|
|
onOpenCreateWorld={openCustomWorldCreator}
|
|
onOpenCreateTypePicker={openCreationTypePicker}
|
|
onOpenGalleryDetail={(entry) => {
|
|
runProtectedAction(() => {
|
|
void openGalleryDetail(entry);
|
|
});
|
|
}}
|
|
onOpenLibraryDetail={(entry) => {
|
|
runProtectedAction(() => {
|
|
openLibraryDetail(entry);
|
|
});
|
|
}}
|
|
onOpenProfileDashboardCard={() => {
|
|
if (dashboardError) {
|
|
void refreshProfileDashboard();
|
|
}
|
|
}}
|
|
/>
|
|
</motion.div>
|
|
)}
|
|
|
|
{selectionStage === 'detail' && (
|
|
<motion.div
|
|
key="platform-detail"
|
|
initial={{ opacity: 0, y: 12 }}
|
|
animate={{ opacity: 1, y: 0 }}
|
|
exit={{ opacity: 0, y: -12 }}
|
|
className="flex h-full min-h-0 flex-col"
|
|
>
|
|
{isDetailLoading || !selectedDetailEntry ? (
|
|
<div className="flex h-full items-center justify-center">
|
|
<div className="platform-subpanel rounded-2xl px-5 py-4 text-sm text-[var(--platform-text-base)]">
|
|
{detailError || '正在读取作品详情...'}
|
|
</div>
|
|
</div>
|
|
) : (
|
|
<PlatformWorldDetailView
|
|
entry={selectedDetailEntry}
|
|
isMutating={isMutatingDetail}
|
|
error={detailError}
|
|
onBack={() => {
|
|
setDetailError(null);
|
|
setSelectionStage('platform');
|
|
}}
|
|
onStartGame={handleStartSelectedWorld}
|
|
onContinueEdit={
|
|
isSelectedWorldOwned
|
|
? () => {
|
|
runProtectedAction(() => {
|
|
openSavedCustomWorldEditor(selectedDetailEntry);
|
|
});
|
|
}
|
|
: null
|
|
}
|
|
onPublish={
|
|
selectedDetailEntry.visibility === 'draft' &&
|
|
isSelectedWorldOwned
|
|
? () => {
|
|
runProtectedAction(() => {
|
|
void handlePublishSelectedWorld();
|
|
});
|
|
}
|
|
: null
|
|
}
|
|
onUnpublish={
|
|
selectedDetailEntry.visibility === 'published' &&
|
|
isSelectedWorldOwned
|
|
? () => {
|
|
runProtectedAction(() => {
|
|
void handleUnpublishSelectedWorld();
|
|
});
|
|
}
|
|
: null
|
|
}
|
|
onDelete={
|
|
isSelectedWorldOwned
|
|
? () => {
|
|
runProtectedAction(() => {
|
|
void handleDeleteSelectedWorld();
|
|
});
|
|
}
|
|
: null
|
|
}
|
|
/>
|
|
)}
|
|
</motion.div>
|
|
)}
|
|
|
|
{selectionStage === 'agent-workspace' && (
|
|
<motion.div
|
|
key="agent-workspace"
|
|
initial={{ opacity: 0, y: 12 }}
|
|
animate={{ opacity: 1, y: 0 }}
|
|
exit={{ opacity: 0, y: -12 }}
|
|
className="flex h-full min-h-0 flex-col"
|
|
>
|
|
<Suspense
|
|
fallback={
|
|
<LazyPanelFallback label="正在加载 Agent 共创工作区..." />
|
|
}
|
|
>
|
|
{agentSession ? (
|
|
<CustomWorldAgentWorkspace
|
|
session={agentSession}
|
|
activeOperation={agentOperation}
|
|
streamingReplyText={streamingAgentReplyText}
|
|
isStreamingReply={isStreamingAgentReply}
|
|
onBack={leaveAgentWorkspace}
|
|
onSubmitMessage={(payload) => {
|
|
void submitAgentMessage(payload);
|
|
}}
|
|
onExecuteAction={(payload) => {
|
|
void executeAgentAction(payload);
|
|
}}
|
|
/>
|
|
) : (
|
|
<div className="flex h-full items-center justify-center">
|
|
<div className="platform-subpanel rounded-2xl px-5 py-4 text-sm text-[var(--platform-text-base)]">
|
|
{isLoadingAgentSession
|
|
? '正在准备 Agent 共创工作区...'
|
|
: creationTypeError || '正在恢复创作工作区...'}
|
|
</div>
|
|
</div>
|
|
)}
|
|
</Suspense>
|
|
</motion.div>
|
|
)}
|
|
|
|
{selectionStage === 'custom-world-generating' && (
|
|
<motion.div
|
|
key="custom-world-generating"
|
|
initial={{ opacity: 0, y: 12 }}
|
|
animate={{ opacity: 1, y: 0 }}
|
|
exit={{ opacity: 0, y: -12 }}
|
|
className="flex h-full min-h-0 flex-col"
|
|
>
|
|
<Suspense
|
|
fallback={<LazyPanelFallback label="正在加载世界生成面板..." />}
|
|
>
|
|
<CustomWorldGenerationView
|
|
settingText={activeGenerationSettingText}
|
|
anchorEntries={agentDraftAnchorPreviewEntries}
|
|
progress={activeGenerationProgress}
|
|
isGenerating={isActiveGenerationRunning}
|
|
error={activeGenerationError}
|
|
onBack={leaveAgentDraftGeneration}
|
|
onEditSetting={leaveAgentDraftGeneration}
|
|
onRetry={retryAgentDraftGeneration}
|
|
onInterrupt={undefined}
|
|
backLabel="返回工作区"
|
|
settingActionLabel={null}
|
|
retryLabel="重新生成草稿"
|
|
settingTitle="当前世界信息"
|
|
settingDescription={null}
|
|
progressTitle={
|
|
isAgentDraftGenerationView ? '世界草稿生成进度' : undefined
|
|
}
|
|
activeBadgeLabel={
|
|
isAgentDraftGenerationView ? '草稿编译中' : undefined
|
|
}
|
|
pausedBadgeLabel={
|
|
isAgentDraftGenerationView ? '草稿生成已暂停' : undefined
|
|
}
|
|
idleBadgeLabel={
|
|
isAgentDraftGenerationView ? '等待返回工作区' : undefined
|
|
}
|
|
/>
|
|
</Suspense>
|
|
</motion.div>
|
|
)}
|
|
|
|
{selectionStage === 'custom-world-result' &&
|
|
generatedCustomWorldProfile && (
|
|
<motion.div
|
|
key="custom-world-result"
|
|
initial={{ opacity: 0, y: 12 }}
|
|
animate={{ opacity: 1, y: 0 }}
|
|
exit={{ opacity: 0, y: -12 }}
|
|
className="flex h-full min-h-0 flex-col"
|
|
>
|
|
<Suspense
|
|
fallback={<LazyPanelFallback label="正在加载世界编辑器..." />}
|
|
>
|
|
<CustomWorldResultView
|
|
profile={generatedCustomWorldProfile}
|
|
previewCharacters={previewCustomWorldCharacters}
|
|
isGenerating={false}
|
|
progress={0}
|
|
progressLabel=""
|
|
error={resultViewError}
|
|
onProfileChange={(profile) => {
|
|
setGeneratedCustomWorldProfile(
|
|
normalizeAgentBackedProfile(profile),
|
|
);
|
|
}}
|
|
onBack={
|
|
isAgentDraftResultView
|
|
? () => {
|
|
void (async () => {
|
|
const currentProfile =
|
|
generatedCustomWorldProfile ??
|
|
buildCustomWorldProfileFromAgentDraft(
|
|
agentSession,
|
|
);
|
|
|
|
if (currentProfile && activeAgentSessionId) {
|
|
await syncAgentDraftResultProfile(currentProfile);
|
|
}
|
|
|
|
leaveAgentDraftResult();
|
|
})().catch((error) => {
|
|
setCustomWorldError(
|
|
resolveErrorMessage(
|
|
error,
|
|
'返回创作前同步草稿失败。',
|
|
),
|
|
);
|
|
});
|
|
}
|
|
: leaveCustomWorldResult
|
|
}
|
|
onEditSetting={undefined}
|
|
onRegenerate={undefined}
|
|
onContinueExpand={undefined}
|
|
onEnterWorld={() => {
|
|
runProtectedAction(() => {
|
|
void (async () => {
|
|
if (!isAgentDraftResultView || !activeAgentSessionId) {
|
|
handleCustomWorldSelect(generatedCustomWorldProfile);
|
|
return;
|
|
}
|
|
|
|
const currentProfile =
|
|
generatedCustomWorldProfile ??
|
|
buildCustomWorldProfileFromAgentDraft(agentSession);
|
|
if (!currentProfile) {
|
|
return;
|
|
}
|
|
|
|
const latestResult = await syncAgentDraftResultProfile(
|
|
currentProfile,
|
|
);
|
|
const latestProfile = normalizeAgentBackedProfile(
|
|
buildCustomWorldProfileFromAgentDraft(
|
|
latestResult.session ?? agentSession,
|
|
) ??
|
|
latestResult.profile ??
|
|
currentProfile,
|
|
);
|
|
setGeneratedCustomWorldProfile(latestProfile);
|
|
handleCustomWorldSelect(latestProfile);
|
|
})().catch((error) => {
|
|
setCustomWorldError(
|
|
resolveErrorMessage(error, '进入世界前同步草稿失败。'),
|
|
);
|
|
});
|
|
});
|
|
}}
|
|
readOnly={false}
|
|
compactAgentResultMode={isAgentDraftResultView}
|
|
backLabel={isAgentDraftResultView ? '返回创作' : undefined}
|
|
editActionLabel="继续调整设定"
|
|
enterWorldActionLabel="进入世界"
|
|
autoSaveState={customWorldAutoSaveState}
|
|
/>
|
|
</Suspense>
|
|
</motion.div>
|
|
)}
|
|
</AnimatePresence>
|
|
|
|
<PlatformCreationTypeModal
|
|
isOpen={showCreationTypeModal}
|
|
isBusy={isCreatingAgentSession}
|
|
error={creationTypeError}
|
|
onClose={() => {
|
|
if (isCreatingAgentSession) {
|
|
return;
|
|
}
|
|
setShowCreationTypeModal(false);
|
|
}}
|
|
onSelectRpg={() => {
|
|
runProtectedAction(() => {
|
|
void openRpgAgentWorkspace();
|
|
});
|
|
}}
|
|
/>
|
|
</>
|
|
);
|
|
}
|