briyah 1.1.5 → 1.1.6

package/dist-sdk/server/src/story/story-store.service.js

@@ -345,6 +345,44 @@ let StoryStoreService = class StoryStoreService {
             return false;
         }
     }
+    restoreRoomFilesFromChapter(storyId, chapterIndex) {
+        const storyFolder = path.join(this.storiesDir, storyId);
+        const chapterFolder = path.join(storyFolder, 'chapters', `chapter_${chapterIndex}`);
+        try {
+            const story = this.getStory(storyId);
+            if (!story || !story.roomId) {
+                logger_1.logger.error(`Cannot restore room files: story ${storyId} has no room ID`);
+                return -1;
+            }
+            if (!fs.existsSync(chapterFolder)) {
+                logger_1.logger.warn(`Chapter ${chapterIndex} folder not found for story ${storyId}`);
+                return -1;
+            }
+            const roomFolder = path.join(storyFolder, 'rooms', story.roomId);
+            if (!fs.existsSync(roomFolder)) {
+                fs.mkdirSync(roomFolder, { recursive: true });
+            }
+            const items = fs.readdirSync(chapterFolder);
+            let restored = 0;
+            for (const item of items) {
+                if (item === 'metadata.json' || item === 'agents') {
+                    continue;
+                }
+                const sourcePath = path.join(chapterFolder, item);
+                const targetPath = path.join(roomFolder, item);
+                if (fs.statSync(sourcePath).isFile()) {
+                    fs.copyFileSync(sourcePath, targetPath);
+                    restored++;
+                }
+            }
+            logger_1.logger.log(`Restored ${restored} room files from chapter ${chapterIndex} for story ${storyId}`);
+            return restored;
+        }
+        catch (error) {
+            logger_1.logger.error(`Error restoring room files from chapter ${chapterIndex} for story ${storyId}:`, error);
+            return -1;
+        }
+    }
     async restoreAgentsFromChapter(storyId, chapterIndex, agentStore) {
         const storyFolder = path.join(this.storiesDir, storyId);
         const chapterAgentsFolder = path.join(storyFolder, 'chapters', `chapter_${chapterIndex}`, 'agents');

package/dist-sdk/server/src/story/story.service.d.ts

@@ -36,7 +36,7 @@ export declare class StoryService {
     private getStoryRoom;
     private ensureStoryLoaded;
     getStoryInfo(storyId: string): Promise<StoryInfo | null>;
-    createStory(name: string, idea: string, userCharacterDesc: string, otherCharactersDesc: string, storyModel?: string, isImport?: boolean, imageModelName?: string): Promise<StoryInfo>;
+    createStory(name: string, idea: string, userCharacterDesc: string, otherCharactersDesc: string, illustrateStory: boolean, storyModel?: string, isImport?: boolean, imageModelName?: string, imageEditModelName?: string): Promise<StoryInfo>;
     private createStoryAsync;
     generateCharacterPortraits(storyInfo: StoryInfo, room: Room): Promise<void>[];
     generateOpeningSceneImage(storyInfo: StoryInfo, room: Room): Promise<{
@@ -56,6 +56,7 @@ export declare class StoryService {
     savePlotPlan(storyId: string, content: string): Promise<void>;
     publishArtifact(storyId: string, name: string, creator: string, body: string, viewers: string[]): Promise<void>;
     respondToStory(storyId: string, content: string): Promise<void>;
+    interruptStory(storyId: string): Promise<void>;
     introduceCharacter(storyId: string, characterName: string, characterDescription: string, storyModel?: string, fromNarratorSuggestion?: boolean): Promise<void>;
     declineCharacter(storyId: string, characterName: string): Promise<void>;
     deleteCharacter(storyId: string, characterName: string): Promise<void>;
@@ -70,6 +71,7 @@ export declare class StoryService {
     progressStoryToNextChapter(storyId: string): Promise<{
         chapterIndex: number;
     }>;
+    revertStoryChapter(storyId: string): Promise<void>;
     private progressStoryToNextChapterAsync;
     private generateOpeningScene;
     private compactAgentHistories;
@@ -79,6 +81,7 @@ export declare class StoryService {
     private getImageModelConfig;
     private createArtistAgent;
     private generateCharacterPortrait;
+    private updateCharacterPortrait;
     private generateSceneIllustration;
     private generateSceneReference;
     private generateStoryImage;

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

@@ -191,6 +191,7 @@ let StoryService = class StoryService {
                 return {
                     service: modelConfig.service,
                     model: modelConfig.model,
+                    smallModel: modelConfig.small_model,
                 };
             }
             logger_1.logger.warn(`Story model "${storyModel}" not found in story_models.json`);
@@ -240,6 +241,21 @@ let StoryService = class StoryService {
             room.setOnSituationUpdate((situation) => {
                 this.updateStorySituation(storyId, situation);
             });
+            room.setOnModeratorResponse((message) => {
+                if (message.updatePortrait?.length) {
+                    for (const nickname of message.updatePortrait) {
+                        const characterAgent = room
+                            .getAgents()
+                            .find((a) => a.agentNickname === nickname);
+                        if (characterAgent) {
+                            this.updateCharacterPortrait(room, characterAgent, storyId).catch((e) => logger_1.logger.error(`Error updating portrait for ${nickname}:`, e));
+                        }
+                        else {
+                            logger_1.logger.warn(`update_portrait: agent "${nickname}" not found in room`);
+                        }
+                    }
+                }
+            });
             if (story.situation) {
                 room.setSituation(story.situation);
             }
@@ -249,7 +265,7 @@ let StoryService = class StoryService {
     async getStoryInfo(storyId) {
         return this.storyStore.getStory(storyId);
     }
-    async createStory(name, idea, userCharacterDesc, otherCharactersDesc, storyModel, isImport = false, imageModelName) {
+    async createStory(name, idea, userCharacterDesc, otherCharactersDesc, illustrateStory, storyModel, isImport = false, imageModelName, imageEditModelName) {
         if (!name || name.trim().length === 0) {
             throw new Error('Story name is required');
         }
@@ -280,7 +296,18 @@ let StoryService = class StoryService {
             moderator.markupRate = 0;
             moderator.save();
             logger_1.logger.log(`Created moderator agent: ${moderator.agentName}`);
+            if (illustrateStory) {
+                if (!imageModelName)
+                    imageModelName = process.env.DEFAULT_IMAGE_MODEL;
+                if (!imageEditModelName)
+                    imageEditModelName = process.env.DEFAULT_IMAGE_EDIT_MODEL;
+            }
+            else {
+                imageModelName = undefined;
+                imageEditModelName = undefined;
+            }
             const artist = this.createArtistAgent(storyInfo.id, storyAgentsDir, storyArtifactService, imageModelName);
+            const artistEdit = this.createArtistAgent(storyInfo.id, storyAgentsDir, storyArtifactService, imageEditModelName, 'Artist (Edit)');
             let illustrator = null;
             if (artist) {
                 illustrator = this.agentFactory.createAgent(process.env.MODERATOR_AI_SERVICE || aiServiceName, `${storyTitle} - Illustrator`, 'Illustrator', 'Visual artist for generating scene illustrations', 'illustrator', process.env.MODERATOR_AI_MODEL || aiModelName, storyAgentsDir, storyArtifactService);
@@ -295,6 +322,7 @@ let StoryService = class StoryService {
             narrator.allowSearch = true;
             narrator.promptCacheTTL = 60;
             narrator.ownerRoomId = storyInfo.id;
+            narrator.smallModelName = modelConfig.smallModel;
             narrator.save();
             logger_1.logger.log(`Created narrator agent: ${narrator.agentName}`);
             narrator.disableMarkup = true;
@@ -348,6 +376,7 @@ let StoryService = class StoryService {
                 userAgent = this.agentFactory.createAgent(aiServiceName, `${name} - ${userNickname}`, userNickname, userCharacterInfo.description || userCharacterDesc, 'character', aiModelName, storyAgentsDir, storyArtifactService);
                 userAgent.isControlledByHuman = true;
                 userAgent.ownerRoomId = storyInfo.id;
+                userAgent.smallModelName = modelConfig.smallModel;
                 userAgent.save();
                 logger_1.logger.log(`Created human-controlled character agent: ${userCharacterName}`);
                 userAgent.disableMarkup = true;
@@ -366,6 +395,7 @@ let StoryService = class StoryService {
                     const agent = this.agentFactory.createAgent(aiServiceName, `${name} - ${characterNickname}`, characterNickname, charInfo.description, 'character', aiModelName, storyAgentsDir, storyArtifactService);
                     agent.promptCacheTTL = 60;
                     agent.ownerRoomId = storyInfo.id;
+                    agent.smallModelName = modelConfig.smallModel;
                     agent.save();
                     logger_1.logger.log(`Created character agent: ${charInfo.name}`);
                     agent.disableMarkup = true;
@@ -409,11 +439,28 @@ let StoryService = class StoryService {
             room.setOnSituationUpdate((situation) => {
                 this.updateStorySituation(storyInfo.id, situation);
             });
+            room.setOnModeratorResponse((message) => {
+                if (message.updatePortrait?.length) {
+                    for (const nickname of message.updatePortrait) {
+                        const characterAgent = room
+                            .getAgents()
+                            .find((a) => a.agentNickname === nickname);
+                        if (characterAgent) {
+                            this.updateCharacterPortrait(room, characterAgent, storyInfo.id).catch((e) => logger_1.logger.error(`Error updating portrait for ${nickname}:`, e));
+                        }
+                        else {
+                            logger_1.logger.warn(`update_portrait: agent "${nickname}" not found in room`);
+                        }
+                    }
+                }
+            });
             storyInfo.roomId = roomId;
             storyInfo.moderatorAgentId = moderator.id;
             storyInfo.illustratorAgentId = illustrator?.id;
             storyInfo.artistAgentId = artist?.id;
+            storyInfo.artistEditAgentId = artistEdit?.id;
             storyInfo.imageModelName = imageModelName;
+            storyInfo.imageEditModelName = imageEditModelName;
             if (userAgent) {
                 storyInfo.userAgentId = userAgent.id;
             }
@@ -936,6 +983,10 @@ let StoryService = class StoryService {
         const responseMessage = new message_1.RoomMessage(humanAgent.agentNickname, app_types_1.MessageAction.MODERATE, content, [], null);
         room.addPendingMessage(responseMessage);
     }
+    async interruptStory(storyId) {
+        const room = await this.getStoryRoom(storyId);
+        room.interrupt();
+    }
     async introduceCharacter(storyId, characterName, characterDescription, storyModel, fromNarratorSuggestion) {
         const room = await this.getStoryRoom(storyId);
         if (!characterName)
@@ -970,6 +1021,7 @@ let StoryService = class StoryService {
         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.smallModelName = modelConfig.smallModel;
         characterAgent.save();
         room.arrive(characterAgent);
         const introducedCharArtifacts = room.getArtifacts();
@@ -1238,6 +1290,49 @@ let StoryService = class StoryService {
             throw err;
         }
     }
+    async revertStoryChapter(storyId) {
+        const story = this.storyStore.getStory(storyId);
+        if (!story || !story.roomId) {
+            throw new errors_1.NotFoundError('Story not found');
+        }
+        const room = await this.getStoryRoom(storyId);
+        if (!room) {
+            throw new errors_1.NotFoundError('Story room not found');
+        }
+        if (this.chaptersInProgress.has(storyId)) {
+            throw new errors_1.OperationFailedError('Chapter progression is in progress; cannot revert');
+        }
+        const chapters = this.storyStore.listChapters(storyId);
+        if (chapters.length === 0) {
+            throw new errors_1.OperationFailedError('No previous chapter to revert to');
+        }
+        const liveMessages = room.getLatestRoomMessages(0, true);
+        const nonOpening = liveMessages.filter((m) => m.sender !== 'Opening Scene' || m.action !== app_types_1.MessageAction.SYSTEM);
+        if (nonOpening.length > 0) {
+            throw new errors_1.OperationFailedError('Cannot revert: chapter has progressed past the opening scene');
+        }
+        const targetChapter = Math.max(...chapters.map((c) => c.chapterNum));
+        await this.storyStore.restoreAgentsFromChapter(storyId, targetChapter, this.agentStore);
+        const restoredCount = this.storyStore.restoreRoomFilesFromChapter(storyId, targetChapter);
+        if (restoredCount < 0) {
+            throw new errors_1.OperationFailedError(`Failed to restore room files from chapter ${targetChapter}`);
+        }
+        const storageDir = room.getStorageDir();
+        const messagesPath = path.join(storageDir, story.roomId, 'messages');
+        const restoredMessages = await this.roomStore.readRoomMessagesFromFileAsync(messagesPath);
+        room.setRoomMessages(restoredMessages || []);
+        const restoredArtifacts = this.roomStore.loadArtifactFiles(story.roomId, storageDir);
+        room.setArtifacts(restoredArtifacts);
+        const humanAgent = room.getAgents().find((a) => a.isControlledByHuman);
+        if (humanAgent) {
+            room.setCurrentSpeaker(humanAgent.agentNickname);
+        }
+        const deleted = this.storyStore.deleteChapter(storyId, targetChapter);
+        if (!deleted) {
+            logger_1.logger.warn(`Reverted chapter ${targetChapter} for story ${storyId} but failed to delete backup directory`);
+        }
+        logger_1.logger.log(`Reverted story ${storyId} to chapter ${targetChapter} (${restoredMessages?.length ?? 0} messages, ${restoredArtifacts.length} artifacts)`);
+    }
     async progressStoryToNextChapterAsync(storyId) {
         let room = null;
         let agents = [];
@@ -1322,12 +1417,12 @@ let StoryService = class StoryService {
         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();
+        const previousAllowSearch = narrator.allowSearch;
+        narrator.allowSearch = true;
         try {
-            const progressPlotResponse = await narrator.preparedPrompt('progress_plot', {
+            const progressPlotResponse = await narrator.withSmallModel(() => narrator.preparedPrompt('progress_plot', {
                 currentPlotPlan: currentPlotPlan,
-                formattedHistory: formattedHistory,
-            }, false);
+            }, false));
             if (progressPlotResponse) {
                 const cleanedPlotPlan = this.extractMarkdownContent(progressPlotResponse);
                 room.publishArtifact('Plot Plan', narrator.agentNickname, cleanedPlotPlan, [
@@ -1340,6 +1435,9 @@ let StoryService = class StoryService {
         catch (error) {
             logger_1.logger.error(`Error updating plot plan:`, error);
         }
+        finally {
+            narrator.allowSearch = previousAllowSearch;
+        }
         return '';
     }
     async updateCharacterProfiles(room, characterAgents, plotPlan = '') {
@@ -1348,21 +1446,22 @@ let StoryService = class StoryService {
             try {
                 const profileArtifact = artifacts.find((a) => a.name === `Character Profile - ${character.agentNickname}`);
                 let currentProfile = profileArtifact ? profileArtifact.body : null;
-                let formattedHistory = character.getFormattedMessages(0);
+                let formattedHistory = [];
+                const hasNativeHistory = (character.history?.length ?? 0) > 0;
+                if (!hasNativeHistory) {
+                    formattedHistory = room
+                        .getLatestRoomMessages(0, true)
+                        .map((m) => `${m.sender}: ${m.content}\n`);
+                }
                 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', {
+                const progressCharacterResponse = await character.withSmallModel(() => character.preparedPrompt('progress_character', {
                     agentName: character.agentNickname,
                     currentProfile: currentProfile,
                     formattedHistory: formattedHistory,
                     plotPlan,
-                }, false);
+                }, false));
                 if (progressCharacterResponse.description) {
                     character.description = progressCharacterResponse.description;
                     character.save();
@@ -1375,37 +1474,30 @@ let StoryService = class StoryService {
         });
         await Promise.all(updatePromises);
         logger_1.logger.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) {
-                    logger_1.logger.error('Could not extract story ID from room path');
-                    return { character: characterAgent.agentNickname, success: false };
+        const pathParts = room.getStorageDir().split(path.sep);
+        const storiesIndex = pathParts.findIndex((p) => p === 'stories');
+        const storyId = storiesIndex >= 0 ? pathParts[storiesIndex + 1] : null;
+        if (!storyId) {
+            logger_1.logger.error('Could not extract story ID from room path; skipping portrait updates');
+        }
+        else {
+            const portraitPromises = characterAgents.map(async (characterAgent) => {
+                try {
+                    const artifactId = await this.updateCharacterPortrait(room, characterAgent, storyId);
+                    return {
+                        character: characterAgent.agentNickname,
+                        success: !!artifactId,
+                        artifactId,
+                    };
                 }
-                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);
-                    logger_1.logger.log(`Deleted old portrait for ${characterAgent.agentName}`);
+                catch (error) {
+                    logger_1.logger.error(`Error updating portrait for ${characterAgent.agentName}:`, error);
+                    return { character: characterAgent.agentNickname, success: false, error };
                 }
-                const artifactId = await this.generateCharacterPortrait(room, characterAgent, storyId);
-                return {
-                    character: characterAgent.agentNickname,
-                    success: !!artifactId,
-                    artifactId,
-                };
-            }
-            catch (error) {
-                logger_1.logger.error(`Error regenerating portrait for ${characterAgent.agentName}:`, error);
-                return { character: characterAgent.agentNickname, success: false, error };
-            }
-        });
-        await Promise.all(portraitPromises);
-        logger_1.logger.log(`Regenerated portraits for ${characterAgents.length} characters`);
+            });
+            await Promise.all(portraitPromises);
+            logger_1.logger.log(`Updated portraits for ${characterAgents.length} characters`);
+        }
     }
     getImageModelConfig(modelName) {
         try {
@@ -1423,23 +1515,32 @@ let StoryService = class StoryService {
                 logger_1.logger.log(`Images disabled: selected "${modelName}"`);
                 return null;
             }
-            return { service: modelConfig.service, model: modelConfig.model };
+            return {
+                service: modelConfig.service,
+                model: modelConfig.model,
+                imageProperties: modelConfig.imageProperties,
+                centsPerImage: modelConfig.centsPerImage,
+            };
         }
         catch (error) {
             logger_1.logger.error('Error loading image model config:', error);
             return null;
         }
     }
-    createArtistAgent(storyId, storyAgentsDir, storyArtifactService, imageModelName) {
+    createArtistAgent(storyId, storyAgentsDir, storyArtifactService, imageModelName, nickname = 'Artist') {
         const storyInfo = this.storyStore.getStory(storyId);
         const imageConfig = this.getImageModelConfig(imageModelName);
         if (!imageConfig) {
-            logger_1.logger.log('Artist agent creation skipped: images disabled');
+            logger_1.logger.log(`Artist agent creation skipped (${nickname}): images disabled`);
             return null;
         }
-        const artistAgent = this.agentFactory.createAgent(imageConfig.service, `${storyInfo.name} - Artist`, 'Artist', 'AI artist for generating character portraits and scene illustrations', 'default', imageConfig.model, storyAgentsDir, storyArtifactService);
+        const artistAgent = this.agentFactory.createAgent(imageConfig.service, `${storyInfo.name} - ${nickname}`, nickname, 'AI artist for generating character portraits and scene illustrations', 'default', imageConfig.model, storyAgentsDir, storyArtifactService);
         artistAgent.maxHistoryMessages = 10;
         artistAgent.promptCacheTTL = 0;
+        artistAgent.imageProperties = {
+            ...(imageConfig?.imageProperties ?? {}),
+            ...(imageConfig?.centsPerImage != null ? { centsPerImage: imageConfig.centsPerImage } : {}),
+        };
         artistAgent.save();
         logger_1.logger.log(`Created artist agent: ${artistAgent.agentName} (${imageConfig.service}/${imageConfig.model})`);
         return artistAgent;
@@ -1456,11 +1557,13 @@ let StoryService = class StoryService {
                 logger_1.logger.warn(`No profile for ${characterAgent.agentNickname}, skipping portrait`);
                 return null;
             }
+            const storyArtifactService = this.getStoryArtifactService(storyId);
             const artistAgent = await this.agentStore.getAgent(storyInfo.artistAgentId);
             if (!artistAgent) {
                 logger_1.logger.warn(`Artist agent not found: ${storyInfo.artistAgentId}`);
                 return null;
             }
+            artistAgent.artifactService = storyArtifactService;
             const visualDescription = await characterAgent.preparedPrompt('describe_character', {
                 characterName: characterAgent.agentNickname,
                 characterProfile: characterDescription,
@@ -1470,13 +1573,12 @@ let StoryService = class StoryService {
                 logger_1.logger.warn(`Failed to generate visual description for ${characterAgent.agentNickname}`);
                 return null;
             }
-            const imageResult = await artistAgent.generateImage(visualDescription, 1024, 1536, 'high');
+            const imageResult = await artistAgent.generateImage(visualDescription);
             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);
             logger_1.logger.log(`Generated portrait for ${characterAgent.agentNickname}: ${artifactId}`);
@@ -1487,7 +1589,66 @@ let StoryService = class StoryService {
             return null;
         }
     }
-    async generateSceneIllustration(storyId, situation) {
+    async updateCharacterPortrait(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) {
+                logger_1.logger.warn(`No profile for ${characterAgent.agentNickname}, skipping portrait update`);
+                return null;
+            }
+            const storyArtifactService = this.getStoryArtifactService(storyId);
+            if (!storyInfo.artistEditAgentId) {
+                logger_1.logger.warn(`No edit artist configured for story ${storyId}, skipping portrait update`);
+                return null;
+            }
+            const artistEditAgent = await this.agentStore.getAgent(storyInfo.artistEditAgentId);
+            if (!artistEditAgent) {
+                logger_1.logger.warn(`Edit artist agent not found: ${storyInfo.artistEditAgentId}`);
+                return null;
+            }
+            artistEditAgent.artifactService = storyArtifactService;
+            const portraitName = `Portrait - ${characterAgent.agentNickname}`;
+            const existingPortrait = storyArtifactService
+                .listArtifacts()
+                .find((a) => a.name === portraitName);
+            if (!existingPortrait) {
+                logger_1.logger.warn(`No existing portrait for ${characterAgent.agentNickname}, cannot update`);
+                return null;
+            }
+            const visualDescription = await characterAgent.preparedPrompt('update_portrait', {
+                characterName: characterAgent.agentNickname,
+                characterProfile: characterDescription,
+                scenario: scenario,
+            }, false);
+            if (!visualDescription || typeof visualDescription !== 'string') {
+                logger_1.logger.warn(`Failed to generate update description for ${characterAgent.agentNickname}`);
+                return null;
+            }
+            const imageResult = await artistEditAgent.editImage(visualDescription, [
+                existingPortrait.artifactId,
+            ]);
+            if (imageResult.error) {
+                return null;
+            }
+            storyArtifactService.deleteArtifact(existingPortrait.artifactId);
+            artistEditAgent.save();
+            const artifactId = imageResult.artifactId;
+            storyArtifactService.renameArtifact(artifactId, portraitName);
+            storyArtifactService.updateArtifactDescription(artifactId, visualDescription);
+            logger_1.logger.log(`Updated portrait for ${characterAgent.agentNickname}: ${artifactId}`);
+            return artifactId;
+        }
+        catch (error) {
+            logger_1.logger.error(`Error updating portrait for ${characterAgent.agentNickname}:`, error);
+            return null;
+        }
+    }
+    async generateSceneIllustration(storyId, situation, allowReference = true) {
         try {
             const story = this.storyStore.getStory(storyId);
             if (!story?.illustratorAgentId) {
@@ -1529,8 +1690,12 @@ let StoryService = class StoryService {
                 return;
             }
             if (sceneAnalysis.isReference) {
+                if (!allowReference) {
+                    logger_1.logger.warn(`Illustrator requested another reference (${sceneAnalysis.sceneName}) after one was just created; skipping to avoid loop`);
+                    return;
+                }
                 await this.generateSceneReference(storyId, sceneAnalysis.sceneName, sceneAnalysis.sceneDescription);
-                await this.generateSceneIllustration(storyId, situation);
+                await this.generateSceneIllustration(storyId, situation, false);
             }
             else {
                 await this.generateStoryImage(storyId, story.turnNumber, sceneAnalysis.imageCaption, sceneAnalysis.sceneName, sceneAnalysis.sceneDescription, sceneAnalysis.characterNames);
@@ -1553,12 +1718,13 @@ let StoryService = class StoryService {
                 logger_1.logger.error(`Artist agent not found: ${storyInfo.artistAgentId}`);
                 return;
             }
-            let storyArtifactService = this.getStoryArtifactService(storyId);
+            const storyArtifactService = this.getStoryArtifactService(storyId);
             if (!storyArtifactService) {
                 logger_1.logger.error(`Story artifact service not found: ${storyId}`);
                 return;
             }
-            const imageResult = await artistAgent.generateImage(sceneDescription, 1024, 1024, 'auto');
+            artistAgent.artifactService = storyArtifactService;
+            const imageResult = await artistAgent.generateImage(sceneDescription);
             if (imageResult.error) {
                 return;
             }
@@ -1603,9 +1769,16 @@ let StoryService = class StoryService {
                 logger_1.logger.error(`Artist agent not found: ${storyInfo.artistAgentId}`);
                 return;
             }
-            let quality = 'high';
-            let width = 1536;
-            const imageResult = await artistAgent.generateImage(sceneDescription, width, 1024, quality, referenceImageIds);
+            artistAgent.artifactService = storyArtifactService;
+            const editAgent = storyInfo.artistEditAgentId
+                ? await this.agentStore.getAgent(storyInfo.artistEditAgentId)
+                : null;
+            if (editAgent) {
+                editAgent.artifactService = storyArtifactService;
+            }
+            const imageResult = referenceImageIds?.length && editAgent
+                ? await editAgent.editImage(sceneDescription, referenceImageIds)
+                : await artistAgent.generateImage(sceneDescription);
             if (imageResult.error) {
                 return;
             }
@@ -1654,6 +1827,11 @@ let StoryService = class StoryService {
         if (introduce) {
             let newCharacterName = situation.substring(11).trim();
             if (newCharacterName) {
+                const existingAgent = room.getAgents().find((a) => room.checkAgentNicknameMatch(a.agentNickname, newCharacterName));
+                if (existingAgent) {
+                    logger_1.logger.log(`INTRODUCE: ${newCharacterName} ignored — character already in story`);
+                    return;
+                }
                 const declinedCharacters = story?.declinedCharacters || [];
                 if (declinedCharacters.includes(newCharacterName)) {
                     logger_1.logger.log(`Character ${newCharacterName} was declined, skipping prompt`);

package/dist-sdk/shared/types/app.types.d.ts

@@ -101,12 +101,27 @@ export interface ModelInfo {
     description: string;
     model: string;
     service: string;
+    type?: string;
 }
 export interface StoryModelDefaults {
     selectedStoryModel: string;
     selectedImageModel: string;
+    selectedImageEditModel: string;
     enforceDefaultModels: boolean;
 }
+export interface StoryModelEntry {
+    name: string;
+    description: string;
+    service: string;
+    model: string;
+    small_model?: string;
+    cost: string;
+}
+export interface StoryModelConfig {
+    service: string;
+    model: string;
+    smallModel?: string;
+}
 export type PromptScope = 'common' | 'user';
 export interface PromptFolder {
     name: string;
@@ -234,8 +249,10 @@ export interface StoryInfo {
     moderatorAgentId: string;
     illustratorAgentId?: string;
     artistAgentId?: string;
+    artistEditAgentId?: string;
     userAgentId?: string;
     imageModelName?: string;
+    imageEditModelName?: string;
     isImport: boolean;
     totalCost: number;
     totalInputTokens: number;

package/docs/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJx1jc0KgzAQhN9lzrGa0ErJO/TSq3gIutbQmEA2niTvXtI/pNDTwM63822IISSG7lrV9AKRJkdDssEz9IZWNSW8WQgaF2I2N4LA3foRWp1agTU6aFifKE5mIK7f1GFOi4PA4AwzNBKPVXmrvmgpZ+vGSB66k/Io+yxQcue8hrD8eqU6f7zPdeJ6h/0Vvw455wf4B1Aw"
+window.hierarchyData = "eJx1jTsKwzAQRO8ytRz/sBN0hzRpjQshr2MRWQKtUhndPSg/TCDVwM7beRuC95Ehh76tRoFAsyUdjXcMuaFvqxxOrQSJMzGrK0HgZtwE2XS9wD1YSBgXKcxKE5dv6rDE1UJAW8UMichTkd+KL5rLxdgpkIMc6vrYjUkg58558X799dbN6eN9rhOXO+yv+HVIKT0A/0RQQA=="