briyah 1.0.0

package/dist/server/src/story/story.service.js

@@ -0,0 +1,1797 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoryService = void 0;
+const common_1 = require("@nestjs/common");
+const story_store_service_1 = require("./story-store.service");
+const story_progress_service_1 = require("./story-progress.service");
+const story_message_service_1 = require("./story-message.service");
+const agent_store_service_1 = require("../ai/agent-store.service");
+const agent_factory_1 = require("../ai/agent-factory");
+const room_factory_1 = require("../room/room-factory");
+const room_store_service_1 = require("../room/room-store.service");
+const app_types_1 = require("@shared/types/app.types");
+const configuration_service_1 = require("../config/configuration.service");
+const artifact_service_1 = require("../ai/artifact.service");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const archiver_1 = __importDefault(require("archiver"));
+const yauzl = __importStar(require("yauzl"));
+const message_1 = require("../room/message");
+const errors_1 = require("../common/errors");
+let StoryService = class StoryService {
+    storyStore;
+    agentStore;
+    roomStore;
+    progressService;
+    messageService;
+    configService;
+    agentFactory;
+    roomFactory;
+    storyArtifactServices = new Map();
+    constructor(storyStore, agentStore, roomStore, progressService, messageService, configService, agentFactory, roomFactory) {
+        this.storyStore = storyStore;
+        this.agentStore = agentStore;
+        this.roomStore = roomStore;
+        this.progressService = progressService;
+        this.messageService = messageService;
+        this.configService = configService;
+        this.agentFactory = agentFactory;
+        this.roomFactory = roomFactory;
+    }
+    getProgressEmitter(storyId) {
+        return this.progressService.getProgressEmitter(storyId);
+    }
+    getMessageEmitter(storyId) {
+        return this.messageService.getOrCreateEmitter(storyId);
+    }
+    cleanupProgressEmitter(storyId) {
+        this.progressService.cleanup(storyId);
+    }
+    cleanupMessageEmitter(storyId) {
+        this.messageService.cleanup(storyId);
+    }
+    getStoryArtifactService(storyId) {
+        let artifactService = this.storyArtifactServices.get(storyId);
+        if (!artifactService) {
+            const { artifactsDir } = this.getStoryStorageDirs(storyId);
+            artifactService = new artifact_service_1.ArtifactService(this.configService, artifactsDir);
+            this.storyArtifactServices.set(storyId, artifactService);
+        }
+        return artifactService;
+    }
+    async emitStoryStateUpdate(storyId) {
+        try {
+            let story = await this.ensureStoryLoaded(storyId);
+            if (!story) {
+                console.error(`Story ${storyId} not found for state update`);
+                return;
+            }
+            const room = await this.roomStore.getRoom(story.roomId);
+            if (!room) {
+                console.error(`Room ${story.roomId} not found for story ${storyId}`);
+                return;
+            }
+            await this.updateStoryCost(storyId);
+            story = await this.getStoryInfo(storyId);
+            const humanAgent = room.getAgents().find((agent) => agent.isControlledByHuman);
+            if (!humanAgent) {
+                console.error(`No human agent found for story ${storyId}`);
+                return;
+            }
+            const roomMessages = room.getLatestRoomMessages(0, true);
+            const latestMessage = roomMessages[roomMessages.length - 1];
+            const currentSpeaker = room.getCurrentSpeaker();
+            const humanPrompt = this.getHumanPrompt(room);
+            const stateUpdate = {
+                storyId: story.id,
+                latestRoomMessage: latestMessage,
+                userAgentName: humanAgent.agentNickname,
+                humanPrompt: humanPrompt,
+                currentSpeaker: currentSpeaker,
+                totalCost: story.totalCost || 0,
+                totalInputTokens: story.totalInputTokens || 0,
+                totalOutputTokens: story.totalOutputTokens || 0,
+            };
+            this.messageService.emitUpdate(storyId, {
+                type: 'state',
+                state: stateUpdate
+            });
+        }
+        catch (error) {
+            console.error(`Error emitting story state update for ${storyId}:`, error);
+        }
+    }
+    getHumanPrompt(room) {
+        const humanAgent = room.getAgents().find((a) => a.isControlledByHuman);
+        if (!humanAgent) {
+            return '';
+        }
+        if (room.getCurrentSpeaker() === humanAgent.agentNickname) {
+            return `What does ${humanAgent.agentNickname} do or say next?`;
+        }
+        else if (room.getCurrentSpeaker() !== null) {
+            return `Waiting for ${room.getCurrentSpeaker()}...`;
+        }
+        else if (room.isProcessingInProgress()) {
+            return 'Processing...';
+        }
+        else {
+            return '';
+        }
+    }
+    handleRoomError(storyId, error) {
+        console.log(`Room error for story ${storyId}: ${error.name} - ${error.message}`);
+        this.messageService.emitError(storyId, error);
+    }
+    getRandomWord() {
+        const randomWordsPath = path.join(this.configService.getCommonConfigDir(), 'random_words.txt');
+        const content = fs.readFileSync(randomWordsPath, 'utf-8');
+        const words = content.split('\n').filter((word) => word.trim().length > 0);
+        const randomIndex = Math.floor(Math.random() * words.length);
+        return words[randomIndex];
+    }
+    getStoryStorageDirs(storyId) {
+        const userStoriesDir = path.join(this.configService.getUserDataDir(), 'stories');
+        return {
+            agentsDir: path.join(userStoriesDir, storyId, 'agents'),
+            roomsDir: path.join(userStoriesDir, storyId, 'rooms'),
+            artifactsDir: path.join(userStoriesDir, storyId, 'artifacts'),
+        };
+    }
+    getStoryModelConfig(storyModel) {
+        const storyModelsPath = path.join(this.configService.getCommonConfigDir(), 'story_models.json');
+        try {
+            const storyModels = JSON.parse(fs.readFileSync(storyModelsPath, 'utf8'));
+            const modelConfig = storyModels.find((m) => m.name === storyModel);
+            if (modelConfig) {
+                return {
+                    service: modelConfig.service,
+                    model: modelConfig.model,
+                };
+            }
+            console.warn(`Story model "${storyModel}" not found in story_models.json`);
+            return null;
+        }
+        catch (error) {
+            console.error(`Error reading story_models.json:`, error);
+            return null;
+        }
+    }
+    async getStoryRoom(storyId) {
+        const story = await this.ensureStoryLoaded(storyId);
+        if (!story) {
+            throw new Error('Story not found');
+        }
+        const room = await this.roomStore.getRoom(story.roomId);
+        if (!room) {
+            throw new Error('Story room not found');
+        }
+        return room;
+    }
+    async ensureStoryLoaded(storyId) {
+        const story = this.storyStore.getStory(storyId);
+        if (!story)
+            return null;
+        if (!story.roomId) {
+            console.error(`Story ${storyId} has no roomId. Deleting story from storage...`);
+            this.storyStore.removeStory(storyId);
+            return null;
+        }
+        let room = await this.roomStore.getRoom(story.roomId);
+        if (room) {
+            return story;
+        }
+        const { agentsDir, roomsDir } = this.getStoryStorageDirs(storyId);
+        const storyArtifactService = this.getStoryArtifactService(storyId);
+        await this.agentStore.loadAgentsFromDirectory(agentsDir, storyArtifactService);
+        await this.roomStore.loadRoomsFromDirectory(roomsDir);
+        room = await this.roomStore.getRoom(story.roomId);
+        if (room) {
+            room.setOnStateChange(() => {
+                this.emitStoryStateUpdate(storyId);
+            });
+            room.setOnError((error) => {
+                this.handleRoomError(storyId, error);
+            });
+            room.setOnSituationUpdate((situation) => {
+                this.updateStorySituation(storyId, situation);
+            });
+            if (story.situation) {
+                room.setSituation(story.situation);
+            }
+        }
+        return story;
+    }
+    async getStoryInfo(storyId) {
+        return this.storyStore.getStory(storyId);
+    }
+    async createStory(name, idea, userCharacterDesc, otherCharactersDesc, storyModel, isImport = false, imageModelName) {
+        if (!name || name.trim().length === 0) {
+            throw new Error('Story name is required');
+        }
+        const storyInfo = this.storyStore.createStory(name);
+        storyInfo.turnNumber = 0;
+        try {
+            this.progressService.createProgressEmitter(storyInfo.id);
+            this.progressService.emitProgress(storyInfo.id, 'start', 'Starting story creation...');
+            const { agentsDir: storyAgentsDir, roomsDir: storyRoomsDir } = this.getStoryStorageDirs(storyInfo.id);
+            const storyArtifactService = this.getStoryArtifactService(storyInfo.id);
+            let aiServiceName;
+            let aiModelName;
+            if (!storyModel || storyModel.trim().length === 0)
+                storyModel = process.env.DEFAULT_STORY_MODEL;
+            const modelConfig = this.getStoryModelConfig(storyModel);
+            if (modelConfig) {
+                aiServiceName = modelConfig.service;
+                aiModelName = modelConfig.model;
+            }
+            if (!aiServiceName || !aiModelName)
+                throw new Error(`Failed to find model config for "${storyModel}"`);
+            let moderator = this.agentFactory.createAgent(process.env.MODERATOR_AI_SERVICE || aiServiceName, 'Moderator', '', 'Story moderator responsible for message routing and conversation flow', 'story_moderator', process.env.MODERATOR_AI_MODEL || aiModelName, storyAgentsDir, storyArtifactService);
+            moderator.maxHistoryMessages = 16;
+            moderator.reasoningEffort = 'low';
+            moderator.promptCacheTTL = 60;
+            moderator.ownerRoomId = storyInfo.id;
+            moderator.markupRate = 0;
+            moderator.save();
+            console.log(`Created moderator agent: ${moderator.agentName}`);
+            const artist = this.createArtistAgent(storyInfo.id, storyAgentsDir, storyArtifactService, imageModelName);
+            let illustrator = null;
+            if (artist) {
+                illustrator = this.agentFactory.createAgent(process.env.MODERATOR_AI_SERVICE || aiServiceName, 'Illustrator', '', 'Visual artist for generating scene illustrations', 'illustrator', process.env.MODERATOR_AI_MODEL || aiModelName, storyAgentsDir, storyArtifactService);
+                illustrator.maxHistoryMessages = 10;
+                illustrator.promptCacheTTL = 60;
+                illustrator.ownerRoomId = storyInfo.id;
+                illustrator.save();
+                console.log(`Created illustrator agent: ${illustrator.agentName}`);
+            }
+            let narrator = this.agentFactory.createAgent(aiServiceName, 'Narrator', '', 'Story narrator. Should receive all messages where a character wants to perform an action or PASS or INTRODUCE a new character. Responds to all dialog with characters not listed in Available Agents.', 'narrator', aiModelName, storyAgentsDir, storyArtifactService);
+            narrator.reasoningEffort = 'low';
+            narrator.allowSearch = true;
+            narrator.promptCacheTTL = 60;
+            narrator.ownerRoomId = storyInfo.id;
+            narrator.save();
+            console.log(`Created narrator agent: ${narrator.agentName}`);
+            narrator.disableMarkup = true;
+            narrator.disableBalanceCheck = true;
+            narrator.save();
+            this.progressService.emitProgress(storyInfo.id, 'opening-scene', 'Generating opening scene...');
+            const storyFrameworkPromptName = isImport ? 'import_story' : 'create_story';
+            const storyFrameworkResponse = await narrator.preparedPrompt(storyFrameworkPromptName, {
+                name,
+                idea,
+                userCharacterDesc,
+                otherCharactersDesc,
+                randomNumber: Math.floor(Math.random() * 100),
+                randomWord: this.getRandomWord(),
+            }, false);
+            const scenario = storyFrameworkResponse.scenario;
+            const openingScene = storyFrameworkResponse.openingScene;
+            const userCharacterInfo = storyFrameworkResponse.userCharacter;
+            const userCharacterBackstory = userCharacterInfo.backstory;
+            const otherCharactersInfo = storyFrameworkResponse.otherCharacters || [];
+            let importedStoryText = '';
+            if (isImport) {
+                importedStoryText = idea;
+            }
+            console.log(`Story framework extracted: ${otherCharactersInfo.length} other characters`);
+            const characters = [
+                {
+                    name: userCharacterInfo.name,
+                    sex: userCharacterInfo.sex,
+                    description: userCharacterInfo.description,
+                    isControlledByHuman: true,
+                },
+                ...otherCharactersInfo.map((char) => ({
+                    name: char.name,
+                    sex: char.sex,
+                    description: char.description,
+                    isControlledByHuman: false,
+                })),
+            ];
+            storyInfo.scenario = scenario;
+            storyInfo.characters = characters;
+            storyInfo.aiService = aiServiceName;
+            storyInfo.aiModel = aiModelName;
+            storyInfo.isImport = isImport;
+            this.storyStore.updateStoryMetadata(storyInfo.id, storyInfo);
+            this.storyStore.saveStoryCreationParameters(storyInfo.id, idea, userCharacterDesc, otherCharactersDesc);
+            const userCharacterName = userCharacterInfo.name || 'Player';
+            const userNickname = userCharacterName.trim().split(/\s+/)[0];
+            let userAgent = null;
+            try {
+                userAgent = this.agentFactory.createAgent(aiServiceName, `${name} - ${userNickname}`, userNickname, userCharacterInfo.description || userCharacterDesc, 'character', aiModelName, storyAgentsDir, storyArtifactService);
+                userAgent.isControlledByHuman = true;
+                userAgent.ownerRoomId = storyInfo.id;
+                userAgent.save();
+                console.log(`Created human-controlled character agent: ${userCharacterName}`);
+                userAgent.disableMarkup = true;
+                userAgent.disableBalanceCheck = true;
+                userAgent.save();
+            }
+            catch (error) {
+                console.error('Error creating user character:', error);
+                throw error;
+            }
+            const characterAgents = [];
+            for (let i = 0; i < otherCharactersInfo.length; i++) {
+                const charInfo = otherCharactersInfo[i];
+                const characterNickname = charInfo.name.trim().split(/\s+/)[0];
+                try {
+                    const agent = this.agentFactory.createAgent(aiServiceName, `${name} - ${characterNickname}`, characterNickname, charInfo.description, 'character', aiModelName, storyAgentsDir, storyArtifactService);
+                    agent.promptCacheTTL = 60;
+                    agent.ownerRoomId = storyInfo.id;
+                    agent.save();
+                    console.log(`Created character agent: ${charInfo.name}`);
+                    agent.disableMarkup = true;
+                    agent.disableBalanceCheck = true;
+                    agent.save();
+                    characterAgents.push(agent);
+                }
+                catch (error) {
+                    console.error(`Error creating character ${charInfo.name}:`, error);
+                }
+            }
+            console.log(`Created ${characterAgents.length + (userAgent ? 1 : 0)} character agents`);
+            const room = this.roomFactory.createRoom(`Story: ${name}`, scenario, '', storyRoomsDir);
+            room.arrive(moderator);
+            room.arrive(narrator);
+            if (userAgent) {
+                room.arrive(userAgent);
+            }
+            for (const characterAgent of characterAgents) {
+                room.arrive(characterAgent);
+            }
+            room.setRoomLeader(narrator.agentNickname);
+            room.setCurrentSpeaker(narrator.agentNickname);
+            room.setSituation(scenario || 'Story beginning');
+            const roomId = room.saveMetadata();
+            room.addRoomMessages([
+                new message_1.RoomMessage(`${userCharacterName}'s Backstory`, app_types_1.MessageAction.SYSTEM, userCharacterBackstory),
+            ]);
+            this.populateStoryHistory(room, openingScene);
+            const totalCharacters = (userAgent ? 1 : 0) + characterAgents.length;
+            console.log(`Created story room: ${roomId} with moderator, narrator, and ${totalCharacters} character agents`);
+            if (userAgent) {
+                room.setCurrentSpeaker(userAgent.agentNickname);
+            }
+            room.setOnStateChange(() => {
+                this.emitStoryStateUpdate(storyInfo.id);
+            });
+            room.setOnError((error) => {
+                this.handleRoomError(storyInfo.id, error);
+            });
+            room.setOnSituationUpdate((situation) => {
+                this.updateStorySituation(storyInfo.id, situation);
+            });
+            storyInfo.roomId = roomId;
+            storyInfo.moderatorAgentId = moderator.id;
+            storyInfo.illustratorAgentId = illustrator?.id;
+            storyInfo.artistAgentId = artist?.id;
+            storyInfo.imageModelName = imageModelName;
+            if (userAgent) {
+                storyInfo.userAgentId = userAgent.id;
+            }
+            this.storyStore.updateStoryMetadata(storyInfo.id, storyInfo);
+            await this.updateStoryCost(storyInfo.id);
+            room.ready();
+            setImmediate(() => {
+                this.createStoryAsync(storyInfo.id, name, importedStoryText, isImport).catch((error) => {
+                    console.error('Error in async story creation:', error);
+                    this.progressService.emitProgress(storyInfo.id, 'error', `Error: ${error.message}`);
+                    this.progressService.cleanup(storyInfo.id);
+                    this.deleteStory(storyInfo.id).catch((cleanupError) => {
+                        console.error('Error cleaning up story after async failure:', cleanupError);
+                    });
+                });
+            });
+            return storyInfo;
+        }
+        catch (error) {
+            console.error('Error creating story:', error);
+            this.progressService.emitProgress(storyInfo.id, 'error', `Error: ${error.message}`);
+            this.progressService.cleanup(storyInfo.id);
+            await this.deleteStory(storyInfo.id);
+            throw error;
+        }
+    }
+    async createStoryAsync(storyId, name, importedStoryText, isImport) {
+        try {
+            const room = await this.getStoryRoom(storyId);
+            const storyInfo = this.storyStore.getStory(storyId);
+            const plotPromptName = isImport ? 'import_plot' : 'create_plot';
+            const userCharPromptName = isImport ? 'import_user_character' : 'create_user_character';
+            const characterPromptName = isImport ? 'import_character' : 'create_character';
+            this.progressService.emitProgress(storyInfo.id, 'profiles', 'Generating detailed profiles and plot...');
+            const narrator = room.getAgents().find((a) => a.agentNickname === 'Narrator');
+            const userAgent = room.getAgents().find((a) => a.isControlledByHuman === true);
+            const userCharacter = storyInfo.characters.find((c) => c.isControlledByHuman === true);
+            const otherCharacters = storyInfo.characters
+                .filter((c) => c.isControlledByHuman === false)
+                .map((c) => `${c.name}: ${c.description}.`)
+                .join('\n');
+            let plotPlan = '';
+            const phase1Results = await Promise.all([
+                narrator
+                    .preparedPrompt(plotPromptName, {
+                    name,
+                    importedStoryText,
+                    scenario: storyInfo.scenario,
+                    characters: storyInfo.characters,
+                }, false)
+                    .then((response) => {
+                    if (response) {
+                        const cleanedPlotPlan = this.extractMarkdownContent(response);
+                        plotPlan = cleanedPlotPlan;
+                        room.publishArtifact('Plot Plan', narrator.agentNickname, cleanedPlotPlan, [
+                            narrator.agentNickname,
+                        ]);
+                        console.log(`Published plot plan artifact to narrator`);
+                        this.progressService.emitProgress(storyInfo.id, 'profiles', 'Finished creating detailed plot plan.');
+                    }
+                    return { type: 'plot', success: !!response };
+                })
+                    .catch((error) => {
+                    console.error('Error generating/publishing plot plan:', error);
+                    return { type: 'plot', success: false, error };
+                }),
+            ]);
+            const phase2Promises = [];
+            if (userAgent) {
+                phase2Promises.push(userAgent
+                    .preparedPrompt(userCharPromptName, {
+                    name,
+                    importedStoryText,
+                    scenario: storyInfo.scenario,
+                    characterName: userCharacter.name,
+                    characterObservableDesc: userCharacter.description,
+                    otherCharacters,
+                }, false)
+                    .then((response) => {
+                    if (response.character?.character_profile) {
+                        room.publishArtifact(`Character Profile - ${userAgent.agentNickname}`, userAgent.agentNickname, response.character.character_profile, [narrator.agentNickname, userAgent.agentNickname]);
+                        console.log(`Published character profile for ${userCharacter.name} (human-controlled)`);
+                        this.progressService.emitProgress(storyInfo.id, 'profiles', `Finished creating character profile for ${userCharacter.name}`);
+                    }
+                    else {
+                        throw new Error('No character profile returned from API');
+                    }
+                    return { type: 'userCharacter', success: true };
+                })
+                    .catch((error) => {
+                    console.error(`Error generating/publishing user character profile:`, error);
+                    return { type: 'userCharacter', success: false, error };
+                }));
+            }
+            for (let i = 0; i < storyInfo.characters.length; i++) {
+                const charInfo = storyInfo.characters[i];
+                if (charInfo.isControlledByHuman)
+                    continue;
+                const agent = room.getAgents().find((a) => a.agentNickname === charInfo.name);
+                const aiCharOtherCharacters = storyInfo.characters
+                    .filter((c) => c.isControlledByHuman === false)
+                    .map((c) => `${c.name}: ${c.description}.`)
+                    .join('\n');
+                phase2Promises.push(agent
+                    .preparedPrompt(characterPromptName, {
+                    name,
+                    importedStoryText,
+                    scenario: storyInfo.scenario,
+                    characterName: charInfo.name,
+                    characterObservableDesc: charInfo.description,
+                    userCharacter,
+                    otherCharacters: aiCharOtherCharacters,
+                    plotPlan,
+                }, false)
+                    .then((response) => {
+                    if (response.character?.character_profile) {
+                        room.publishArtifact(`Character Profile - ${agent.agentNickname}`, agent.agentNickname, response.character.character_profile, [agent.agentNickname]);
+                        console.log(`Published character profile for ${charInfo.name}`);
+                        this.progressService.emitProgress(storyInfo.id, 'profiles', `Finished creating character profile for ${charInfo.name}`);
+                    }
+                    else {
+                        throw new Error(`No character profile returned for ${charInfo.name}`);
+                    }
+                    return { type: 'character', name: charInfo.name, success: true };
+                })
+                    .catch((error) => {
+                    console.error(`Error generating/publishing profile for ${charInfo.name}:`, error);
+                    return {
+                        type: 'character',
+                        name: charInfo.name,
+                        success: false,
+                        error,
+                    };
+                }));
+            }
+            const phase2Results = await Promise.all(phase2Promises);
+            const openingSceneResult = await this.generateOpeningSceneImage(storyInfo, room);
+            const profileResults = [...phase1Results, ...phase2Results, openingSceneResult];
+            const failedProfiles = profileResults.filter((r) => !r.success);
+            if (failedProfiles.length > 0) {
+                console.warn(`${failedProfiles.length} profile(s) failed to generate`);
+            }
+            narrator.allowSearch = false;
+            narrator.save();
+            const allAgents = room.getAgents();
+            for (const agent of allAgents) {
+                if (agent.disableMarkup || agent.disableBalanceCheck) {
+                    agent.disableMarkup = false;
+                    agent.disableBalanceCheck = false;
+                    agent.save();
+                    console.log(`Re-enabled markup and balance checks for ${agent.agentName}`);
+                }
+            }
+            console.log(`Generated and published ${profileResults.length} profiles in parallel (each agent created its own profile)`);
+            room.saveMetadata();
+            this.progressService.emitProgress(storyInfo.id, 'complete', 'Story plot creation complete');
+        }
+        catch (error) {
+            console.error('Error creating story:', error);
+            this.progressService.emitProgress(storyId, 'error', `Error: ${error.message}`);
+        }
+        finally {
+            try {
+                const room = await this.getStoryRoom(storyId);
+                if (room) {
+                    const allAgents = room.getAgents();
+                    this.enableStoryAgentFlags(allAgents, 'story creation');
+                }
+            }
+            catch (finallyError) {
+                console.error('Error in finally block disabling flags:', finallyError);
+            }
+        }
+    }
+    generateCharacterPortraits(storyInfo, room) {
+        if (!storyInfo.artistAgentId) {
+            console.log('Skipping character portrait generation: no artist agent');
+            return [];
+        }
+        this.progressService.emitProgress(storyInfo.id, 'portraits', 'Generating character portraits...');
+        const characterAgents = room
+            .getAgents()
+            .filter((agent) => agent.promptFolder === 'character');
+        return characterAgents.map(async (characterAgent) => {
+            try {
+                return this.generateCharacterPortrait(room, characterAgent, storyInfo.id).then((artifactId) => {
+                    if (artifactId) {
+                        this.progressService.emitProgress(storyInfo.id, 'portraits', `Generated portrait for ${characterAgent.agentNickname}`);
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`Portrait error for ${characterAgent.agentNickname}:`, error);
+            }
+        });
+    }
+    generateOpeningSceneImage(storyInfo, room) {
+        return Promise.all(this.generateCharacterPortraits(storyInfo, room))
+            .then(() => {
+            return this.generateSceneIllustration(storyInfo.id, 'Opening Scene');
+        })
+            .then(() => {
+            this.progressService.emitProgress(storyInfo.id, 'opening-scene', 'Generating opening scene image...');
+            return { type: 'opening-scene', success: true };
+        })
+            .catch((_error) => {
+            return Promise.resolve({ type: 'opening-scene', success: false });
+        });
+    }
+    async validateImportStructure(importDir) {
+        const errors = [];
+        const metadataPath = path.join(importDir, 'metadata.json');
+        if (!fs.existsSync(metadataPath)) {
+            errors.push('metadata.json not found at root level');
+            return { valid: false, errors };
+        }
+        let metadata;
+        try {
+            const metadataContent = fs.readFileSync(metadataPath, 'utf-8');
+            metadata = JSON.parse(metadataContent);
+            if (!metadata.id || typeof metadata.id !== 'string') {
+                errors.push("metadata.json missing or invalid 'id' field");
+            }
+            if (!metadata.name ||
+                typeof metadata.name !== 'string' ||
+                metadata.name.trim() === '') {
+                errors.push("metadata.json missing or invalid 'name' field");
+            }
+            if (!metadata.roomId || typeof metadata.roomId !== 'string') {
+                errors.push("metadata.json missing or invalid 'roomId' field");
+            }
+            if (!metadata.moderatorAgentId || typeof metadata.moderatorAgentId !== 'string') {
+                errors.push("metadata.json missing or invalid 'moderatorAgentId' field");
+            }
+            if (!Array.isArray(metadata.characters)) {
+                errors.push("metadata.json missing or invalid 'characters' field");
+            }
+        }
+        catch (error) {
+            errors.push(`Failed to parse metadata.json: ${error.message}`);
+            return { valid: false, errors };
+        }
+        const agentsDir = path.join(importDir, 'agents');
+        if (!fs.existsSync(agentsDir)) {
+            errors.push('agents/ folder not found');
+        }
+        else {
+            const referencedAgentIds = new Set();
+            if (metadata.moderatorAgentId)
+                referencedAgentIds.add(metadata.moderatorAgentId);
+            if (metadata.illustratorAgentId)
+                referencedAgentIds.add(metadata.illustratorAgentId);
+            if (metadata.artistAgentId)
+                referencedAgentIds.add(metadata.artistAgentId);
+            if (metadata.userAgentId)
+                referencedAgentIds.add(metadata.userAgentId);
+            for (const agentId of referencedAgentIds) {
+                const agentFile = path.join(agentsDir, `${agentId}.json`);
+                if (!fs.existsSync(agentFile)) {
+                    errors.push(`Agent file missing: agents/${agentId}.json`);
+                }
+            }
+        }
+        const roomsDir = path.join(importDir, 'rooms');
+        if (!fs.existsSync(roomsDir)) {
+            errors.push('rooms/ folder not found');
+        }
+        else {
+            const roomFolders = fs
+                .readdirSync(roomsDir)
+                .filter((f) => fs.statSync(path.join(roomsDir, f)).isDirectory());
+            if (roomFolders.length !== 1) {
+                errors.push(`Expected exactly 1 room folder, found ${roomFolders.length}`);
+            }
+            else {
+                const roomFolderName = roomFolders[0];
+                if (roomFolderName !== metadata.roomId) {
+                    errors.push(`Room folder name '${roomFolderName}' doesn't match roomId '${metadata.roomId}' in metadata`);
+                }
+                const roomMetadataPath = path.join(roomsDir, roomFolderName, 'metadata.json');
+                if (!fs.existsSync(roomMetadataPath)) {
+                    errors.push(`Room metadata.json not found at rooms/${roomFolderName}/metadata.json`);
+                }
+            }
+        }
+        const storyCreationPath = path.join(importDir, 'story_creation.json');
+        if (!fs.existsSync(storyCreationPath)) {
+            console.warn('story_creation.json not found (non-fatal)');
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            metadata: errors.length === 0 ? metadata : undefined,
+        };
+    }
+    async extractZip(zipBuffer, targetDir) {
+        return new Promise((resolve, reject) => {
+            let totalSize = 0;
+            const maxSize = 100 * 1024 * 1024;
+            yauzl.fromBuffer(zipBuffer, { lazyEntries: true }, (err, zipfile) => {
+                if (err) {
+                    return reject(new Error(`Failed to read zip file: ${err.message}`));
+                }
+                zipfile.readEntry();
+                zipfile.on('entry', (entry) => {
+                    const entryPath = entry.fileName;
+                    if (entryPath.includes('..') || path.isAbsolute(entryPath)) {
+                        zipfile.close();
+                        return reject(new Error(`Security: Invalid path in zip: ${entryPath}`));
+                    }
+                    const fullPath = path.join(targetDir, entryPath);
+                    if (/\/$/.test(entryPath)) {
+                        fs.mkdirSync(fullPath, { recursive: true });
+                        zipfile.readEntry();
+                    }
+                    else {
+                        zipfile.openReadStream(entry, (err, readStream) => {
+                            if (err) {
+                                zipfile.close();
+                                return reject(new Error(`Failed to read entry ${entryPath}: ${err.message}`));
+                            }
+                            fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+                            const writeStream = fs.createWriteStream(fullPath);
+                            readStream.on('data', (chunk) => {
+                                totalSize += chunk.length;
+                                if (totalSize > maxSize) {
+                                    zipfile.close();
+                                    writeStream.close();
+                                    reject(new Error(`Zip file exceeds maximum size of ${maxSize} bytes`));
+                                }
+                            });
+                            readStream.pipe(writeStream);
+                            writeStream.on('finish', () => {
+                                zipfile.readEntry();
+                            });
+                            writeStream.on('error', (err) => {
+                                zipfile.close();
+                                reject(new Error(`Failed to write file ${entryPath}: ${err.message}`));
+                            });
+                        });
+                    }
+                });
+                zipfile.on('end', () => {
+                    resolve();
+                });
+                zipfile.on('error', (err) => {
+                    reject(new Error(`Zip extraction error: ${err.message}`));
+                });
+            });
+        });
+    }
+    async importStoryFromZip(zipBuffer) {
+        const storiesDir = path.join(this.configService.getUserDataDir(), 'stories');
+        const importDir = path.join(storiesDir, 'import');
+        try {
+            if (fs.existsSync(importDir)) {
+                fs.rmSync(importDir, { recursive: true, force: true });
+            }
+            fs.mkdirSync(importDir, { recursive: true });
+            await this.extractZip(zipBuffer, importDir);
+            const validationResult = await this.validateImportStructure(importDir);
+            if (!validationResult.valid) {
+                throw new Error(`Invalid story structure:\n${validationResult.errors.join('\n')}`);
+            }
+            const metadata = validationResult.metadata;
+            const finalStoryPath = path.join(storiesDir, metadata.id);
+            if (fs.existsSync(finalStoryPath)) {
+                throw new Error(`Story with ID ${metadata.id} already exists (name: '${metadata.name}')`);
+            }
+            fs.renameSync(importDir, finalStoryPath);
+            console.log(`Successfully imported story: ${metadata.name} (${metadata.id})`);
+            return metadata;
+        }
+        catch (error) {
+            if (fs.existsSync(importDir)) {
+                fs.rmSync(importDir, { recursive: true, force: true });
+            }
+            throw error;
+        }
+    }
+    populateStoryHistory(room, storyText) {
+        try {
+            const storyMessage = {
+                role: 'assistant',
+                content: storyText,
+            };
+            room.getAgents().forEach((agent) => {
+                agent.addToConversationHistory(storyMessage);
+                agent.save();
+            });
+            room.addRoomMessages([
+                new message_1.RoomMessage(`Opening Scene`, app_types_1.MessageAction.SYSTEM, storyText),
+            ]);
+        }
+        catch (error) {
+            console.error('Error populating imported story history:', error);
+            throw error;
+        }
+    }
+    async getStoryState(storyId) {
+        const story = await this.ensureStoryLoaded(storyId);
+        if (!story) {
+            throw new Error('Story not found');
+        }
+        const room = await this.roomStore.getRoom(story.roomId);
+        if (!room) {
+            throw new Error('Story room not found');
+        }
+        const humanAgent = room.getAgents().find((agent) => agent.isControlledByHuman);
+        if (!humanAgent) {
+            throw new Error('No human-controlled agent found in story');
+        }
+        const roomMessages = room.getLatestRoomMessages(0, true);
+        const latestMessageIndex = roomMessages.length > 0 ? roomMessages[roomMessages.length - 1].index : -1;
+        let latestRoomMessage = null;
+        if (latestMessageIndex >= 0)
+            latestRoomMessage = roomMessages[latestMessageIndex];
+        const currentSpeaker = room.getCurrentSpeaker();
+        const humanPrompt = this.getHumanPrompt(room);
+        let storyState = {
+            storyId: storyId,
+            userAgentName: humanAgent.agentNickname,
+            latestRoomMessage: latestRoomMessage,
+            humanPrompt: humanPrompt,
+            currentSpeaker: currentSpeaker,
+            totalCost: story.totalCost || 0,
+            totalInputTokens: story.totalInputTokens || 0,
+            totalOutputTokens: story.totalOutputTokens || 0,
+        };
+        return storyState;
+    }
+    async listCharacters(storyId) {
+        try {
+            const room = await this.getStoryRoom(storyId);
+            const characters = room
+                .getAgents()
+                .filter((agent) => agent.promptFolder === 'character');
+            return characters.map((agent) => ({
+                name: agent.agentNickname,
+                description: agent.description,
+                isControlledByHuman: agent.isControlledByHuman,
+            }));
+        }
+        catch (error) {
+            console.error('Error listing characters:', error);
+            return [];
+        }
+    }
+    async getCharacter(storyId, characterName) {
+        try {
+            const room = await this.getStoryRoom(storyId);
+            const artifactName = `Character Profile - ${characterName}`;
+            const artifacts = room.getArtifacts();
+            const profileArtifact = artifacts.find((a) => a.name === artifactName);
+            if (!profileArtifact) {
+                return null;
+            }
+            let content = profileArtifact.body;
+            const portraitName = `Portrait - ${characterName}`;
+            const storyArtifactService = this.getStoryArtifactService(storyId);
+            const allArtifacts = storyArtifactService.listArtifacts();
+            const portraitArtifact = allArtifacts.find((a) => a.name === portraitName);
+            if (portraitArtifact) {
+                const imgUrl = `/api/stories/${storyId}/artifacts/${portraitArtifact.artifactId}`;
+                const imageMarkdown = `![Portrait of ${characterName}](${imgUrl})\n\n`;
+                content = imageMarkdown + content;
+            }
+            return content;
+        }
+        catch (error) {
+            console.error('Error getting character:', error);
+            throw new Error(`Error getting character: ${error.message}`);
+        }
+    }
+    saveCharacter(storyId, characterName, content) {
+        const artifactName = `Character Profile - ${characterName}`;
+        this.publishArtifact(storyId, artifactName, characterName, content, []);
+    }
+    async getPlotPlan(storyId) {
+        const room = await this.getStoryRoom(storyId);
+        const artifacts = room.getArtifacts();
+        const artifact = artifacts.find((a) => a.name === 'Plot Plan');
+        if (!artifact) {
+            return null;
+        }
+        return artifact.body;
+    }
+    async getAgentHistory(storyId, agentId) {
+        const room = await this.getStoryRoom(storyId);
+        const agent = room.getAgents().find((a) => a.id === agentId);
+        if (!agent) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        return JSON.stringify(agent.history || []);
+    }
+    async savePlotPlan(storyId, content) {
+        const room = await this.getStoryRoom(storyId);
+        room.publishArtifact('Plot Plan', 'Narrator', content, []);
+    }
+    async publishArtifact(storyId, name, creator, body, viewers) {
+        const room = await this.getStoryRoom(storyId);
+        room.publishArtifact(name, creator, body, viewers);
+    }
+    async respondToStory(storyId, content) {
+        const room = await this.getStoryRoom(storyId);
+        const trimmedContent = content?.trim();
+        const isPassing = trimmedContent?.toUpperCase() === 'PASS';
+        if (!trimmedContent && !isPassing) {
+            throw new Error('No message content provided');
+        }
+        const story = this.storyStore.getStory(storyId);
+        if (story) {
+            story.turnNumber = (story.turnNumber || 0) + 1;
+            this.storyStore.updateStoryMetadata(storyId, story);
+        }
+        const humanAgent = room.getAgents().find((agent) => agent.isControlledByHuman);
+        if (!humanAgent) {
+            throw new Error('No human-controlled agent found in story');
+        }
+        const responseMessage = new message_1.RoomMessage(humanAgent.agentNickname, app_types_1.MessageAction.MODERATE, content, [], null);
+        room.addPendingMessage(responseMessage);
+    }
+    async introduceCharacter(storyId, characterName, characterDescription, storyModel, fromNarratorSuggestion) {
+        const room = await this.getStoryRoom(storyId);
+        if (!characterName)
+            throw new Error('No character name provided');
+        if (characterName === 'Narrator' || characterName === 'Moderator') {
+            throw new Error('Cannot introduce a character named Narrator or Moderator');
+        }
+        const existingAgent = room.getAgents().find((agent) => {
+            const agentFirstNickname = agent.agentNickname.split(/\s+/)[0];
+            return agent.agentNickname === characterName || agentFirstNickname === characterName;
+        });
+        if (existingAgent) {
+            throw new Error(`A character named ${characterName} already exists in this story`);
+        }
+        let aiServiceName;
+        let aiModelName;
+        if (!storyModel || storyModel.trim().length === 0)
+            storyModel = process.env.DEFAULT_STORY_MODEL;
+        const modelConfig = this.getStoryModelConfig(storyModel);
+        if (modelConfig) {
+            aiServiceName = modelConfig.service;
+            aiModelName = modelConfig.model;
+        }
+        if (!aiServiceName || !aiModelName) {
+            throw new Error('Invalid story model provided');
+        }
+        room.setCurrentSpeaker(null);
+        const { agentsDir: storyAgentsDir } = this.getStoryStorageDirs(storyId);
+        const storyArtifactService = this.getStoryArtifactService(storyId);
+        const story = this.storyStore.getStory(storyId);
+        const storyTitle = story.name;
+        const characterNickname = characterName.trim().split(/\s+/)[0];
+        const characterAgent = this.agentFactory.createAgent(aiServiceName, `${storyTitle} - ${characterNickname}`, characterNickname, characterDescription, 'character', aiModelName, storyAgentsDir, storyArtifactService);
+        characterAgent.promptCacheTTL = 60;
+        characterAgent.save();
+        room.arrive(characterAgent);
+        const introducedCharArtifacts = room.getArtifacts();
+        const introducedCharPlotPlanArtifact = introducedCharArtifacts.find((a) => a.name === 'Plot Plan');
+        const introducedCharPlotPlan = introducedCharPlotPlanArtifact?.body || '';
+        await this.updateCharacterProfiles(room, [characterAgent], introducedCharPlotPlan);
+        try {
+            const artifactId = await this.generateCharacterPortrait(room, characterAgent, storyId);
+            if (artifactId) {
+                console.log(`Generated portrait for newly introduced character: ${characterName}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error generating portrait for introduced character ${characterName}:`, error);
+        }
+        if (!fromNarratorSuggestion) {
+            room.addPendingMessage(new message_1.RoomMessage('system', app_types_1.MessageAction.MODERATE, `INTRODUCE ${characterName}`));
+        }
+        else {
+            console.log(`Skipping INTRODUCE message for ${characterName} (already introduced by narrator)`);
+        }
+    }
+    async declineCharacter(storyId, characterName) {
+        const story = this.storyStore.getStory(storyId);
+        if (!story) {
+            throw new Error('Story not found');
+        }
+        if (!story.declinedCharacters) {
+            story.declinedCharacters = [];
+        }
+        if (!story.declinedCharacters.includes(characterName)) {
+            story.declinedCharacters.push(characterName);
+            this.storyStore.updateStoryMetadata(storyId, story);
+            console.log(`Recorded declined character: ${characterName} for story ${storyId}`);
+        }
+    }
+    async deleteCharacter(storyId, characterName) {
+        let room;
+        try {
+            room = await this.getStoryRoom(storyId);
+        }
+        catch (_error) {
+            throw new errors_1.NotFoundError(`Story not found: ${storyId}`);
+        }
+        if (!room) {
+            throw new errors_1.NotFoundError(`Story not found: ${storyId}`);
+        }
+        const agent = room.getAgents().find((a) => a.agentNickname === characterName);
+        if (!agent) {
+            throw new errors_1.NotFoundError(`Character agent not found: ${characterName}`);
+        }
+        if (characterName === 'Narrator' ||
+            characterName === 'Moderator' ||
+            agent.isControlledByHuman) {
+            throw new errors_1.OperationFailedError(`Cannot delete ${characterName} - system agents and human-controlled characters cannot be removed`);
+        }
+        const agents = room.getAgents();
+        const filteredAgents = agents.filter((a) => a.agentNickname !== characterName);
+        room.setAgents(filteredAgents);
+        room.saveMetadata();
+        this.agentStore.removeAgent(agent.id);
+    }
+    async deleteStory(storyId) {
+        console.log(`Deleting story ${storyId}...`);
+        const story = this.storyStore.getStory(storyId);
+        if (story?.roomId) {
+            try {
+                const room = await this.roomStore.getRoom(story.roomId);
+                if (room) {
+                    const agents = room.getAgents();
+                    await Promise.all(agents.map(async (agent) => {
+                        try {
+                            await agent.deleteAgent();
+                        }
+                        catch (error) {
+                            console.warn(`Error deleting agent ${agent.id}:`, error);
+                        }
+                    }));
+                    room.deleteRoom();
+                    console.log(`Deleted room ${story.roomId} for story ${storyId}`);
+                }
+                else {
+                    console.warn(`Room ${story.roomId} not found for story ${storyId}`);
+                }
+            }
+            catch (error) {
+                console.warn(`Error cleaning up room for story ${storyId}:`, error);
+            }
+        }
+        else {
+            console.warn(`Story ${storyId} has no roomId, skipping room cleanup`);
+        }
+        if (story?.artistAgentId) {
+            try {
+                this.agentStore.removeAgent(story.artistAgentId);
+                console.log(`Deleted artist agent ${story.artistAgentId}`);
+            }
+            catch (error) {
+                console.warn(`Error deleting artist agent ${story.artistAgentId}:`, error);
+            }
+        }
+        if (story?.illustratorAgentId) {
+            try {
+                this.agentStore.removeAgent(story.illustratorAgentId);
+                console.log(`Deleted illustrator agent ${story.illustratorAgentId}`);
+            }
+            catch (error) {
+                console.warn(`Error deleting illustrator agent ${story.illustratorAgentId}:`, error);
+            }
+        }
+        try {
+            this.cleanupProgressEmitter(storyId);
+            this.cleanupMessageEmitter(storyId);
+        }
+        catch (error) {
+            console.warn(`Error cleaning up emitters for story ${storyId}:`, error);
+        }
+        try {
+            this.storyStore.removeStory(storyId);
+            console.log(`Deleted story ${storyId} from store`);
+        }
+        catch (error) {
+            console.warn(`Error removing story ${storyId} from store:`, error);
+        }
+        console.log(`Story ${storyId} deletion complete`);
+    }
+    disableStoryAgentFlags(agents, reason = 'operation') {
+        for (const agent of agents) {
+            if (agent && !agent.disableMarkup && !agent.disableBalanceCheck) {
+                agent.disableMarkup = true;
+                agent.disableBalanceCheck = true;
+                agent.save();
+                console.log(`Disabled markup/balance checks for ${agent.agentName} (${reason})`);
+            }
+        }
+    }
+    enableStoryAgentFlags(agents, reason = 'operation') {
+        for (const agent of agents) {
+            if (agent && (agent.disableMarkup || agent.disableBalanceCheck)) {
+                agent.disableMarkup = false;
+                agent.disableBalanceCheck = false;
+                agent.save();
+                console.log(`Re-enabled markup/balance checks for ${agent.agentName} (${reason})`);
+            }
+        }
+    }
+    async compactStory(storyId) {
+        let agents = [];
+        try {
+            const room = await this.getStoryRoom(storyId);
+            agents = room.getAgents();
+            if (agents.length === 0) {
+                throw new Error('No agents in story room');
+            }
+            console.log(`Compacting ${agents.length} agents in parallel`);
+            const agentsToCompact = agents.filter(agent => agent !== room.getModeratorAgent());
+            this.disableStoryAgentFlags(agentsToCompact, 'compaction');
+            const compactionPromises = agents.map(async (agent) => {
+                if (agent === room.getModeratorAgent()) {
+                    agent.history = [];
+                    agent.save();
+                    return;
+                }
+                try {
+                    await this.compactAgentHistory(agent);
+                }
+                catch (error) {
+                    console.error(`Error compacting ${agent.agentName}:`, error);
+                }
+            });
+            await Promise.all(compactionPromises);
+            console.log(`Finished compacting ${agents.length} agents in parallel`);
+            return { success: true };
+        }
+        catch (error) {
+            console.error('Error compacting story:', error);
+            return { success: false, message: error.message };
+        }
+        finally {
+            if (agents.length > 0) {
+                this.enableStoryAgentFlags(agents, 'compaction');
+            }
+        }
+    }
+    async progressStoryToNextChapter(storyId) {
+        const story = await this.ensureStoryLoaded(storyId);
+        if (!story) {
+            throw new Error('Story not found');
+        }
+        const existingEmitter = this.progressService.getProgressEmitter(storyId);
+        if (!existingEmitter) {
+            this.progressService.createProgressEmitter(storyId);
+        }
+        const room = await this.getStoryRoom(storyId);
+        room.setCurrentSpeaker('system');
+        this.progressService.emitProgress(storyId, 'opening-scene', 'Generating opening scene of chapter...');
+        const agents = room.getAgents();
+        const narrator = agents.find((agent) => agent.promptFolder === 'narrator');
+        const { openingScene, chapterTitle } = await this.generateOpeningScene(room, narrator);
+        this.progressService.emitProgress(storyId, 'chapter-backup', `Saving previous chapter: "${chapterTitle}"...`);
+        const chapterIndex = this.storyStore.getNextChapterIndex(storyId);
+        const backupSuccess = this.storyStore.createChapterBackup(storyId, chapterIndex, chapterTitle);
+        if (!backupSuccess) {
+            throw new Error('Failed to backup chapter');
+        }
+        room.clearRoomMessages();
+        this.populateStoryHistory(room, openingScene);
+        const humanAgent = room.getAgents().find((a) => a.isControlledByHuman);
+        if (humanAgent) {
+            room.setCurrentSpeaker(humanAgent.agentNickname);
+        }
+        this.progressService.emitProgress(storyId, 'ready', 'Chapter opening is ready! Continuing chapter progression in the background...');
+        setImmediate(() => {
+            this.progressStoryToNextChapterAsync(storyId).catch((error) => {
+                console.error('Error in async chapter progression:', error);
+                this.progressService.emitProgress(storyId, 'error', `Error: ${error.message}`);
+            });
+        });
+        return { chapterIndex };
+    }
+    async progressStoryToNextChapterAsync(storyId) {
+        let room = null;
+        let agents = [];
+        let narrator = null;
+        let characterAgents = [];
+        try {
+            room = await this.getStoryRoom(storyId);
+            agents = room.getAgents();
+            narrator = agents.find((agent) => agent.promptFolder === 'narrator');
+            characterAgents = agents.filter((agent) => agent.promptFolder === 'character');
+            if (narrator) {
+                narrator.disableMarkup = true;
+                narrator.disableBalanceCheck = true;
+                narrator.allowSearch = false;
+                narrator.save();
+            }
+            for (const agent of characterAgents) {
+                agent.disableMarkup = true;
+                agent.disableBalanceCheck = true;
+                agent.save();
+            }
+            this.progressService.emitProgress(storyId, 'profiles-compact', 'Updating plot plan and character profiles...');
+            const updatedPlotPlan = await this.updatePlotPlan(room, narrator);
+            await this.updateCharacterProfiles(room, characterAgents, updatedPlotPlan);
+            await this.updateStoryCost(storyId);
+            this.progressService.emitProgress(storyId, 'complete', 'Chapter progression complete!');
+        }
+        catch (error) {
+            console.error('Error in async chapter progression:', error);
+            throw error;
+        }
+        finally {
+            if (room) {
+                const agentsToReEnable = narrator ? [narrator, ...characterAgents] : characterAgents;
+                this.enableStoryAgentFlags(agentsToReEnable, 'chapter progression');
+            }
+        }
+    }
+    async generateOpeningScene(room, narrator) {
+        const artifacts = room.getArtifacts();
+        const plotPlanArtifact = artifacts.find((a) => a.name === 'Plot Plan');
+        const currentPlotPlan = plotPlanArtifact?.body || 'No plot plan found.';
+        const formattedHistory = narrator.getRawMessages();
+        const aiResponse = await narrator.preparedPrompt('create_chapter', {
+            currentPlotPlan: currentPlotPlan,
+            formattedHistory: formattedHistory || 'No recent events...',
+        }, false);
+        const lines = aiResponse.split('\n');
+        let chapterTitle = 'Untitled Chapter';
+        let openingScene = aiResponse;
+        if (lines.length > 0 && lines[0].trim().startsWith('#')) {
+            chapterTitle = lines[0].trim().substring(1).trim();
+            openingScene = lines.slice(1).join('\n').trim();
+        }
+        return {
+            openingScene,
+            chapterTitle,
+        };
+    }
+    async compactAgentHistories(agents, threshold) {
+        await Promise.all(agents.map(async (agent) => {
+            let numMessageChars = agent.history?.map((m) => m.content?.length).reduce((a, b) => a + b, 0);
+            if (numMessageChars > threshold) {
+                await this.compactAgentHistory(agent);
+            }
+            else {
+                return Promise.resolve();
+            }
+        }));
+    }
+    async compactAgentHistory(agent) {
+        const originalHistory = [...agent.history];
+        const originalLength = originalHistory.length;
+        if (originalHistory.length == 0) {
+            return {
+                success: true,
+                originalLength: originalLength,
+                newLength: originalLength,
+                message: 'No conversation history to compact',
+            };
+        }
+        const formattedHistory = agent.getFormattedMessages(0);
+        try {
+            agent.history = [];
+            const summaryResponse = await agent.preparedPrompt('compact_story', {
+                agentName: agent.agentNickname,
+                formattedHistory: formattedHistory,
+            }, false);
+            const summary = summaryResponse?.summary || summaryResponse;
+            agent.addToConversationHistory(`[CONVERSATION HISTORY SUMMARY]\n\n${summary}`, true);
+            const newLength = agent.history.length;
+            console.log(`Compacted ${agent.agentName}: ${originalLength} messages`);
+            agent.save();
+            return {
+                success: true,
+                originalLength: originalLength,
+                newLength: newLength,
+                message: `${originalLength} messages -> ${newLength} messages`,
+                summary: summary,
+            };
+        }
+        catch (error) {
+            agent.history = originalHistory;
+            console.error(`Error compacting ${agent.agentName}:`, error);
+            throw error;
+        }
+    }
+    extractMarkdownContent(response) {
+        const fenceMatch = response.match(/```(?:markdown)?\s*\n([\s\S]*?)```/);
+        if (fenceMatch) {
+            return fenceMatch[1].trim();
+        }
+        return response.trim();
+    }
+    async updatePlotPlan(room, narrator) {
+        const artifacts = room.getArtifacts();
+        const plotPlanArtifact = artifacts.find((a) => a.name === 'Plot Plan');
+        const currentPlotPlan = plotPlanArtifact ? plotPlanArtifact.body : 'No plot plan found.';
+        const formattedHistory = narrator.getRawMessages();
+        try {
+            const progressPlotResponse = await narrator.preparedPrompt('progress_plot', {
+                currentPlotPlan: currentPlotPlan,
+                formattedHistory: formattedHistory,
+            }, false);
+            if (progressPlotResponse) {
+                const cleanedPlotPlan = this.extractMarkdownContent(progressPlotResponse);
+                room.publishArtifact('Plot Plan', narrator.agentNickname, cleanedPlotPlan, [
+                    narrator.agentNickname,
+                ]);
+                console.log(`Updated plot plan`);
+                return cleanedPlotPlan;
+            }
+        }
+        catch (error) {
+            console.error(`Error updating plot plan:`, error);
+        }
+        return '';
+    }
+    async updateCharacterProfiles(room, characterAgents, plotPlan = '') {
+        const artifacts = room.getArtifacts();
+        const updatePromises = characterAgents.map(async (character) => {
+            try {
+                const profileArtifact = artifacts.find((a) => a.name === `Character Profile - ${character.agentNickname}`);
+                let currentProfile = profileArtifact ? profileArtifact.body : null;
+                let formattedHistory = character.getFormattedMessages(0);
+                if (!currentProfile) {
+                    currentProfile = `There is not yet a character profile for ${character.agentNickname}. Use the updated plot plan and recent story messages to create a character profile.`;
+                    if (!formattedHistory || formattedHistory.length === 0) {
+                        formattedHistory = room
+                            .getLatestRoomMessages(0, true)
+                            .map((m) => `${m.sender}: ${m.content}\n`);
+                    }
+                }
+                const progressCharacterResponse = await character.preparedPrompt('progress_character', {
+                    agentName: character.agentNickname,
+                    currentProfile: currentProfile,
+                    formattedHistory: formattedHistory,
+                    plotPlan,
+                }, false);
+                if (progressCharacterResponse.description) {
+                    character.description = progressCharacterResponse.description;
+                    character.save();
+                }
+                room.publishArtifact(`Character Profile - ${character.agentNickname}`, character.agentNickname, progressCharacterResponse.character_profile, [character.agentNickname]);
+            }
+            catch (error) {
+                console.error(`Error updating character profile for ${character.agentNickname}:`, error);
+            }
+        });
+        await Promise.all(updatePromises);
+        console.log(`Updated ${characterAgents.length} character profiles in parallel`);
+        const portraitPromises = characterAgents.map(async (characterAgent) => {
+            try {
+                const pathParts = room.getStorageDir().split(path.sep);
+                const storiesIndex = pathParts.findIndex((p) => p === 'stories');
+                const storyId = storiesIndex >= 0 ? pathParts[storiesIndex + 1] : null;
+                if (!storyId) {
+                    console.error('Could not extract story ID from room path');
+                    return { character: characterAgent.agentNickname, success: false };
+                }
+                const storyArtifactService = this.getStoryArtifactService(storyId);
+                const oldPortraitName = `Portrait - ${characterAgent.agentNickname}`;
+                const oldArtifacts = storyArtifactService.listArtifacts();
+                const oldPortrait = oldArtifacts.find((a) => a.name === oldPortraitName);
+                if (oldPortrait) {
+                    storyArtifactService.deleteArtifact(oldPortrait.artifactId);
+                    console.log(`Deleted old portrait for ${characterAgent.agentName}`);
+                }
+                const artifactId = await this.generateCharacterPortrait(room, characterAgent, storyId);
+                return {
+                    character: characterAgent.agentNickname,
+                    success: !!artifactId,
+                    artifactId,
+                };
+            }
+            catch (error) {
+                console.error(`Error regenerating portrait for ${characterAgent.agentName}:`, error);
+                return { character: characterAgent.agentNickname, success: false, error };
+            }
+        });
+        await Promise.all(portraitPromises);
+        console.log(`Regenerated portraits for ${characterAgents.length} characters`);
+    }
+    getImageModelConfig(modelName) {
+        try {
+            if (!modelName) {
+                return null;
+            }
+            const imageModelsPath = path.join(this.configService.getCommonConfigDir(), 'image_models.json');
+            const imageModels = JSON.parse(fs.readFileSync(imageModelsPath, 'utf8'));
+            const modelConfig = imageModels.find((m) => m.name === modelName);
+            if (!modelConfig) {
+                console.warn(`Image model not found: ${modelName}`);
+                return null;
+            }
+            if (!modelConfig.service || !modelConfig.model) {
+                console.log(`Images disabled: selected "${modelName}"`);
+                return null;
+            }
+            return { service: modelConfig.service, model: modelConfig.model };
+        }
+        catch (error) {
+            console.error('Error loading image model config:', error);
+            return null;
+        }
+    }
+    createArtistAgent(storyId, storyAgentsDir, storyArtifactService, imageModelName) {
+        const imageConfig = this.getImageModelConfig(imageModelName);
+        if (!imageConfig) {
+            console.log('Artist agent creation skipped: images disabled');
+            return null;
+        }
+        const artistAgent = this.agentFactory.createAgent(imageConfig.service, 'Artist', '', 'AI artist for generating character portraits and scene illustrations', 'default', imageConfig.model, storyAgentsDir, storyArtifactService);
+        artistAgent.maxHistoryMessages = 10;
+        artistAgent.promptCacheTTL = 0;
+        artistAgent.save();
+        console.log(`Created artist agent: ${artistAgent.agentName} (${imageConfig.service}/${imageConfig.model})`);
+        return artistAgent;
+    }
+    async generateCharacterPortrait(room, characterAgent, storyId) {
+        try {
+            const artifacts = room.getArtifacts();
+            const profileArtifact = artifacts.find((a) => a.name === `Character Profile - ${characterAgent.agentNickname}`);
+            const storyInfo = this.storyStore.getStory(storyId);
+            const scenario = storyInfo?.scenario || '';
+            const character = storyInfo.characters.find((c) => c.name === characterAgent.agentNickname);
+            let characterDescription = profileArtifact?.body || character?.description || '';
+            if (!characterDescription) {
+                console.warn(`No profile for ${characterAgent.agentNickname}, skipping portrait`);
+                return null;
+            }
+            const artistAgent = await this.agentStore.getAgent(storyInfo.artistAgentId);
+            if (!artistAgent) {
+                console.warn(`Artist agent not found: ${storyInfo.artistAgentId}`);
+                return null;
+            }
+            const visualDescription = await characterAgent.preparedPrompt('describe_character', {
+                characterName: characterAgent.agentNickname,
+                characterProfile: characterDescription,
+                scenario: scenario,
+            }, false);
+            if (!visualDescription || typeof visualDescription !== 'string') {
+                console.warn(`Failed to generate visual description for ${characterAgent.agentNickname}`);
+                return null;
+            }
+            const imageResult = await artistAgent.generateImage(visualDescription, 1024, 1536, 'high');
+            if (imageResult.error) {
+                return null;
+            }
+            artistAgent.save();
+            const artifactId = imageResult.artifactId;
+            let storyArtifactService = this.getStoryArtifactService(storyId);
+            storyArtifactService.renameArtifact(artifactId, `Portrait - ${characterAgent.agentNickname}`);
+            storyArtifactService.updateArtifactDescription(artifactId, visualDescription);
+            console.log(`Generated portrait for ${characterAgent.agentNickname}: ${artifactId}`);
+            return artifactId;
+        }
+        catch (error) {
+            console.error(`Error generating portrait for ${characterAgent.agentNickname}:`, error);
+            return null;
+        }
+    }
+    async generateSceneIllustration(storyId, situation) {
+        try {
+            const story = this.storyStore.getStory(storyId);
+            if (!story?.illustratorAgentId) {
+                console.log('No illustrator configured');
+                return;
+            }
+            const illustrator = await this.agentStore.getAgent(story.illustratorAgentId);
+            const room = await this.roomStore.getRoom(story.roomId);
+            if (!illustrator || !room)
+                return;
+            const allMessages = room.getLatestRoomMessages(0, true);
+            const latestMessage = allMessages[allMessages.length - 1];
+            if (!latestMessage) {
+                console.warn('No messages in room');
+                return;
+            }
+            illustrator.addToConversationHistory(latestMessage.content, false);
+            const storyArtifactService = this.getStoryArtifactService(storyId);
+            const allArtifacts = storyArtifactService.listArtifacts();
+            const existingScenes = allArtifacts
+                .filter((a) => a.name.startsWith('Scene - '))
+                .map((a) => ({
+                name: a.name.replace('Scene - ', ''),
+                description: a.description || '',
+            }));
+            let existingScenesString = existingScenes
+                .map((s) => `- ${s.name}: ${s.description}`)
+                .join('\n');
+            if (!existingScenesString)
+                existingScenesString =
+                    'No scene reference images have been created yet. (set isReference: true)';
+            let prompt = `**Current Situation**:\n ${story.situation}\n\n**Existing Scenes**:\n ${existingScenesString}`;
+            const sceneAnalysis = await illustrator.instructedPrompt(prompt, 'describe_scene', {
+                characters: story.characters,
+            }, true, true);
+            illustrator.save();
+            if (!sceneAnalysis || !sceneAnalysis.createImage) {
+                console.log('Illustrator decided not to create an image for this situation');
+                return;
+            }
+            if (sceneAnalysis.isReference) {
+                await this.generateSceneReference(storyId, sceneAnalysis.sceneName, sceneAnalysis.sceneDescription);
+                await this.generateSceneIllustration(storyId, situation);
+            }
+            else {
+                await this.generateStoryImage(storyId, story.turnNumber, sceneAnalysis.imageCaption, sceneAnalysis.sceneName, sceneAnalysis.sceneDescription, sceneAnalysis.characterNames);
+            }
+        }
+        catch (error) {
+            console.error('Scene illustration error:', error);
+        }
+    }
+    async generateSceneReference(storyId, sceneName, sceneDescription) {
+        try {
+            console.log(`Generating scene reference: ${sceneName}`);
+            const storyInfo = this.storyStore.getStory(storyId);
+            if (!storyInfo || !storyInfo.artistAgentId) {
+                console.error(`Cannot generate scene reference: story ${storyId} has no artist agent`);
+                return;
+            }
+            const artistAgent = await this.agentStore.getAgent(storyInfo.artistAgentId);
+            if (!artistAgent) {
+                console.error(`Artist agent not found: ${storyInfo.artistAgentId}`);
+                return;
+            }
+            let storyArtifactService = this.getStoryArtifactService(storyId);
+            if (!storyArtifactService) {
+                console.error(`Story artifact service not found: ${storyId}`);
+                return;
+            }
+            const imageResult = await artistAgent.generateImage(sceneDescription, 1024, 1024, 'auto');
+            if (imageResult.error) {
+                return;
+            }
+            artistAgent.save();
+            const artifactId = imageResult.artifactId;
+            storyArtifactService.renameArtifact(artifactId, `Scene - ${sceneName}`);
+            storyArtifactService.updateArtifactDescription(artifactId, sceneDescription);
+            console.log(`Generated scene reference: ${sceneName} (${artifactId})`);
+        }
+        catch (error) {
+            console.error('Scene reference generation error:', error);
+        }
+    }
+    async generateStoryImage(storyId, turnNumber, imageCaption, sceneName, sceneDescription, characterNames) {
+        try {
+            console.log(`Generating story image for turn ${turnNumber}`);
+            const storyArtifactService = this.getStoryArtifactService(storyId);
+            const allArtifacts = storyArtifactService.listArtifacts();
+            const sceneArtifact = allArtifacts.find((a) => a.name === `Scene - ${sceneName}`);
+            if (!sceneArtifact) {
+                console.warn(`Scene not found: ${sceneName}`);
+                return;
+            }
+            const characterPortraitIds = [];
+            for (const charName of characterNames) {
+                const portrait = allArtifacts.find((a) => a.name === `Portrait - ${charName}`);
+                if (portrait) {
+                    characterPortraitIds.push(portrait.artifactId);
+                }
+                else {
+                    console.warn(`Portrait not found: ${charName}`);
+                }
+            }
+            const referenceImageIds = [sceneArtifact.artifactId, ...characterPortraitIds];
+            const storyInfo = this.storyStore.getStory(storyId);
+            if (!storyInfo || !storyInfo.artistAgentId) {
+                console.error(`Cannot generate story image: story ${storyId} has no artist agent`);
+                return;
+            }
+            const artistAgent = await this.agentStore.getAgent(storyInfo.artistAgentId);
+            if (!artistAgent) {
+                console.error(`Artist agent not found: ${storyInfo.artistAgentId}`);
+                return;
+            }
+            let quality = 'high';
+            let width = 1536;
+            const imageResult = await artistAgent.generateImage(sceneDescription, width, 1024, quality, referenceImageIds);
+            if (imageResult.error) {
+                return;
+            }
+            artistAgent.save();
+            const artifactId = imageResult.artifactId;
+            storyArtifactService.renameArtifact(artifactId, `Story image - ${turnNumber}`);
+            storyArtifactService.updateArtifactDescription(artifactId, imageCaption);
+            console.log(`Generated story image: ${imageCaption} (${artifactId})`);
+            try {
+                const room = await this.getStoryRoom(storyId);
+                const imgUrl = `/api/stories/${storyId}/artifacts/${artifactId}`;
+                const imageMarkdown = `![${imageCaption}](${imgUrl})`;
+                const imageMessage = new message_1.RoomMessage(imageCaption, app_types_1.MessageAction.SYSTEM, imageMarkdown);
+                room.addRoomMessage(imageMessage);
+                console.log(`Added story image message to room`);
+            }
+            catch (error) {
+                console.error('Error adding image message to room:', error);
+            }
+        }
+        catch (error) {
+            console.error('Story image generation error:', error);
+        }
+    }
+    async updateStorySituation(storyId, situation) {
+        const story = this.storyStore.getStory(storyId);
+        if (!story)
+            return;
+        const room = await this.getStoryRoom(storyId);
+        let progressChapter = situation.startsWith('PROGRESS');
+        if (progressChapter) {
+            if (story) {
+                story.declinedCharacters = [];
+                this.storyStore.updateStoryMetadata(storyId, story);
+            }
+            this.messageService.emitUpdate(storyId, {
+                type: 'suggestion',
+                suggestion: {
+                    type: 'progress_chapter',
+                    timestamp: Date.now()
+                }
+            });
+            return;
+        }
+        let agentCompactionThreshold = Number(process.env.AGENT_COMPACTION_THRESHOLD) || 150000;
+        await this.compactAgentHistories(room.getAgents(), agentCompactionThreshold);
+        let introduce = situation.startsWith('INTRODUCE:');
+        if (introduce) {
+            let newCharacterName = situation.substring(11).trim();
+            if (newCharacterName) {
+                const declinedCharacters = story?.declinedCharacters || [];
+                if (declinedCharacters.includes(newCharacterName)) {
+                    console.log(`Character ${newCharacterName} was declined, skipping prompt`);
+                    return;
+                }
+                this.messageService.emitUpdate(storyId, {
+                    type: 'suggestion',
+                    suggestion: {
+                        type: 'introduce_character',
+                        characterName: newCharacterName,
+                        timestamp: Date.now()
+                    }
+                });
+            }
+            return;
+        }
+        story.situation = situation;
+        this.storyStore.updateStoryMetadata(storyId, story);
+        console.log(`Updated story ${storyId} situation: ${situation}`);
+        this.generateSceneIllustration(storyId, situation).catch((error) => {
+            console.error('Illustration generation error:', error);
+        });
+    }
+    async generateStoryMarkdown(storyId) {
+        const story = this.storyStore.getStory(storyId);
+        if (!story) {
+            throw new Error('Story not found');
+        }
+        let markdown = `# ${story.name}\n\n`;
+        markdown += `**Scenario**: ${story.scenario}\n\n`;
+        markdown += `**Characters**:\n`;
+        for (const char of story.characters) {
+            const type = char.isControlledByHuman ? 'Human' : 'AI';
+            markdown += `- ${char.name} (${type}): ${char.description}\n`;
+        }
+        markdown += `\n---\n\n`;
+        const chapters = this.storyStore.listChapters(storyId);
+        for (const chapter of chapters) {
+            markdown += `## Chapter ${chapter.chapterNum}: ${chapter.chapterTitle}\n\n`;
+            const messages = await this.storyStore.getChapterContent(storyId, chapter.chapterNum);
+            markdown += this.formatMessagesToMarkdown(messages);
+            markdown += `\n---\n\n`;
+        }
+        const room = await this.getStoryRoom(storyId);
+        if (room) {
+            markdown += `## Current Chapter\n\n`;
+            markdown += this.formatMessagesToMarkdown(room.getLatestRoomMessages(0, true));
+        }
+        markdown = this.processImageMarkdown(markdown, 600);
+        return markdown;
+    }
+    async exportStoryData(storyId) {
+        const story = this.storyStore.getStory(storyId);
+        if (!story) {
+            throw new Error('Story not found');
+        }
+        const userStoriesDir = path.join(this.configService.getUserDataDir(), 'stories');
+        const storyFolderPath = path.join(userStoriesDir, storyId);
+        if (!fs.existsSync(storyFolderPath)) {
+            throw new Error('Story folder not found on disk');
+        }
+        const archive = (0, archiver_1.default)('zip', {
+            zlib: { level: 9 },
+        });
+        archive.directory(storyFolderPath, false);
+        archive.finalize();
+        const sanitizedName = story.name.replace(/[^a-z0-9]/gi, '_');
+        const filename = `${sanitizedName}.zip`;
+        return {
+            stream: archive,
+            filename: filename,
+        };
+    }
+    formatMessagesToMarkdown(messages) {
+        let text = '';
+        for (const msg of messages) {
+            if (msg.situation) {
+                text += `### ${msg.situation}\n\n`;
+            }
+            text += `**${msg.sender}**: ${msg.content}\n\n`;
+        }
+        return text;
+    }
+    processImageMarkdown(markdown, maxWidth = 600) {
+        markdown = markdown.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (match, alt, url) => {
+            return `<img src="${url}" alt="${alt}" style="max-width: ${maxWidth}px; width: 100%; height: auto; display: block; margin: 1rem auto;" />`;
+        });
+        return markdown;
+    }
+    async updateStoryCost(storyId) {
+        try {
+            const storyInfo = this.storyStore.getStory(storyId);
+            if (!storyInfo || !storyInfo.roomId) {
+                console.warn(`Cannot update story cost: story ${storyId} not found or has no room`);
+                return;
+            }
+            const room = await this.roomStore.getRoom(storyInfo.roomId);
+            if (!room) {
+                console.warn(`Cannot update story cost: room ${storyInfo.roomId} not found`);
+                return;
+            }
+            let totalCost = 0;
+            let totalInputTokens = 0;
+            let totalOutputTokens = 0;
+            const agents = room.getAgents();
+            for (const agent of agents) {
+                totalCost += agent.totalCost || 0;
+                totalInputTokens += agent.totalInputTokens || 0;
+                totalOutputTokens += agent.totalOutputTokens || 0;
+            }
+            if (storyInfo.illustratorAgentId) {
+                const illustratorAgent = await this.agentStore.getAgent(storyInfo.illustratorAgentId);
+                if (illustratorAgent) {
+                    totalCost += illustratorAgent.totalCost || 0;
+                    totalInputTokens += illustratorAgent.totalInputTokens || 0;
+                    totalOutputTokens += illustratorAgent.totalOutputTokens || 0;
+                }
+                else {
+                    console.warn(`Illustrator agent not found: ${storyInfo.illustratorAgentId}`);
+                }
+            }
+            if (storyInfo.artistAgentId) {
+                const artistAgent = await this.agentStore.getAgent(storyInfo.artistAgentId);
+                if (artistAgent) {
+                    totalCost += artistAgent.totalCost || 0;
+                    totalInputTokens += artistAgent.totalInputTokens || 0;
+                    totalOutputTokens += artistAgent.totalOutputTokens || 0;
+                }
+                else {
+                    console.warn(`Artist agent not found: ${storyInfo.artistAgentId}`);
+                }
+            }
+            storyInfo.totalCost = totalCost;
+            storyInfo.totalInputTokens = totalInputTokens;
+            storyInfo.totalOutputTokens = totalOutputTokens;
+            this.storyStore.updateStoryMetadata(storyId, storyInfo);
+        }
+        catch (error) {
+            console.error(`Error updating story cost for ${storyId}:`, error);
+        }
+    }
+};
+exports.StoryService = StoryService;
+exports.StoryService = StoryService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [story_store_service_1.StoryStoreService,
+        agent_store_service_1.AgentStoreService,
+        room_store_service_1.RoomStoreService,
+        story_progress_service_1.StoryProgressService,
+        story_message_service_1.StoryMessageService,
+        configuration_service_1.ConfigurationService,
+        agent_factory_1.AgentFactory,
+        room_factory_1.RoomFactory])
+], StoryService);