briyah 1.0.9 → 1.1.1

package/{dist → dist-sdk}/server/src/story/story.service.js

@@ -74,6 +74,7 @@ let StoryService = class StoryService {
     agentFactory;
     roomFactory;
     storyArtifactServices = new Map();
+    chaptersInProgress = new Set();
     constructor(storyStore, agentStore, roomStore, progressService, messageService, configService, agentFactory, roomFactory) {
         this.storyStore = storyStore;
         this.agentStore = agentStore;
@@ -138,10 +139,7 @@ let StoryService = class StoryService {
                 totalInputTokens: story.totalInputTokens || 0,
                 totalOutputTokens: story.totalOutputTokens || 0,
             };
-            this.messageService.emitUpdate(storyId, {
-                type: 'state',
-                state: stateUpdate
-            });
+            this.messageService.emitStoryState(storyId, stateUpdate);
         }
         catch (error) {
             logger_1.logger.error(`Error emitting story state update for ${storyId}:`, error);
@@ -257,6 +255,7 @@ let StoryService = class StoryService {
         }
         const storyInfo = this.storyStore.createStory(name);
         storyInfo.turnNumber = 0;
+        let storyTitle = name;
         try {
             this.progressService.createProgressEmitter(storyInfo.id);
             this.progressService.emitProgress(storyInfo.id, 'start', 'Starting story creation...');
@@ -273,7 +272,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, '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(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);
             moderator.maxHistoryMessages = 16;
             moderator.reasoningEffort = 'low';
             moderator.promptCacheTTL = 60;
@@ -284,14 +283,14 @@ let StoryService = class StoryService {
             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 = 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.maxHistoryMessages = 10;
                 illustrator.promptCacheTTL = 60;
                 illustrator.ownerRoomId = storyInfo.id;
                 illustrator.save();
                 logger_1.logger.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);
+            let narrator = this.agentFactory.createAgent(aiServiceName, `${storyTitle} - Narrator`, '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;
@@ -977,6 +976,21 @@ let StoryService = class StoryService {
         const introducedCharPlotPlanArtifact = introducedCharArtifacts.find((a) => a.name === 'Plot Plan');
         const introducedCharPlotPlan = introducedCharPlotPlanArtifact?.body || '';
         await this.updateCharacterProfiles(room, [characterAgent], introducedCharPlotPlan);
+        if (!story.characters) {
+            story.characters = [];
+        }
+        if (!story.characters.some((c) => c.name === characterName)) {
+            story.characters.push({
+                name: characterName,
+                description: characterAgent.description,
+                isControlledByHuman: false,
+            });
+        }
+        if (story.pendingSuggestion?.type === 'suggest-introduce-character' &&
+            story.pendingSuggestion.characterName === characterName) {
+            story.pendingSuggestion = undefined;
+        }
+        this.storyStore.updateStoryMetadata(storyId, story);
         try {
             const artifactId = await this.generateCharacterPortrait(room, characterAgent, storyId);
             if (artifactId) {
@@ -1003,9 +1017,13 @@ let StoryService = class StoryService {
         }
         if (!story.declinedCharacters.includes(characterName)) {
             story.declinedCharacters.push(characterName);
-            this.storyStore.updateStoryMetadata(storyId, story);
             logger_1.logger.log(`Recorded declined character: ${characterName} for story ${storyId}`);
         }
+        if (story.pendingSuggestion?.type === 'suggest-introduce-character' &&
+            story.pendingSuggestion.characterName === characterName) {
+            story.pendingSuggestion = undefined;
+        }
+        this.storyStore.updateStoryMetadata(storyId, story);
     }
     async deleteCharacter(storyId, characterName) {
         let room;
@@ -1032,6 +1050,17 @@ let StoryService = class StoryService {
         room.setAgents(filteredAgents);
         room.saveMetadata();
         this.agentStore.removeAgent(agent.id);
+        const story = this.storyStore.getStory(storyId);
+        if (story?.characters) {
+            const filtered = story.characters.filter((c) => {
+                const firstWord = c.name.trim().split(/\s+/)[0];
+                return c.name !== characterName && firstWord !== characterName;
+            });
+            if (filtered.length !== story.characters.length) {
+                story.characters = filtered;
+                this.storyStore.updateStoryMetadata(storyId, story);
+            }
+        }
     }
     async deleteStory(storyId) {
         logger_1.logger.log(`Deleting story ${storyId}...`);
@@ -1135,7 +1164,7 @@ let StoryService = class StoryService {
                     return;
                 }
                 try {
-                    await this.compactAgentHistory(agent);
+                    await agent.compact();
                 }
                 catch (error) {
                     logger_1.logger.error(`Error compacting ${agent.agentName}:`, error);
@@ -1160,36 +1189,54 @@ let StoryService = class StoryService {
         if (!story) {
             throw new Error('Story not found');
         }
-        const existingEmitter = this.progressService.getProgressEmitter(storyId);
-        if (!existingEmitter) {
-            this.progressService.createProgressEmitter(storyId);
+        if (this.chaptersInProgress.has(storyId)) {
+            throw new errors_1.OperationFailedError('Chapter progression is already in progress for this story');
         }
-        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) => {
-                logger_1.logger.error('Error in async chapter progression:', error);
-                this.progressService.emitProgress(storyId, 'error', `Error: ${error.message}`);
+        this.chaptersInProgress.add(storyId);
+        try {
+            if (story.pendingSuggestion?.type === 'suggest-progress-chapter') {
+                story.pendingSuggestion = undefined;
+                this.storyStore.updateStoryMetadata(storyId, story);
+            }
+            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) => {
+                    logger_1.logger.error('Error in async chapter progression:', error);
+                    this.progressService.emitProgress(storyId, 'error', `Error: ${error.message}`);
+                })
+                    .finally(() => {
+                    this.chaptersInProgress.delete(storyId);
+                });
             });
-        });
-        return { chapterIndex };
+            return { chapterIndex };
+        }
+        catch (err) {
+            this.chaptersInProgress.delete(storyId);
+            throw err;
+        }
     }
     async progressStoryToNextChapterAsync(storyId) {
         let room = null;
@@ -1254,50 +1301,16 @@ let StoryService = class StoryService {
         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();
+                try {
+                    await agent.compact();
+                }
+                catch (error) {
+                    logger_1.logger.error(`Error compacting ${agent.agentName}:`, error);
+                    throw error;
+                }
             }
         }));
     }
-    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;
-            logger_1.logger.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;
-            logger_1.logger.error(`Error compacting ${agent.agentName}:`, error);
-            throw error;
-        }
-    }
     extractMarkdownContent(response) {
         const fenceMatch = response.match(/```(?:markdown)?\s*\n([\s\S]*?)```/);
         if (fenceMatch) {
@@ -1418,12 +1431,13 @@ let StoryService = class StoryService {
         }
     }
     createArtistAgent(storyId, storyAgentsDir, storyArtifactService, imageModelName) {
+        const storyInfo = this.storyStore.getStory(storyId);
         const imageConfig = this.getImageModelConfig(imageModelName);
         if (!imageConfig) {
             logger_1.logger.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);
+        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);
         artistAgent.maxHistoryMessages = 10;
         artistAgent.promptCacheTTL = 0;
         artistAgent.save();
@@ -1625,15 +1639,13 @@ let StoryService = class StoryService {
         if (progressChapter) {
             if (story) {
                 story.declinedCharacters = [];
-                this.storyStore.updateStoryMetadata(storyId, story);
             }
-            this.messageService.emitUpdate(storyId, {
-                type: 'suggestion',
-                suggestion: {
-                    type: 'progress_chapter',
-                    timestamp: Date.now()
-                }
-            });
+            story.pendingSuggestion = {
+                type: 'suggest-progress-chapter',
+                timestamp: Date.now(),
+            };
+            this.storyStore.updateStoryMetadata(storyId, story);
+            this.messageService.emitProgressChapter(storyId);
             return;
         }
         let agentCompactionThreshold = Number(process.env.AGENT_COMPACTION_THRESHOLD) || 150000;
@@ -1647,14 +1659,13 @@ let StoryService = class StoryService {
                     logger_1.logger.log(`Character ${newCharacterName} was declined, skipping prompt`);
                     return;
                 }
-                this.messageService.emitUpdate(storyId, {
-                    type: 'suggestion',
-                    suggestion: {
-                        type: 'introduce_character',
-                        characterName: newCharacterName,
-                        timestamp: Date.now()
-                    }
-                });
+                story.pendingSuggestion = {
+                    type: 'suggest-introduce-character',
+                    characterName: newCharacterName,
+                    timestamp: Date.now(),
+                };
+                this.storyStore.updateStoryMetadata(storyId, story);
+                this.messageService.emitIntroduceCharacter(storyId, newCharacterName);
             }
             return;
         }

