briyah 1.2.3 → 1.2.5

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

@@ -192,6 +192,8 @@ let StoryService = class StoryService {
                     service: modelConfig.service,
                     model: modelConfig.model,
                     smallModel: modelConfig.small_model,
+                    moderatorService: modelConfig.moderator_service || modelConfig.service,
+                    moderatorModel: modelConfig.moderator_model || modelConfig.model,
                 };
             }
             logger_1.logger.warn(`Story model "${storyModel}" not found in story_models.json`);
@@ -238,9 +240,7 @@ let StoryService = class StoryService {
             room.setOnError((error) => {
                 this.handleRoomError(storyId, error);
             });
-            room.setOnSituationUpdate((situation) => {
-                this.updateStorySituation(storyId, situation);
-            });
+            room.setOnSituationUpdate((situation, latestMessage) => this.updateStorySituation(storyId, situation, latestMessage));
             room.setOnModeratorResponse((message) => {
                 const portraitsToUpdate = message.changes?.update_portrait ?? [];
                 if (portraitsToUpdate.length) {
@@ -249,7 +249,7 @@ let StoryService = class StoryService {
                             .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));
+                            this.updateCharacterPortrait(room, characterAgent, storyId, true).catch((e) => logger_1.logger.error(`Error updating appearance for ${nickname}:`, e));
                         }
                         else {
                             logger_1.logger.warn(`changes.update_portrait: agent "${nickname}" not found in room`);
@@ -261,13 +261,16 @@ let StoryService = class StoryService {
             if (story.situation) {
                 room.setSituation(story.situation);
             }
+            if (story.situationTime) {
+                room.setSituationTime(story.situationTime);
+            }
         }
         return story;
     }
     async getStoryInfo(storyId) {
         return this.storyStore.getStory(storyId);
     }
-    async createStory(name, idea, userCharacterDesc, otherCharactersDesc, illustrateStory, storyModel, isImport = false, imageModelName, imageEditModelName) {
+    async createStory(name, idea, userCharacterDesc, otherCharactersDesc, illustrateStory, storyModel, isImport = false, imageModelName, skipDetailedPlot = false) {
         if (!name || name.trim().length === 0) {
             throw new Error('Story name is required');
         }
@@ -290,7 +293,7 @@ let StoryService = class StoryService {
             }
             if (!aiServiceName || !aiModelName)
                 throw new Error(`Failed to find model config for "${storyModel}"`);
-            let moderator = this.agentFactory.createAgent(process.env.MODERATOR_AI_SERVICE || aiServiceName, `${storyTitle} - Moderator`, 'Moderator', 'Story moderator responsible for message routing and conversation flow', 'story_moderator', process.env.MODERATOR_AI_MODEL || aiModelName, storyAgentsDir, storyArtifactService);
+            let moderator = this.agentFactory.createAgent(modelConfig.moderatorService, `${storyTitle} - Moderator`, 'Moderator', 'Story moderator responsible for message routing and conversation flow', 'story_moderator', modelConfig.moderatorModel, storyAgentsDir, storyArtifactService);
             moderator.maxHistoryMessages = 16;
             moderator.reasoningEffort = 'low';
             moderator.promptCacheTTL = 60;
@@ -301,18 +304,15 @@ let StoryService = class StoryService {
             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)');
+            const artist = this.createArtistAgent(storyInfo.id, storyAgentsDir, storyArtifactService, imageModelName, 'Artist', 'generation');
+            const artistEdit = this.createArtistAgent(storyInfo.id, storyAgentsDir, storyArtifactService, imageModelName, 'Artist (Edit)', 'editing');
             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);
+                illustrator = this.agentFactory.createAgent(modelConfig.moderatorService, `${storyTitle} - Illustrator`, 'Illustrator', 'Visual artist for generating scene illustrations', 'illustrator', modelConfig.moderatorModel, storyAgentsDir, storyArtifactService);
                 illustrator.reasoningEffort = 'low';
                 illustrator.maxHistoryMessages = 10;
                 illustrator.promptCacheTTL = 60;
@@ -370,6 +370,7 @@ let StoryService = class StoryService {
             storyInfo.aiService = aiServiceName;
             storyInfo.aiModel = aiModelName;
             storyInfo.isImport = isImport;
+            storyInfo.skipDetailedPlot = skipDetailedPlot;
             this.storyStore.updateStoryMetadata(storyInfo.id, storyInfo);
             this.storyStore.saveStoryCreationParameters(storyInfo.id, idea, userCharacterDesc, otherCharactersDesc);
             const userCharacterName = userCharacterInfo.name || 'Player';
@@ -439,9 +440,7 @@ let StoryService = class StoryService {
             room.setOnError((error) => {
                 this.handleRoomError(storyInfo.id, error);
             });
-            room.setOnSituationUpdate((situation) => {
-                this.updateStorySituation(storyInfo.id, situation);
-            });
+            room.setOnSituationUpdate((situation, latestMessage) => this.updateStorySituation(storyInfo.id, situation, latestMessage));
             room.setOnModeratorResponse((message) => {
                 const portraitsToUpdate = message.changes?.update_portrait ?? [];
                 if (portraitsToUpdate.length) {
@@ -465,7 +464,6 @@ let StoryService = class StoryService {
             storyInfo.artistAgentId = artist?.id;
             storyInfo.artistEditAgentId = artistEdit?.id;
             storyInfo.imageModelName = imageModelName;
-            storyInfo.imageEditModelName = imageEditModelName;
             if (userAgent) {
                 storyInfo.userAgentId = userAgent.id;
             }
@@ -473,7 +471,7 @@ let StoryService = class StoryService {
             await this.updateStoryCost(storyInfo.id);
             room.ready();
             setImmediate(() => {
-                this.createStoryAsync(storyInfo.id, name, importedStoryText, isImport).catch((error) => {
+                this.createStoryAsync(storyInfo.id, name, importedStoryText, isImport, skipDetailedPlot).catch((error) => {
                     logger_1.logger.error('Error in async story creation:', error);
                     this.progressService.emitProgress(storyInfo.id, 'error', `Error: ${error.message}`);
                     this.progressService.cleanup(storyInfo.id);
@@ -492,11 +490,15 @@ let StoryService = class StoryService {
             throw error;
         }
     }
-    async createStoryAsync(storyId, name, importedStoryText, isImport) {
+    async createStoryAsync(storyId, name, importedStoryText, isImport, skipDetailedPlot = false) {
         try {
             const room = await this.getStoryRoom(storyId);
             const storyInfo = this.storyStore.getStory(storyId);
-            const plotPromptName = isImport ? 'import_plot' : 'create_plot';
+            const plotPromptName = isImport
+                ? 'import_plot'
+                : skipDetailedPlot
+                    ? 'create_simple_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...');
@@ -549,7 +551,7 @@ let StoryService = class StoryService {
                         room.publishArtifact(`Character Profile - ${userAgent.agentNickname}`, userAgent.agentNickname, response.character.character_profile, [narrator.agentNickname, userAgent.agentNickname]);
                         logger_1.logger.log(`Published character profile for ${userCharacter.name} (human-controlled)`);
                         if (response.character.inventory) {
-                            this.publishInventoryArtifact(room, userAgent.agentNickname, response.character.inventory);
+                            this.storeCharacterInventory(room, userAgent.agentNickname, response.character.inventory);
                         }
                         this.progressService.emitProgress(storyInfo.id, 'profiles', `Finished creating character profile for ${userCharacter.name}`);
                     }
@@ -588,7 +590,7 @@ let StoryService = class StoryService {
                         room.publishArtifact(`Character Profile - ${agent.agentNickname}`, agent.agentNickname, response.character.character_profile, [agent.agentNickname]);
                         logger_1.logger.log(`Published character profile for ${charInfo.name}`);
                         if (response.character.inventory) {
-                            this.publishInventoryArtifact(room, agent.agentNickname, response.character.inventory);
+                            this.storeCharacterInventory(room, agent.agentNickname, response.character.inventory);
                         }
                         this.progressService.emitProgress(storyInfo.id, 'profiles', `Finished creating character profile for ${charInfo.name}`);
                     }
@@ -950,6 +952,21 @@ let StoryService = class StoryService {
         const artifactName = `Character Profile - ${characterName}`;
         this.publishArtifact(storyId, artifactName, characterName, content, []);
     }
+    async getCharacterInventory(storyId, characterName) {
+        try {
+            const room = await this.getStoryRoom(storyId);
+            const agent = room.getAgents().find((a) => a.agentNickname === characterName);
+            return agent?.privateContext ? agent.privateContext : null;
+        }
+        catch (error) {
+            logger_1.logger.error('Error getting character inventory:', error);
+            throw new Error(`Error getting character inventory: ${error.message}`);
+        }
+    }
+    async saveCharacterInventory(storyId, characterName, content) {
+        const room = await this.getStoryRoom(storyId);
+        this.storeCharacterInventory(room, characterName, content);
+    }
     async getPlotPlan(storyId) {
         const room = await this.getStoryRoom(storyId);
         const artifacts = room.getArtifacts();
@@ -998,7 +1015,7 @@ let StoryService = class StoryService {
         const room = await this.getStoryRoom(storyId);
         room.interrupt();
     }
-    async introduceCharacter(storyId, characterName, characterDescription, storyModel, fromNarratorSuggestion) {
+    async introduceCharacter(storyId, characterName, characterDescription, storyModel, fromNarratorSuggestion, latestNarration) {
         const room = await this.getStoryRoom(storyId);
         if (!characterName)
             throw new Error('No character name provided');
@@ -1014,12 +1031,31 @@ let StoryService = class StoryService {
         }
         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;
+        let aiSmallModelName;
+        const explicitConfig = storyModel && storyModel.trim().length > 0
+            ? this.getStoryModelConfig(storyModel)
+            : null;
+        if (explicitConfig) {
+            aiServiceName = explicitConfig.service;
+            aiModelName = explicitConfig.model;
+            aiSmallModelName = explicitConfig.smallModel;
+        }
+        else {
+            const template = room.getAgents().find((a) => a.promptFolder === 'character') ??
+                room.getAgents().find((a) => a.promptFolder === 'narrator');
+            if (template) {
+                aiServiceName = template.serviceName;
+                aiModelName = template.modelName;
+                aiSmallModelName = template.smallModelName;
+            }
+            else {
+                const fallback = this.getStoryModelConfig(process.env.DEFAULT_STORY_MODEL);
+                if (fallback) {
+                    aiServiceName = fallback.service;
+                    aiModelName = fallback.model;
+                    aiSmallModelName = fallback.smallModel;
+                }
+            }
         }
         if (!aiServiceName || !aiModelName) {
             throw new Error('Invalid story model provided');
@@ -1032,13 +1068,13 @@ 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.smallModelName = aiSmallModelName;
         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);
+        await this.updateCharacterProfiles(room, [characterAgent], introducedCharPlotPlan, latestNarration);
         if (!story.characters) {
             story.characters = [];
         }
@@ -1054,14 +1090,20 @@ let StoryService = class StoryService {
             story.pendingSuggestion = undefined;
         }
         this.storyStore.updateStoryMetadata(storyId, story);
-        try {
-            const artifactId = await this.generateCharacterPortrait(room, characterAgent, storyId);
-            if (artifactId) {
-                logger_1.logger.log(`Generated portrait for newly introduced character: ${characterName}`);
+        const portraitName = `Portrait - ${characterAgent.agentNickname}`;
+        const portraitAlreadyExists = this.getStoryArtifactService(storyId)
+            .listArtifacts()
+            .some((a) => a.name === portraitName);
+        if (!portraitAlreadyExists) {
+            try {
+                const artifactId = await this.generateCharacterPortrait(room, characterAgent, storyId);
+                if (artifactId) {
+                    logger_1.logger.log(`Generated portrait for newly introduced character: ${characterName}`);
+                }
+            }
+            catch (error) {
+                logger_1.logger.error(`Error generating portrait for introduced character ${characterName}:`, error);
             }
-        }
-        catch (error) {
-            logger_1.logger.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}`));
@@ -1367,7 +1409,8 @@ let StoryService = class StoryService {
                 agent.save();
             }
             this.progressService.emitProgress(storyId, 'profiles', 'Updating plot plan and character profiles...');
-            const updatedPlotPlan = await this.updatePlotPlan(room, narrator);
+            const skipDetailedPlot = this.storyStore.getStory(storyId)?.skipDetailedPlot ?? false;
+            const updatedPlotPlan = await this.updatePlotPlan(room, narrator, skipDetailedPlot);
             await this.updateCharacterProfiles(room, characterAgents, updatedPlotPlan);
             await this.updateStoryCost(storyId);
             this.progressService.emitProgress(storyId, 'complete', 'Chapter progression complete!');
@@ -1425,14 +1468,14 @@ let StoryService = class StoryService {
         }
         return response.trim();
     }
-    async updatePlotPlan(room, narrator) {
+    async updatePlotPlan(room, narrator, skipDetailedPlot = false) {
         const artifacts = room.getArtifacts();
         const plotPlanArtifact = artifacts.find((a) => a.name === 'Plot Plan');
         const currentPlotPlan = plotPlanArtifact ? plotPlanArtifact.body : 'No plot plan found.';
         const previousAllowSearch = narrator.allowSearch;
         narrator.allowSearch = true;
         try {
-            const progressPlotResponse = await narrator.withSmallModel(() => narrator.preparedPrompt('progress_plot', {
+            const progressPlotResponse = await narrator.withSmallModel(() => narrator.preparedPrompt(skipDetailedPlot ? 'progress_simple_plot' : 'progress_plot', {
                 currentPlotPlan: currentPlotPlan,
             }, false));
             if (progressPlotResponse) {
@@ -1452,11 +1495,17 @@ let StoryService = class StoryService {
         }
         return '';
     }
-    publishInventoryArtifact(room, characterNickname, body) {
-        if (!body || !body.trim())
+    storeCharacterInventory(room, characterNickname, body) {
+        const agent = room
+            .getAgents()
+            .find((a) => a.agentNickname === characterNickname);
+        if (!agent) {
+            logger_1.logger.warn(`storeCharacterInventory: character "${characterNickname}" not found in room`);
             return;
-        room.publishArtifact(`${characterNickname} - Inventory`, characterNickname, body, [characterNickname, 'Narrator', 'Moderator']);
-        logger_1.logger.log(`Published inventory for ${characterNickname}`);
+        }
+        agent.privateContext = body ?? '';
+        agent.save();
+        logger_1.logger.log(`Stored inventory for ${characterNickname}`);
     }
     applyInventoryUpdates(room, moderatorMessage) {
         const updates = moderatorMessage.changes?.update_inventory ?? [];
@@ -1469,53 +1518,61 @@ let StoryService = class StoryService {
                 logger_1.logger.warn(`changes.update_inventory: skipping malformed entry: ${JSON.stringify(entry)}`);
                 continue;
             }
-            const characterAgent = room
-                .getAgents()
-                .find((a) => a.agentNickname === characterName);
-            if (!characterAgent) {
-                logger_1.logger.warn(`changes.update_inventory: character "${characterName}" not found in room`);
-                continue;
-            }
-            this.publishInventoryArtifact(room, characterName, inventory);
+            this.storeCharacterInventory(room, characterName, inventory);
         }
     }
-    async updateCharacterProfiles(room, characterAgents, plotPlan = '') {
+    async updateCharacterProfiles(room, characterAgents, plotPlan = '', latestNarration) {
         const artifacts = room.getArtifacts();
+        const characterRoster = room
+            .getAgents()
+            .filter((a) => a.promptFolder === 'character')
+            .map((a) => ({ name: a.agentNickname, description: a.description || '' }));
         const updatePromises = characterAgents.map(async (character) => {
             try {
                 const profileArtifact = artifacts.find((a) => a.name === `Character Profile - ${character.agentNickname}`);
-                let currentProfile = profileArtifact ? profileArtifact.body : null;
+                const currentProfile = profileArtifact ? profileArtifact.body : null;
                 let formattedHistory = [];
                 const hasNativeHistory = (character.history?.length ?? 0) > 0;
                 if (!hasNativeHistory) {
                     formattedHistory = room
                         .getLatestRoomMessages(0, true)
                         .map((m) => `${m.sender}: ${m.content}\n`);
+                    if (latestNarration) {
+                        formattedHistory.push(`${room.getRoomLeader()}: ${latestNarration}\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.`;
-                }
-                const progressCharacterResponse = await character.withSmallModel(() => character.preparedPrompt('progress_character', {
+                const profilePromptName = currentProfile
+                    ? 'progress_character'
+                    : 'introduce_character';
+                const progressCharacterResponse = await character.withSmallModel(() => character.preparedPrompt(profilePromptName, {
                     agentName: character.agentNickname,
                     currentProfile: currentProfile,
                     formattedHistory: formattedHistory,
                     plotPlan,
+                    otherCharacters: characterRoster.filter((c) => c.name !== character.agentNickname),
                 }, false));
+                if (progressCharacterResponse.no_changes ||
+                    !progressCharacterResponse.character_profile) {
+                    logger_1.logger.log(`No profile changes needed for ${character.agentNickname}; leaving profile unchanged`);
+                    return null;
+                }
                 if (progressCharacterResponse.description) {
                     character.description = progressCharacterResponse.description;
                     character.save();
                 }
                 room.publishArtifact(`Character Profile - ${character.agentNickname}`, character.agentNickname, progressCharacterResponse.character_profile, [character.agentNickname]);
                 if (progressCharacterResponse.inventory) {
-                    this.publishInventoryArtifact(room, character.agentNickname, progressCharacterResponse.inventory);
+                    this.storeCharacterInventory(room, character.agentNickname, progressCharacterResponse.inventory);
                 }
+                return character;
             }
             catch (error) {
                 logger_1.logger.error(`Error updating character profile for ${character.agentNickname}:`, error);
+                return null;
             }
         });
-        await Promise.all(updatePromises);
-        logger_1.logger.log(`Updated ${characterAgents.length} character profiles in parallel`);
+        const changedAgents = (await Promise.all(updatePromises)).filter((agent) => agent !== null);
+        logger_1.logger.log(`Updated ${changedAgents.length} of ${characterAgents.length} character profiles in parallel`);
         const pathParts = room.getStorageDir().split(path.sep);
         const storiesIndex = pathParts.findIndex((p) => p === 'stories');
         const storyId = storiesIndex >= 0 ? pathParts[storiesIndex + 1] : null;
@@ -1523,7 +1580,7 @@ let StoryService = class StoryService {
             logger_1.logger.error('Could not extract story ID from room path; skipping portrait updates');
         }
         else {
-            const portraitPromises = characterAgents.map(async (characterAgent) => {
+            const portraitPromises = changedAgents.map(async (characterAgent) => {
                 try {
                     const artifactId = await this.updateCharacterPortrait(room, characterAgent, storyId);
                     return {
@@ -1538,28 +1595,29 @@ let StoryService = class StoryService {
                 }
             });
             await Promise.all(portraitPromises);
-            logger_1.logger.log(`Updated portraits for ${characterAgents.length} characters`);
+            logger_1.logger.log(`Updated portraits for ${changedAgents.length} characters`);
         }
     }
-    getImageModelConfig(modelName) {
+    getImageModelConfig(modelName, variant = 'generation') {
         try {
             if (!modelName) {
                 return null;
             }
             const imageModelsPath = path.join(this.userPaths.getCommonConfigDir(), 'image_models.json');
             const imageModels = JSON.parse(fs.readFileSync(imageModelsPath, 'utf8'));
-            const modelConfig = imageModels.find((m) => m.name === modelName);
-            if (!modelConfig) {
+            const entry = imageModels.find((m) => m.name === modelName);
+            if (!entry) {
                 logger_1.logger.warn(`Image model not found: ${modelName}`);
                 return null;
             }
-            if (!modelConfig.service || !modelConfig.model) {
-                logger_1.logger.log(`Images disabled: selected "${modelName}"`);
+            const variantConfig = entry[variant];
+            if (!variantConfig || !variantConfig.service || !variantConfig.model) {
+                logger_1.logger.log(`No ${variant} model for "${modelName}" (images disabled)`);
                 return null;
             }
             return {
-                service: modelConfig.service,
-                model: modelConfig.model,
+                service: variantConfig.service,
+                model: variantConfig.model,
             };
         }
         catch (error) {
@@ -1571,15 +1629,22 @@ let StoryService = class StoryService {
         try {
             const imageModelsPath = path.join(this.userPaths.getCommonConfigDir(), 'image_models.json');
             const imageModels = JSON.parse(fs.readFileSync(imageModelsPath, 'utf8'));
-            const modelConfig = imageModels.find((m) => m.model === agent.modelName);
-            if (!modelConfig) {
+            const isEditAgent = (agent.agentNickname ?? '').toLowerCase().includes('edit');
+            const preferred = isEditAgent ? 'editing' : 'generation';
+            const fallback = isEditAgent ? 'generation' : 'editing';
+            const findVariant = (variant) => {
+                const entry = imageModels.find((m) => m[variant]?.model === agent.modelName);
+                return entry ? entry[variant] : null;
+            };
+            const variantConfig = findVariant(preferred) ?? findVariant(fallback);
+            if (!variantConfig) {
                 logger_1.logger.warn(`No image_models.json entry for "${agent.modelName}"; image generation may fail`);
                 return {};
             }
             return {
-                ...(modelConfig.imageProperties ?? {}),
-                ...(modelConfig.centsPerImage != null
-                    ? { centsPerImage: modelConfig.centsPerImage }
+                ...(variantConfig.imageProperties ?? {}),
+                ...(variantConfig.centsPerImage != null
+                    ? { centsPerImage: variantConfig.centsPerImage }
                     : {}),
             };
         }
@@ -1588,9 +1653,9 @@ let StoryService = class StoryService {
             return {};
         }
     }
-    createArtistAgent(storyId, storyAgentsDir, storyArtifactService, imageModelName, nickname = 'Artist') {
+    createArtistAgent(storyId, storyAgentsDir, storyArtifactService, imageModelName, nickname = 'Artist', variant = 'generation') {
         const storyInfo = this.storyStore.getStory(storyId);
-        const imageConfig = this.getImageModelConfig(imageModelName);
+        const imageConfig = this.getImageModelConfig(imageModelName, variant);
         if (!imageConfig) {
             logger_1.logger.log(`Artist agent creation skipped (${nickname}): images disabled`);
             return null;
@@ -1651,7 +1716,7 @@ let StoryService = class StoryService {
             return null;
         }
     }
-    async updateCharacterPortrait(room, characterAgent, storyId) {
+    async updateCharacterPortrait(room, characterAgent, storyId, updateDescription = false) {
         try {
             const artifacts = room.getArtifacts();
             const profileArtifact = artifacts.find((a) => a.name === `Character Profile - ${characterAgent.agentNickname}`);
@@ -1660,37 +1725,58 @@ let StoryService = class StoryService {
             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`);
+                logger_1.logger.warn(`No profile for ${characterAgent.agentNickname}, skipping appearance 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 = storyInfo.artistEditAgentId
+                ? await this.agentStore.getAgent(storyInfo.artistEditAgentId)
+                : null;
+            const hasArtist = !!artistEditAgent;
+            if (artistEditAgent) {
+                artistEditAgent.artifactService = storyArtifactService;
             }
-            const artistEditAgent = await this.agentStore.getAgent(storyInfo.artistEditAgentId);
-            if (!artistEditAgent) {
-                logger_1.logger.warn(`Edit artist agent not found: ${storyInfo.artistEditAgentId}`);
+            if (!updateDescription && !hasArtist) {
+                logger_1.logger.warn(`No edit artist configured for story ${storyId}, skipping portrait update`);
                 return null;
             }
-            artistEditAgent.artifactService = storyArtifactService;
             const portraitName = `Portrait - ${characterAgent.agentNickname}`;
-            const existingPortrait = storyArtifactService
-                .listArtifacts()
-                .find((a) => a.name === portraitName);
-            if (!existingPortrait) {
+            const existingPortrait = hasArtist
+                ? storyArtifactService.listArtifacts().find((a) => a.name === portraitName)
+                : undefined;
+            if (!updateDescription && hasArtist && !existingPortrait) {
                 logger_1.logger.warn(`No existing portrait for ${characterAgent.agentNickname}, generating from scratch`);
                 return this.generateCharacterPortrait(room, characterAgent, storyId);
             }
-            const visualDescription = await characterAgent.preparedPrompt('update_portrait', {
+            const portraitResponse = await characterAgent.preparedPrompt('update_portrait', {
                 characterName: characterAgent.agentNickname,
                 characterProfile: characterDescription,
+                currentDescription: characterAgent.description || '',
                 scenario: scenario,
             }, false);
+            if (updateDescription &&
+                portraitResponse?.description &&
+                typeof portraitResponse.description === 'string') {
+                characterAgent.description = portraitResponse.description;
+                characterAgent.save();
+                if (character) {
+                    character.description = portraitResponse.description;
+                    this.storyStore.updateStoryMetadata(storyId, storyInfo);
+                }
+                logger_1.logger.log(`Updated appearance description for ${characterAgent.agentNickname}`);
+            }
+            if (!hasArtist) {
+                return null;
+            }
+            const visualDescription = portraitResponse?.visual_prompt;
             if (!visualDescription || typeof visualDescription !== 'string') {
                 logger_1.logger.warn(`Failed to generate update description for ${characterAgent.agentNickname}`);
                 return null;
             }
+            if (!existingPortrait) {
+                logger_1.logger.warn(`No existing portrait for ${characterAgent.agentNickname}, generating from scratch`);
+                return this.generateCharacterPortrait(room, characterAgent, storyId);
+            }
             const imageResult = await artistEditAgent.editImage(visualDescription, this.getImagePropertiesForAgent(artistEditAgent), [existingPortrait.artifactId]);
             if (imageResult.error) {
                 return null;
@@ -1708,7 +1794,7 @@ let StoryService = class StoryService {
             return null;
         }
     }
-    async generateSceneIllustration(storyId, situation, allowReference = true) {
+    async generateSceneIllustration(storyId, situation, allowReference = true, latestNarration) {
         try {
             const story = this.storyStore.getStory(storyId);
             if (!story?.illustratorAgentId) {
@@ -1719,13 +1805,17 @@ let StoryService = class StoryService {
             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) {
-                logger_1.logger.warn('No messages in room');
-                return;
+            let narrationText = latestNarration;
+            if (!narrationText) {
+                const allMessages = room.getLatestRoomMessages(0, true);
+                const latestMessage = allMessages[allMessages.length - 1];
+                if (!latestMessage) {
+                    logger_1.logger.warn('No messages in room');
+                    return;
+                }
+                narrationText = latestMessage.content;
             }
-            illustrator.addToConversationHistory(latestMessage.content, false);
+            illustrator.addToConversationHistory(narrationText, false);
             const storyArtifactService = this.getStoryArtifactService(storyId);
             const allArtifacts = storyArtifactService.listArtifacts();
             const existingScenes = allArtifacts
@@ -1746,7 +1836,8 @@ let StoryService = class StoryService {
             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 situationForScene = `${story.situationTime ? `${story.situationTime} - ` : ''}${story.situation}`;
+            let prompt = `**Current Situation**:\n ${situationForScene}\n\n**Existing Scenes**:\n ${existingScenesString}`;
             const sceneAnalysis = await illustrator.instructedPrompt(prompt, 'describe_scene', {
                 characters: portraitCharacters,
             }, true, true);
@@ -1762,7 +1853,7 @@ let StoryService = class StoryService {
                 }
                 const referenceCreated = await this.generateSceneReference(storyId, sceneAnalysis.sceneName, sceneAnalysis.sceneDescription);
                 if (referenceCreated) {
-                    await this.generateSceneIllustration(storyId, situation, false);
+                    await this.generateSceneIllustration(storyId, situation, false, latestNarration);
                 }
             }
             else {
@@ -1933,21 +2024,16 @@ let StoryService = class StoryService {
         }
         return result;
     }
-    formatDisplaySituation(parsed, fallback) {
-        if (parsed.time && parsed.situation)
-            return `${parsed.time} - ${parsed.situation}`;
-        if (parsed.situation)
-            return parsed.situation;
-        return fallback;
-    }
-    async updateStorySituation(storyId, preamble) {
+    async updateStorySituation(storyId, preamble, latestNarration) {
         const story = this.storyStore.getStory(storyId);
         if (!story)
             return;
         const room = await this.getStoryRoom(storyId);
         const parsed = this.parseNarratorPreamble(preamble);
-        const displaySituation = this.formatDisplaySituation(parsed, preamble);
-        room.setSituation(displaySituation);
+        const situationText = parsed.situation ?? preamble;
+        const situationTime = parsed.time ?? '';
+        room.setSituation(situationText);
+        room.setSituationTime(situationTime);
         if (parsed.progressChapter) {
             story.declinedCharacters = [];
             story.pendingSuggestion = {
@@ -1972,19 +2058,20 @@ let StoryService = class StoryService {
                 logger_1.logger.log(`Character ${newCharacterName} was declined, skipping prompt`);
                 return;
             }
-            story.pendingSuggestion = {
-                type: 'suggest-introduce-character',
-                characterName: newCharacterName,
-                timestamp: Date.now(),
-            };
-            this.storyStore.updateStoryMetadata(storyId, story);
-            this.messageService.emitIntroduceCharacter(storyId, newCharacterName);
+            logger_1.logger.log(`Auto-creating narrator-introduced character ${newCharacterName}`);
+            try {
+                await this.introduceCharacter(storyId, newCharacterName, '', undefined, true, latestNarration);
+            }
+            catch (error) {
+                logger_1.logger.error(`Error auto-creating character ${newCharacterName} for story ${storyId}:`, error);
+            }
             return;
         }
-        story.situation = displaySituation;
+        story.situation = situationText;
+        story.situationTime = situationTime;
         this.storyStore.updateStoryMetadata(storyId, story);
-        logger_1.logger.log(`Updated story ${storyId} situation: ${displaySituation}`);
-        this.generateSceneIllustration(storyId, displaySituation).catch((error) => {
+        logger_1.logger.log(`Updated story ${storyId} situation: ${situationTime ? `${situationTime} - ` : ''}${situationText}`);
+        this.generateSceneIllustration(storyId, situationText, true, latestNarration).catch((error) => {
             logger_1.logger.error('Illustration generation error:', error);
         });
     }