briyah 1.0.9 → 1.1.1

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

@@ -40,7 +40,7 @@ let StripeService = class StripeService {
         this.minPaymentAmount = parseFloat(process.env.MIN_PAYMENT_AMOUNT || '5.00');
         this.maxPaymentAmount = parseFloat(process.env.MAX_PAYMENT_AMOUNT || '500.00');
     }
-    async createPaymentIntent(userId, amount, transactionService) {
+    async createPaymentIntent(userId, amount, appService) {
         if (!amount || amount <= 0) {
             throw new common_1.BadRequestException('Amount must be greater than 0');
         }
@@ -62,7 +62,7 @@ let StripeService = class StripeService {
                     enabled: true,
                 },
             });
-            await transactionService.recordTransaction(amount, paymentIntent.id, 'pending');
+            await appService.recordTransaction(amount, paymentIntent.id, 'pending');
             return {
                 clientSecret: paymentIntent.client_secret,
                 publishableKey: this.publishableKey,
@@ -73,7 +73,7 @@ let StripeService = class StripeService {
             throw new common_1.InternalServerErrorException('Failed to create payment intent');
         }
     }
-    async createCheckoutSession(userId, amount, transactionService) {
+    async createCheckoutSession(userId, amount, appService) {
         if (!amount || amount <= 0) {
             throw new common_1.BadRequestException('Amount must be greater than 0');
         }
@@ -113,7 +113,7 @@ let StripeService = class StripeService {
                 },
             });
             if (session.payment_intent) {
-                await transactionService.recordTransaction(amount, session.payment_intent, 'pending');
+                await appService.recordTransaction(amount, session.payment_intent, 'pending');
             }
             return {
                 url: session.url,
@@ -124,6 +124,22 @@ let StripeService = class StripeService {
             throw new common_1.InternalServerErrorException('Failed to create checkout session');
         }
     }