package/{dist → dist-sdk}/shared/types/app.types.d.ts

@@ -220,6 +220,7 @@ export interface StoryInfo {
     totalOutputTokens: number;
     turnNumber: number;
     declinedCharacters?: string[];
+    pendingSuggestion?: StoryIntroduceCharacterEvent | StoryProgressChapterEvent;
 }
 export interface CreateStoryResponse {
     storyId: string;
@@ -241,19 +242,25 @@ export interface StoryState {
     totalInputTokens: number;
     totalOutputTokens: number;
 }
-export interface StorySuggestion {
-    type: 'introduce_character' | 'progress_chapter';
+export interface StoryStateEvent {
+    type: 'story-state';
+    state: StoryState;
+    timestamp: number;
+}
+export interface StoryIntroduceCharacterEvent {
+    type: 'suggest-introduce-character';
     characterName?: string;
     timestamp: number;
 }
-export interface StoryMessageUpdate {
-    type: 'state' | 'suggestion' | 'error';
-    state?: StoryState;
-    suggestion?: StorySuggestion;
-    error?: {
-        message: string;
-        errorType?: string;
-    };
+export interface StoryProgressChapterEvent {
+    type: 'suggest-progress-chapter';
+    timestamp: number;
+}
+export interface StoryErrorEvent {
+    type: 'story-error';
+    message: string;
+    errorType?: string;
+    timestamp: number;
 }
 export interface ChaptersResponse {
     chapters: ChapterInfo[];
@@ -283,7 +290,7 @@ export interface Transaction {
     userId: string;
     amount: number;
     currency: string;
-    stripePaymentIntentId: string;
+    paymentId: string;
     status: 'pending' | 'succeeded' | 'failed' | 'cancelled';
     createdAt: number;
     updatedAt: number;

package/docs/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJx1jc0KgzAQhN9lzrFWwWLyDr30Kh6CWWtoTCCbniTvXtI/pNDTwM63822IISSGGjopR4FIs6Mp2eAZakMnZQmvV4LCmZj1lSBws95Atd1J4B4dFKxPFGc9Eddv6rCk1UFgcpoZColNVd6qL1rKxToTyUMNzbHvxyxQcue8hLD+epu2/3if68T1Dvsrfh1yzg8aB1Bi"
+window.hierarchyData = "eJx1jc0KwjAQhN9lzqkliq3sO3jxWnoI7dYG0wSy8VTy7hL/KIKngZ1v51sRQ0gC6hrd9gqRJ8dDssELaEWj2xLeLAzCmUXMlaFws34E7Y+Nwj06EKxPHCczsNRvajenxUFhcEYEhCRjVd6qL1rK2boxsgd1Wh90nxVKbpyXEJZfr96fPt7nOku9wf6KX4ec8wMBuFA6"

package/docs/assets/navigation.js

@@ -1 +1 @@
-window.navigationData = "eJyN1sFO4zAQBuB38blalkrA0htbhIQEAtHdE+JgOdPEIrEte4qoEO+OEtJgN/bY1/y/v6buOOnzB0N4R7Zi9+Acr+FKoNSKLZjh2LAVA7Xr3EkQ/mqwa9mCvUpVsdWfz8VkXNWg8GetaLlz4E6Gy+Gq06W/7q+Ve97MF35fz69ca7WV9QbsmxSQYoISZT5p3c2R/mpu1bhN8cVjSBnDRt2qrf4RpEKwWy4O29inIbE8Oz8mxo9yT+CMVg7S3HGTpI2ZbbHvTTGJWJRbLjBOjGEJcA/IK46chA4lEkTkornWYteBQnrLolUK90fvwfSnx0XlSI9i1w03CDY5Kl6eYSwXCDaFfKckYYEjDLNEbl2kl2f7Y1Og+rU8ukFt9wVq0KPYG9nCnXTxkT6EFHCn61oqcj7CCoXNnkGeEn0EHS3XFbTJuZpSini0YLiF6tHqztBTEa/SuBbg3D94z8mzXobtDPY/Vkob4zJkrRUGr8KoNbbKSPphHukVsLqtEmffL5RCRXcYNim6P9XXgFy28SPh5TkmOc+HMAcUvVBjRQoeHjC3FcRfYVOaJ1LfbkqzxHjb/03FMf7l5rUsukESG+I8sqtrcOF/0pk0dfKjuhHaeDeFezPN5hAdCb8vL07Plp8vX/pW2ak="
+window.navigationData = "eJyNlk1P4zAQhv+Lz9WyVAJ2e2MLCCTQVpQb4mA508QisS17iqhW/PdVQpo6iT321e87j5PJfOT1H0P4RLZiT+AcL+FaoNSKLZjhWLEVA7Vv3NlI/FFhU7MFe5eqYKtfX4uBcV2CwlOsqLlz4M6643HU+dKP+2PlgVfzwO/zdORaq50st2A/pIAYZmSimM9aN3NIe5qK6tMUDu5FitEl6kHt9IkgFYLdcXFMY6uOEcuLyymiv8o9gzNaOYjjpk4SbcwsxT5vkEmIRbnjAsOIXswBPAHygiMnQUcTCUTkorrRYt+AQjplQSsF90vvr2m7xwXJAR+FXVfcINhoqXh6AmO5QLAxyLdKIixwhK6WyNQFfGls2zYZVN+Whm5R20MGdeSjsHeyhkfpwiV9FCnAoy5Lqcj6GFso2GwGeZTgCJqE6wLqaF0NKoXYWDDcQrGxujF0VYStNFwLcO4FPlPkmS+BbQy2HytG6+U8yForHK3CIKt35SHpYR7wZWB1XUR63zfkgrKecOyk0G1X3wByWYdbwtNTmGg9H8UUIGuhhowUuBswt9Zqe/sRK5aJJ4l7KCC8EQc1jYgla1AzEGh1sRcwrJDEG0YCkhdtrC4tONfvu8QtIXfyii1yDH/vk5wHSTzdyUPhXixXjk9+0j2Up2di7qVLbsS4PT0ctkIbj4oHM0yDTpoQfv6+Or9Yfr39ByjAXqw="

package/docs/assets/search.js

@@ -1 +1 @@
-window.searchData = "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";
+window.searchData = "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";