+    async getCheckoutSessionUser(sessionId) {
+        try {
+            const session = await this.stripe.checkout.sessions.retrieve(sessionId);
+            const userId = session.metadata?.userId;
+            if (!userId) {
+                throw new common_1.BadRequestException('Session has no userId in metadata');
+            }
+            return { userId, paymentStatus: session.payment_status };
+        }
+        catch (error) {
+            if (error instanceof common_1.BadRequestException)
+                throw error;
+            logger_1.logger.error('Error retrieving checkout session:', error);
+            throw new common_1.BadRequestException('Invalid or expired session ID');
+        }
+    }
     getStripeConfig() {
         return {
             publishableKey: this.publishableKey,
@@ -148,8 +164,7 @@ let StripeService = class StripeService {
             }
             const amount = paymentIntent.amount / 100;
             logger_1.logger.log(`[Stripe Webhook] Amount: $${amount.toFixed(2)}`);
-            const transactionService = appService.getTransactionService();
-            const existingTransaction = await transactionService.getTransactionByPaymentIntent(paymentIntent.id);
+            const existingTransaction = await appService.getTransactionByPaymentId(paymentIntent.id);
             logger_1.logger.log(`[Stripe Webhook] Existing transaction:`, existingTransaction);
             if (existingTransaction?.status === 'succeeded') {
                 logger_1.logger.log(`Transaction ${paymentIntent.id} already processed, skipping`);
@@ -162,7 +177,7 @@ let StripeService = class StripeService {
             const balanceAfter = await appService.getBalance();
             logger_1.logger.log(`[Stripe Webhook] Balance after: $${balanceAfter.toFixed(2)}`);
             logger_1.logger.log(`[Stripe Webhook] Updating transaction status to 'succeeded'`);
-            await transactionService.updateTransactionStatus(paymentIntent.id, 'succeeded');
+            await appService.updateTransactionStatus(paymentIntent.id, 'succeeded');
             logger_1.logger.log(`[Stripe Webhook] Checking for paused stories to resume...`);
             const resumedCount = await appService.resumePausedStories();
             if (resumedCount > 0) {
@@ -182,8 +197,7 @@ let StripeService = class StripeService {
                 logger_1.logger.error('Payment Intent missing userId in metadata:', paymentIntent.id);
                 return;
             }
-            const transactionService = appService.getTransactionService();
-            await transactionService.updateTransactionStatus(paymentIntent.id, 'failed');
+            await appService.updateTransactionStatus(paymentIntent.id, 'failed');
             logger_1.logger.log(`Payment failed for user ${userId}: ${paymentIntent.id}`);
         }
         catch (error) {

package/{dist → dist-sdk}/server/src/app/transaction.service.d.ts

@@ -5,9 +5,9 @@ export declare class TransactionService {
     private configService;
     private transactionsDir;
     constructor(userId: string, configService: ConfigurationService);
-    recordTransaction(amount: number, stripePaymentIntentId: string, status?: 'pending' | 'succeeded' | 'failed' | 'cancelled'): Promise<Transaction>;
-    updateTransactionStatus(paymentIntentId: string, status: 'pending' | 'succeeded' | 'failed' | 'cancelled'): Promise<void>;
-    getTransactionByPaymentIntent(paymentIntentId: string): Promise<Transaction | null>;
+    recordTransaction(amount: number, paymentId: string, status?: 'pending' | 'succeeded' | 'failed' | 'cancelled'): Promise<Transaction>;
+    updateTransactionStatus(paymentId: string, status: 'pending' | 'succeeded' | 'failed' | 'cancelled'): Promise<void>;
+    getTransactionByPaymentId(paymentId: string): Promise<Transaction | null>;
     getTransactions(limit?: number, offset?: number): Promise<{
         transactions: Transaction[];
         total: number;

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

@@ -51,19 +51,19 @@ class TransactionService {
             fs.mkdirSync(this.transactionsDir, { recursive: true });
         }
     }
-    async recordTransaction(amount, stripePaymentIntentId, status = 'pending') {
+    async recordTransaction(amount, paymentId, status = 'pending') {
         const timestamp = Date.now();
         const transaction = {
             id: (0, zod_1.uuidv4)().toString(),
             userId: this.userId,
             amount,
             currency: 'usd',
-            stripePaymentIntentId,
+            paymentId,
             status,
             createdAt: timestamp,
             updatedAt: timestamp,
         };
-        const filename = `${timestamp}-${stripePaymentIntentId}.json`;
+        const filename = `${timestamp}-${paymentId}.json`;
         const filePath = path.join(this.transactionsDir, filename);
         try {
             fs.writeFileSync(filePath, JSON.stringify(transaction, null, 2), 'utf-8');
@@ -74,31 +74,31 @@ class TransactionService {
             throw error;
         }
     }
-    async updateTransactionStatus(paymentIntentId, status) {
+    async updateTransactionStatus(paymentId, status) {
         try {
-            const transaction = await this.getTransactionByPaymentIntent(paymentIntentId);
+            const transaction = await this.getTransactionByPaymentId(paymentId);
             if (!transaction) {
-                logger_1.logger.error(`Transaction not found for payment intent ${paymentIntentId}`);
+                logger_1.logger.error(`Transaction not found for payment ID ${paymentId}`);
                 return;
             }
             transaction.status = status;
             transaction.updatedAt = Date.now();
             const files = fs.readdirSync(this.transactionsDir);
-            const matchingFile = files.find((file) => file.includes(paymentIntentId));
+            const matchingFile = files.find((file) => file.includes(paymentId));
             if (matchingFile) {
                 const filePath = path.join(this.transactionsDir, matchingFile);
                 fs.writeFileSync(filePath, JSON.stringify(transaction, null, 2), 'utf-8');
             }
         }
         catch (error) {
-            logger_1.logger.error(`Error updating transaction status for ${paymentIntentId}:`, error);
+            logger_1.logger.error(`Error updating transaction status for ${paymentId}:`, error);
             throw error;
         }
     }
-    async getTransactionByPaymentIntent(paymentIntentId) {
+    async getTransactionByPaymentId(paymentId) {
         try {
             const files = fs.readdirSync(this.transactionsDir);
-            const matchingFile = files.find((file) => file.includes(paymentIntentId));
+            const matchingFile = files.find((file) => file.includes(paymentId));
             if (!matchingFile) {
                 return null;
             }
@@ -107,7 +107,7 @@ class TransactionService {
             return JSON.parse(content);
         }
         catch (error) {
-            logger_1.logger.error(`Error getting transaction for payment intent ${paymentIntentId}:`, error);
+            logger_1.logger.error(`Error getting transaction for payment ID ${paymentId}:`, error);
             return null;
         }
     }

package/{dist → dist-sdk}/server/src/app.controller.d.ts

@@ -110,6 +110,7 @@ export declare class AppController {
     updateAgent(req: ExpressRequest, agentId: string, updateData: UpdateAgentRequest): Promise<void>;
     deleteAttachedFile(req: ExpressRequest, agentId: string, documentId: string): Promise<void>;
     reloadAgent(req: ExpressRequest, agentId: string): Promise<void>;
+    compactAgentConversation(req: ExpressRequest, agentId: string): Promise<void>;
     resetRoom(req: ExpressRequest, roomId: string): Promise<void>;
     publishRoom(req: ExpressRequest, templateId: string, body: {
         publishedName?: string;

package/{dist → dist-sdk}/server/src/app.controller.js

@@ -827,6 +827,34 @@ let AppController = class AppController {
             throw new common_1.HttpException('Failed to reload agent', common_1.HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
+    async compactAgentConversation(req, agentId) {
+        if (!agentId) {
+            throw new common_1.BadRequestException('Agent ID is required');
+        }
+        try {
+            const appService = this.getAppService(req, agentId);
+            if (req.user.type === 'agent-access') {
+                const agentDetails = await appService.getAgentDetails(agentId);
+                if (!agentDetails || !agentDetails.isPublished) {
+                    throw new common_1.ForbiddenException('Agent is not published');
+                }
+            }
+            await appService.compactAgentConversation(agentId);
+        }
+        catch (error) {
+            logger_1.logger.error(`[${req.user?.sub}] Error compacting agent ${agentId}:`, error);
+            if (error instanceof errors_1.NotFoundError) {
+                throw new common_1.NotFoundException(error.message);
+            }
+            if (error instanceof errors_1.OperationFailedError) {
+                throw new common_1.HttpException(error.message, common_1.HttpStatus.INTERNAL_SERVER_ERROR);
+            }
+            if (error instanceof common_1.ForbiddenException) {
+                throw error;
+            }
+            throw new common_1.HttpException('Failed to compact agent conversation', common_1.HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
     async resetRoom(req, roomId) {
         if (!roomId) {
             throw new common_1.BadRequestException('Room ID is required');
@@ -1412,13 +1440,22 @@ let AppController = class AppController {
                 subscriber.next({
                     data: { type: 'connected', storyId },
                 });
+                if (storyInfo.pendingSuggestion) {
+                    subscriber.next({ data: storyInfo.pendingSuggestion });
+                }
                 const updateHandler = (data) => {
                     subscriber.next({ data });
                 };
-                emitter.on('update', updateHandler);
+                emitter.on('story-state', updateHandler);
+                emitter.on('suggest-introduce-character', updateHandler);
+                emitter.on('suggest-progress-chapter', updateHandler);
+                emitter.on('story-error', updateHandler);
                 return () => {
                     logger_1.logger.log(`[SSE] Cleanup for story ${storyId}`);
-                    emitter.off('update', updateHandler);
+                    emitter.off('story-state', updateHandler);
+                    emitter.off('suggest-introduce-character', updateHandler);
+                    emitter.off('suggest-progress-chapter', updateHandler);
+                    emitter.off('story-error', updateHandler);
                 };
             });
         }
@@ -2070,6 +2107,16 @@ __decorate([
     __metadata("design:paramtypes", [Object, String]),
     __metadata("design:returntype", Promise)
 ], AppController.prototype, "reloadAgent", null);
+__decorate([
+    (0, agent_access_decorator_1.AgentAccess)(),
+    (0, common_1.Post)('agents/:agentId/compact'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.NO_CONTENT),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Param)('agentId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], AppController.prototype, "compactAgentConversation", null);
 __decorate([
     (0, common_1.Post)('rooms/:roomId/reset'),
     (0, common_1.HttpCode)(common_1.HttpStatus.NO_CONTENT),

package/{dist → dist-sdk}/server/src/app.service.d.ts

@@ -21,7 +21,7 @@ import { TransactionService } from './app/transaction.service';
 import { AgentFactory } from './ai/agent-factory';
 import { RoomFactory } from './room/room-factory';
 import { EventEmitter } from 'events';
-import { AgentInfo, RoomInfo, RoomDetails, CreateRoomResponse, FileList, PromptFileContent, PromptFoldersResponse, PromptFilesResponse, PromptScope, ProcessTextResponse, PreparedPromptResponse, AttachDocumentResponse, AgentMessagesResponse, RoomMessagesResponse, StoryInfo, StoryState, Character } from '../../shared/types/app.types';
+import { AgentInfo, RoomInfo, RoomDetails, CreateRoomResponse, FileList, PromptFileContent, PromptFoldersResponse, PromptFilesResponse, PromptScope, ProcessTextResponse, PreparedPromptResponse, AttachDocumentResponse, AgentMessagesResponse, RoomMessagesResponse, StoryInfo, StoryState, Character, Transaction, TransactionHistoryResponse } from '../../shared/types/app.types';
 import { RoomMessage } from './room/message';
 export declare class AppService {
     private readonly aiFactoryService;
@@ -111,6 +111,7 @@ export declare class AppService {
     deleteAttachedFile(agentId: string, fileName: string): Promise<void>;
     deleteAttachedFileById(documentId: string): Promise<void>;
     reloadAgent(agentId: string): Promise<void>;
+    compactAgentConversation(agentId: string): Promise<void>;
     resetRoom(roomId: string): Promise<void>;
     resetStory(storyId: string): Promise<void>;
     createStory(name: string, idea: string, userCharacterDesc: string, otherCharactersDesc: string, storyModel?: string, isImport?: boolean, imageModelName?: string): Promise<StoryInfo>;
@@ -166,7 +167,10 @@ export declare class AppService {
     savePlotPlan(storyId: string, content: string): Promise<void>;
     getBalance(): number;
     addBalance(amount: number): void;
-    getTransactionService(): TransactionService;
+    recordTransaction(amount: number, paymentId: string, status?: 'pending' | 'succeeded' | 'failed' | 'cancelled'): Promise<Transaction>;
+    updateTransactionStatus(paymentId: string, status: 'pending' | 'succeeded' | 'failed' | 'cancelled'): Promise<void>;
+    getTransactionByPaymentId(paymentId: string): Promise<Transaction | null>;
+    getTransactions(limit?: number, offset?: number): Promise<TransactionHistoryResponse>;
     listUserArtifacts(): ArtifactMetadata[];
     getUserArtifact(artifactId: string): string | Buffer | null;
     createUserArtifact(name: string, content: string): string;

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

@@ -890,6 +890,13 @@ class AppService {
         }
         agent.save();
     }
+    async compactAgentConversation(agentId) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError('Agent not found');
+        }
+        await agent.compact();
+    }
     async resetRoom(roomId) {
         const room = await this.roomStore.getRoom(roomId);
         if (!room) {
@@ -1155,8 +1162,17 @@ class AppService {
     addBalance(amount) {
         return this.balanceService.addBalance(amount);
     }
-    getTransactionService() {
-        return this.transactionService;
+    async recordTransaction(amount, paymentId, status = 'pending') {
+        return this.transactionService.recordTransaction(amount, paymentId, status);
+    }
+    async updateTransactionStatus(paymentId, status) {
+        return this.transactionService.updateTransactionStatus(paymentId, status);
+    }
+    async getTransactionByPaymentId(paymentId) {
+        return this.transactionService.getTransactionByPaymentId(paymentId);
+    }
+    async getTransactions(limit = 50, offset = 0) {
+        return this.transactionService.getTransactions(limit, offset);
     }
     listUserArtifacts() {
         return this.artifactService.listArtifacts();

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

@@ -52,7 +52,7 @@ let UsersService = class UsersService {
     usersFilePath;
     dataDir;
     constructor() {
-        this.dataDir = process.env.SERVER_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
+        this.dataDir = process.env.BRIYAH_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
         const commonDir = path.resolve(this.dataDir, 'common');
         const usersDir = path.resolve(commonDir, 'users');
         this.usersFilePath = path.resolve(usersDir, 'users.json');

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

@@ -49,7 +49,7 @@ class ConfigurationService {
     userId;
     constructor(userId, baseDataPath) {
         this.userId = userId;
-        const dataPath = baseDataPath || process.env.SERVER_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
+        const dataPath = baseDataPath || process.env.BRIYAH_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
         this.dataDir = path.resolve(dataPath);
         if (!fs.existsSync(this.dataDir)) {
             fs.mkdirSync(this.dataDir, { recursive: true });

package/{dist → dist-sdk}/server/src/room/published-rooms.service.js

@@ -51,7 +51,7 @@ let PublishedRoomsService = class PublishedRoomsService {
     mapping;
     filePath;
     constructor() {
-        const dataPath = process.env.SERVER_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
+        const dataPath = process.env.BRIYAH_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
         this.filePath = path.join(dataPath, 'common', 'published-rooms.json');
         this.mapping = new Map();
         this.load();

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

@@ -272,6 +272,7 @@ class Room {
             let response = await agent.instructedPrompt(prompt, 'perceive', variables, false, true, maxOutputChars);
             answer = this.parseAgentResponse(agent, response);
             agent.addToConversationHistory(response, true);
+            agent.save();
         }
         catch (e) {
             if (e instanceof errors_1.InsufficientBalanceError) {

package/{dist → dist-sdk}/server/src/sdk/briyah-config.js

@@ -9,8 +9,8 @@ class BriyahConfigService {
             ...(options?.envOverrides || {}),
         };
         if (options?.dataPath) {
-            this.env.SERVER_DATA_PATH = options.dataPath;
-            process.env.SERVER_DATA_PATH = options.dataPath;
+            this.env.BRIYAH_DATA_PATH = options.dataPath;
+            process.env.BRIYAH_DATA_PATH = options.dataPath;
         }
         if (options?.userServiceCacheTimeoutMinutes !== undefined) {
             this.env.USER_SERVICE_CACHE_TIMEOUT_MINUTES = String(options.userServiceCacheTimeoutMinutes);

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

@@ -72,7 +72,7 @@ class Briyah {
     initialized = false;
     constructor(options) {
         this.configService = new briyah_config_1.BriyahConfigService(options);
-        const dataPath = this.configService.get('SERVER_DATA_PATH') || path.resolve(process.cwd(), 'briyah-data');
+        const dataPath = this.configService.get('BRIYAH_DATA_PATH') || path.resolve(process.cwd(), 'briyah-data');
         logger_1.logger.configure({
             enabled: options?.logging?.enabled !== false,
             console: options?.logging?.console !== false,
@@ -131,7 +131,7 @@ class Briyah {
         this.initialized = true;
     }
     seedCommonData() {
-        const dataPath = this.configService.get('SERVER_DATA_PATH') || path.resolve(process.cwd(), 'briyah-data');
+        const dataPath = this.configService.get('BRIYAH_DATA_PATH') || path.resolve(process.cwd(), 'briyah-data');
         const userCommonDir = path.resolve(dataPath, 'common');
         const packageCommonDir = path.resolve(__dirname, '../../../../data/common');
         if (!fs.existsSync(packageCommonDir)) {

package/{dist → dist-sdk}/server/src/sdk/index.d.ts

@@ -1,7 +1,7 @@
 export { Briyah } from './briyah';
 export { BriyahConfigService, BriyahConfigOptions } from './briyah-config';
 export type { AppService } from '../app.service';
-export type { AgentInfo, CreateAgentResponse, RoomInfo, RoomDetails, CreateRoomResponse, StoryInfo, CreateStoryResponse, ProcessTextResponse, FileList, PromptFileContent, AttachDocumentResponse, AgentMessagesResponse, RoomMessagesResponse, StoryState, Message, MessageAction, ModelInfo, ArtifactMetadata, PreparedPromptResponse, PromptScope, PromptFolder, PromptFoldersResponse, PromptFile, PromptFilesResponse, StoryIdea, StorySuggestion, StoryMessageUpdate, Character, ChapterInfo, } from '../../../shared/types/app.types';
+export type { AgentInfo, CreateAgentResponse, RoomInfo, RoomDetails, CreateRoomResponse, StoryInfo, CreateStoryResponse, ProcessTextResponse, FileList, PromptFileContent, AttachDocumentResponse, AgentMessagesResponse, RoomMessagesResponse, StoryState, Message, MessageAction, ModelInfo, ArtifactMetadata, PreparedPromptResponse, PromptScope, PromptFolder, PromptFoldersResponse, PromptFile, PromptFilesResponse, StoryIdea, Transaction, TransactionHistoryResponse, StoryStateEvent, StoryIntroduceCharacterEvent, StoryProgressChapterEvent, StoryErrorEvent, Character, ChapterInfo, } from '../../../shared/types/app.types';
 export type { LoggingOptions } from './briyah-config';
 export { Agent } from '../ai/agent';
 export { Room } from '../room/room';

package/{dist → dist-sdk}/server/src/story/story-message.service.d.ts

@@ -1,10 +1,12 @@
 import { EventEmitter } from 'events';
-import { StoryMessageUpdate } from '../../../shared/types/app.types';
+import { StoryState } from '../../../shared/types/app.types';
 export declare class StoryMessageService {
     private messageEmitters;
     getOrCreateEmitter(storyId: string): EventEmitter;
     getEmitter(storyId: string): EventEmitter | undefined;
-    emitUpdate(storyId: string, update: StoryMessageUpdate): void;
+    emitStoryState(storyId: string, state: StoryState): void;
+    emitIntroduceCharacter(storyId: string, characterName?: string): void;
+    emitProgressChapter(storyId: string): void;
     emitError(storyId: string, error: Error): void;
     cleanup(storyId: string): void;
 }

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

@@ -22,26 +22,37 @@ let StoryMessageService = class StoryMessageService {
     getEmitter(storyId) {
         return this.messageEmitters.get(storyId);
     }
-    emitUpdate(storyId, update) {
-        const emitter = this.messageEmitters.get(storyId);
-        if (emitter) {
-            const updateWithTimestamp = {
-                timestamp: Date.now(),
-                ...update
-            };
-            emitter.emit('update', updateWithTimestamp);
-        }
+    emitStoryState(storyId, state) {
+        const emitter = this.getOrCreateEmitter(storyId);
+        const payload = { type: 'story-state', state, timestamp: Date.now() };
+        emitter.emit('story-state', payload);
+    }
+    emitIntroduceCharacter(storyId, characterName) {
+        const emitter = this.getOrCreateEmitter(storyId);
+        const payload = {
+            type: 'suggest-introduce-character',
+            characterName,
+            timestamp: Date.now(),
+        };
+        emitter.emit('suggest-introduce-character', payload);
+    }
+    emitProgressChapter(storyId) {
+        const emitter = this.getOrCreateEmitter(storyId);
+        const payload = {
+            type: 'suggest-progress-chapter',
+            timestamp: Date.now(),
+        };
+        emitter.emit('suggest-progress-chapter', payload);
     }
     emitError(storyId, error) {
-        const emitter = this.messageEmitters.get(storyId);
-        if (emitter) {
-            emitter.emit('update', {
-                timestamp: Date.now(),
-                type: 'error',
-                errorType: error.name,
-                message: error.message,
-            });
-        }
+        const emitter = this.getOrCreateEmitter(storyId);
+        const payload = {
+            type: 'story-error',
+            errorType: error.name,
+            message: error.message,
+            timestamp: Date.now(),
+        };
+        emitter.emit('story-error', payload);
     }
     cleanup(storyId) {
         const emitter = this.messageEmitters.get(storyId);

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

@@ -20,6 +20,7 @@ export declare class StoryService {
     private readonly agentFactory;
     private readonly roomFactory;
     private readonly storyArtifactServices;
+    private readonly chaptersInProgress;
     constructor(storyStore: StoryStoreService, agentStore: AgentStoreService, roomStore: RoomStoreService, progressService: StoryProgressService, messageService: StoryMessageService, configService: ConfigurationService, agentFactory: AgentFactory, roomFactory: RoomFactory);
     getProgressEmitter(storyId: string): import("node:events")<any>;
     getMessageEmitter(storyId: string): import("node:events")<any>;
@@ -72,7 +73,6 @@ export declare class StoryService {
     private progressStoryToNextChapterAsync;
     private generateOpeningScene;
     private compactAgentHistories;
-    private compactAgentHistory;
     private extractMarkdownContent;
     private updatePlotPlan;
     private updateCharacterProfiles;