briyah 1.0.0

package/dist/app/transaction.service.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const zod_1 = require("zod");
+class TransactionService {
+    userId;
+    configService;
+    transactionsDir;
+    constructor(userId, configService) {
+        this.userId = userId;
+        this.configService = configService;
+        const userDataPath = this.configService.getUserDataDir();
+        this.transactionsDir = path.join(userDataPath, 'transactions');
+        if (!fs.existsSync(this.transactionsDir)) {
+            fs.mkdirSync(this.transactionsDir, { recursive: true });
+        }
+    }
+    async recordTransaction(amount, stripePaymentIntentId, status = 'pending') {
+        const timestamp = Date.now();
+        const transaction = {
+            id: (0, zod_1.uuidv4)().toString(),
+            userId: this.userId,
+            amount,
+            currency: 'usd',
+            stripePaymentIntentId,
+            status,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        const filename = `${timestamp}-${stripePaymentIntentId}.json`;
+        const filePath = path.join(this.transactionsDir, filename);
+        try {
+            fs.writeFileSync(filePath, JSON.stringify(transaction, null, 2), 'utf-8');
+            return transaction;
+        }
+        catch (error) {
+            console.error(`Error recording transaction for user ${this.userId}:`, error);
+            throw error;
+        }
+    }
+    async updateTransactionStatus(paymentIntentId, status) {
+        try {
+            const transaction = await this.getTransactionByPaymentIntent(paymentIntentId);
+            if (!transaction) {
+                console.error(`Transaction not found for payment intent ${paymentIntentId}`);
+                return;
+            }
+            transaction.status = status;
+            transaction.updatedAt = Date.now();
+            const files = fs.readdirSync(this.transactionsDir);
+            const matchingFile = files.find((file) => file.includes(paymentIntentId));
+            if (matchingFile) {
+                const filePath = path.join(this.transactionsDir, matchingFile);
+                fs.writeFileSync(filePath, JSON.stringify(transaction, null, 2), 'utf-8');
+            }
+        }
+        catch (error) {
+            console.error(`Error updating transaction status for ${paymentIntentId}:`, error);
+            throw error;
+        }
+    }
+    async getTransactionByPaymentIntent(paymentIntentId) {
+        try {
+            const files = fs.readdirSync(this.transactionsDir);
+            const matchingFile = files.find((file) => file.includes(paymentIntentId));
+            if (!matchingFile) {
+                return null;
+            }
+            const filePath = path.join(this.transactionsDir, matchingFile);
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error(`Error getting transaction for payment intent ${paymentIntentId}:`, error);
+            return null;
+        }
+    }
+    async getTransactions(limit = 50, offset = 0) {
+        try {
+            const files = fs.readdirSync(this.transactionsDir);
+            const transactions = [];
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                const filePath = path.join(this.transactionsDir, file);
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const transaction = JSON.parse(content);
+                transactions.push(transaction);
+            }
+            transactions.sort((a, b) => b.createdAt - a.createdAt);
+            const total = transactions.length;
+            const paginatedTransactions = transactions.slice(offset, offset + limit);
+            return {
+                transactions: paginatedTransactions,
+                total,
+            };
+        }
+        catch (error) {
+            console.error(`Error getting transactions for user ${this.userId}:`, error);
+            return { transactions: [], total: 0 };
+        }
+    }
+}
+exports.TransactionService = TransactionService;

package/dist/app/user-service-factory.d.ts

@@ -0,0 +1,21 @@
+import { AppService } from '../app.service';
+import { RoomMessageService } from '../room/room-message.service';
+import { AiFactoryService } from '../ai/ai-factory.service';
+import { AgentMessageService } from '../ai/agent-message.service';
+import { StoryProgressService } from '../story/story-progress.service';
+import { StoryMessageService } from '../story/story-message.service';
+import { PublishedAgentsService } from '../ai/published-agents.service';
+import { PublishedRoomsService } from '../room/published-rooms.service';
+import { BalanceMessageService } from './balance-message.service';
+export declare class UserServiceFactory {
+    private readonly aiFactoryService;
+    private readonly agentMessageService;
+    private readonly roomMessageService;
+    private readonly storyProgressService;
+    private readonly storyMessageService;
+    private readonly publishedAgentsService;
+    private readonly publishedRoomsService;
+    private readonly balanceMessageService;
+    constructor(aiFactoryService: AiFactoryService, agentMessageService: AgentMessageService, roomMessageService: RoomMessageService, storyProgressService: StoryProgressService, storyMessageService: StoryMessageService, publishedAgentsService: PublishedAgentsService, publishedRoomsService: PublishedRoomsService, balanceMessageService: BalanceMessageService);
+    createAppService(userId: string): AppService;
+}

package/dist/app/user-service-factory.js

@@ -0,0 +1,81 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserServiceFactory = void 0;
+const common_1 = require("@nestjs/common");
+const app_service_1 = require("../app.service");
+const configuration_service_1 = require("../config/configuration.service");
+const agent_store_service_1 = require("../ai/agent-store.service");
+const room_store_service_1 = require("../room/room-store.service");
+const artifact_store_service_1 = require("../room/artifact-store.service");
+const room_message_service_1 = require("../room/room-message.service");
+const story_store_service_1 = require("../story/story-store.service");
+const attached_file_service_1 = require("../ai/attached-file.service");
+const artifact_service_1 = require("../ai/artifact.service");
+const ai_factory_service_1 = require("../ai/ai-factory.service");
+const agent_message_service_1 = require("../ai/agent-message.service");
+const story_service_1 = require("../story/story.service");
+const story_progress_service_1 = require("../story/story-progress.service");
+const story_message_service_1 = require("../story/story-message.service");
+const published_agents_service_1 = require("../ai/published-agents.service");
+const published_rooms_service_1 = require("../room/published-rooms.service");
+const balance_service_1 = require("./balance.service");
+const balance_message_service_1 = require("./balance-message.service");
+const transaction_service_1 = require("./transaction.service");
+const agent_factory_1 = require("../ai/agent-factory");
+const room_factory_1 = require("../room/room-factory");
+let UserServiceFactory = class UserServiceFactory {
+    aiFactoryService;
+    agentMessageService;
+    roomMessageService;
+    storyProgressService;
+    storyMessageService;
+    publishedAgentsService;
+    publishedRoomsService;
+    balanceMessageService;
+    constructor(aiFactoryService, agentMessageService, roomMessageService, storyProgressService, storyMessageService, publishedAgentsService, publishedRoomsService, balanceMessageService) {
+        this.aiFactoryService = aiFactoryService;
+        this.agentMessageService = agentMessageService;
+        this.roomMessageService = roomMessageService;
+        this.storyProgressService = storyProgressService;
+        this.storyMessageService = storyMessageService;
+        this.publishedAgentsService = publishedAgentsService;
+        this.publishedRoomsService = publishedRoomsService;
+        this.balanceMessageService = balanceMessageService;
+    }
+    createAppService(userId) {
+        const configService = new configuration_service_1.ConfigurationService(userId);
+        const balanceService = new balance_service_1.BalanceService(userId, configService, this.balanceMessageService);
+        const transactionService = new transaction_service_1.TransactionService(userId, configService);
+        const attachedFileService = new attached_file_service_1.AttachedFileService(configService);
+        const artifactService = new artifact_service_1.ArtifactService(configService);
+        const agentStore = new agent_store_service_1.AgentStoreService(this.aiFactoryService, configService, attachedFileService, balanceService, artifactService);
+        const agentFactory = new agent_factory_1.AgentFactory(this.aiFactoryService, agentStore, configService, balanceService, artifactService);
+        const artifactStore = new artifact_store_service_1.ArtifactStoreService();
+        const roomStore = new room_store_service_1.RoomStoreService(configService, agentStore, attachedFileService, artifactStore);
+        const roomFactory = new room_factory_1.RoomFactory(roomStore);
+        const storyStore = new story_store_service_1.StoryStoreService(configService, roomStore);
+        const storyService = new story_service_1.StoryService(storyStore, agentStore, roomStore, this.storyProgressService, this.storyMessageService, configService, agentFactory, roomFactory);
+        return new app_service_1.AppService(this.aiFactoryService, agentStore, this.agentMessageService, roomStore, this.roomMessageService, configService, attachedFileService, artifactService, storyStore, storyService, this.publishedAgentsService, this.publishedRoomsService, balanceService, this.balanceMessageService, transactionService, agentFactory, roomFactory);
+    }
+};
+exports.UserServiceFactory = UserServiceFactory;
+exports.UserServiceFactory = UserServiceFactory = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [ai_factory_service_1.AiFactoryService,
+        agent_message_service_1.AgentMessageService,
+        room_message_service_1.RoomMessageService,
+        story_progress_service_1.StoryProgressService,
+        story_message_service_1.StoryMessageService,
+        published_agents_service_1.PublishedAgentsService,
+        published_rooms_service_1.PublishedRoomsService,
+        balance_message_service_1.BalanceMessageService])
+], UserServiceFactory);

package/dist/app/user-service-manager.d.ts

@@ -0,0 +1,28 @@
+import { OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { AppService } from '../app.service';
+import { UserServiceFactory } from './user-service-factory';
+export interface IConfigService {
+    get<T = string>(key: string, defaultValue?: T): T;
+}
+export declare class UserServiceManager implements OnModuleInit, OnModuleDestroy {
+    private readonly userServiceFactory;
+    private readonly configService;
+    private userServices;
+    private cleanupIntervalId;
+    private readonly cacheTimeoutMinutes;
+    private readonly cleanupIntervalMinutes;
+    constructor(userServiceFactory: UserServiceFactory, configService: ConfigService);
+    onModuleInit(): void;
+    onModuleDestroy(): void;
+    getAppService(userId: string): AppService;
+    removeUserService(userId: string): void;
+    getCacheStats(): {
+        cachedUsers: number;
+        users: {
+            userId: string;
+            ageMinutes: number;
+        }[];
+    };
+    private cleanupInactiveUsers;
+}

package/dist/app/user-service-manager.js

@@ -0,0 +1,102 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserServiceManager = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const user_service_factory_1 = require("./user-service-factory");
+let UserServiceManager = class UserServiceManager {
+    userServiceFactory;
+    configService;
+    userServices = new Map();
+    cleanupIntervalId = null;
+    cacheTimeoutMinutes;
+    cleanupIntervalMinutes = 5;
+    constructor(userServiceFactory, configService) {
+        this.userServiceFactory = userServiceFactory;
+        this.configService = configService;
+        this.cacheTimeoutMinutes = parseInt(this.configService.get('USER_SERVICE_CACHE_TIMEOUT_MINUTES', '30'));
+    }
+    onModuleInit() {
+        if (this.cleanupIntervalId) {
+            return;
+        }
+        this.cleanupIntervalId = setInterval(() => this.cleanupInactiveUsers(), this.cleanupIntervalMinutes * 60 * 1000);
+    }
+    onModuleDestroy() {
+        if (this.cleanupIntervalId) {
+            clearInterval(this.cleanupIntervalId);
+            this.cleanupIntervalId = null;
+            this.userServices.clear();
+            console.log('[UserServiceManager] Shutdown complete');
+        }
+    }
+    getAppService(userId) {
+        const now = Date.now();
+        const context = this.userServices.get(userId);
+        if (context) {
+            const ageMinutes = (now - context.lastAccessed) / (60 * 1000);
+            if (ageMinutes < this.cacheTimeoutMinutes) {
+                context.lastAccessed = now;
+                return context.appService;
+            }
+            else {
+                console.log(`[UserServiceManager] Cache expired for user ${userId} (${ageMinutes.toFixed(1)}min old)`);
+                this.userServices.delete(userId);
+            }
+        }
+        const appService = this.userServiceFactory.createAppService(userId);
+        this.userServices.set(userId, {
+            appService,
+            lastAccessed: now,
+        });
+        return appService;
+    }
+    removeUserService(userId) {
+        if (this.userServices.delete(userId)) {
+            console.log(`[UserServiceManager] Manually removed service for user ${userId}`);
+        }
+    }
+    getCacheStats() {
+        const now = Date.now();
+        const users = Array.from(this.userServices.entries()).map(([userId, context]) => ({
+            userId,
+            ageMinutes: (now - context.lastAccessed) / (60 * 1000),
+        }));
+        return {
+            cachedUsers: this.userServices.size,
+            users,
+        };
+    }
+    cleanupInactiveUsers() {
+        const now = Date.now();
+        const timeoutMs = this.cacheTimeoutMinutes * 60 * 1000;
+        let removedCount = 0;
+        for (const [userId, context] of this.userServices.entries()) {
+            const age = now - context.lastAccessed;
+            if (age > timeoutMs) {
+                this.userServices.delete(userId);
+                removedCount++;
+                const ageMinutes = age / (60 * 1000);
+                console.log(`[UserServiceManager] Cleaned up service for user ${userId} (${ageMinutes.toFixed(1)}min inactive)`);
+            }
+        }
+        if (removedCount > 0) {
+            console.log(`[UserServiceManager] Cleanup complete: removed ${removedCount} inactive user(s), ${this.userServices.size} remaining`);
+        }
+    }
+};
+exports.UserServiceManager = UserServiceManager;
+exports.UserServiceManager = UserServiceManager = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [user_service_factory_1.UserServiceFactory,
+        config_1.ConfigService])
+], UserServiceManager);

package/dist/app.controller.d.ts

@@ -0,0 +1,232 @@
+import { MessageEvent } from '@nestjs/common';
+import { Request as ExpressRequest, Response } from 'express';
+import { Observable } from 'rxjs';
+import { UserServiceManager } from './app/user-service-manager';
+import { PublishedAgentsService } from './ai/published-agents.service';
+import { PublishedRoomsService } from './room/published-rooms.service';
+import { AgentInfo, CreateAgentResponse, UpdateAgentRequest, RoomInfo, RoomDetails, CreateRoomResponse, AgentMessagesResponse, RoomMessagesResponse, FileList, PromptFileContent, PromptFoldersResponse, PromptFilesResponse, PromptScope, CreatePromptFolderRequest, CreatePromptFileRequest, UpdatePromptFileRequest, ProcessTextResponse, PreparedPromptResponse, AttachDocumentResponse, StoryInfo, StoryState, Character, ModelInfo, StoryModelDefaults, ChapterInfo, StoryIdea } from '@shared/types/app.types';
+import { RoomMessage } from './room/message';
+export declare class AppController {
+    private readonly userServiceManager;
+    private readonly publishedAgentsService;
+    private readonly publishedRoomsService;
+    constructor(userServiceManager: UserServiceManager, publishedAgentsService: PublishedAgentsService, publishedRoomsService: PublishedRoomsService);
+    private getAppService;
+    listServices(req: ExpressRequest): string[];
+    listModels(req: ExpressRequest, aiServiceName: string): Promise<ModelInfo[]>;
+    listImageModels(req: ExpressRequest): Promise<ModelInfo[]>;
+    listStoryModels(req: ExpressRequest): Promise<ModelInfo[]>;
+    listStoryModelDefaults(_req: ExpressRequest): StoryModelDefaults;
+    createAgent(req: ExpressRequest, body: {
+        aiServiceName: string;
+        agentName: string;
+        agentNickname?: string;
+        description: string;
+        aiModel: string;
+        promptName: string;
+        controlledByHuman?: boolean;
+        reasoningEffort?: 'low' | 'medium' | 'high' | null;
+        maxOutputTokens?: number;
+        beginInstruction?: string;
+    }): Promise<CreateAgentResponse>;
+    processText(req: ExpressRequest, agentId: string, body: {
+        text: string;
+    }): Promise<ProcessTextResponse>;
+    attachDocument(req: ExpressRequest, agentId: string, body: {
+        fileName?: string;
+    }, file: Express.Multer.File): Promise<AttachDocumentResponse>;
+    listAttachedFiles(req: ExpressRequest, agentId: string): Promise<FileList>;
+    getPrompts(req: ExpressRequest, scope?: PromptScope): PromptFoldersResponse;
+    createPromptFolder(req: ExpressRequest, body: CreatePromptFolderRequest): Promise<void>;
+    deletePromptFolder(req: ExpressRequest, folderName: string): Promise<void>;
+    getPromptFiles(req: ExpressRequest, folderName: string): Promise<PromptFilesResponse>;
+    getPromptFile(req: ExpressRequest, folderName: string, fileName: string): Promise<PromptFileContent>;
+    createPromptFile(req: ExpressRequest, folderName: string, body: CreatePromptFileRequest): Promise<void>;
+    updatePromptFile(req: ExpressRequest, folderName: string, fileName: string, body: UpdatePromptFileRequest): Promise<void>;
+    deletePromptFile(req: ExpressRequest, folderName: string, fileName: string): Promise<void>;
+    listPromptFolders(req: ExpressRequest): string[];
+    listPrompts(req: ExpressRequest, agentId: string): string[];
+    runPreparedPrompt(req: ExpressRequest, agentId: string, promptName: string, body: {
+        variables?: any;
+    }): Promise<PreparedPromptResponse>;
+    listAgents(req: ExpressRequest, published?: string): Promise<AgentInfo[]>;
+    createRoom(req: ExpressRequest, body: {
+        roomName: string;
+        roomGoal: string;
+        agentIds: string[];
+    }): Promise<CreateRoomResponse>;
+    editRoom(req: ExpressRequest, roomId: string, body: {
+        roomName: string;
+        roomGoal: string;
+        baseRoomDir?: string;
+        agentIds: string[];
+    }): Promise<void>;
+    listRooms(req: ExpressRequest): RoomInfo[];
+    getRoomDetails(req: ExpressRequest, roomId: string): Promise<RoomDetails>;
+    getAgentDetails(req: ExpressRequest, agentId: string): Promise<AgentInfo>;
+    getRoomMessages(req: ExpressRequest, roomId: string, fromIndex: string, showThoughts?: string): RoomMessagesResponse;
+    getAgentMessages(req: ExpressRequest, agentId: string, fromIndex: string): Promise<AgentMessagesResponse>;
+    getStoryMessages(req: ExpressRequest, storyId: string, fromIndex: string): RoomMessagesResponse;
+    deleteAgent(req: ExpressRequest, agentId: string): Promise<void>;
+    publishAgentInstance(req: ExpressRequest, agentId: string, body: {
+        publishedAgentName: string;
+    }): Promise<{
+        instanceId: string;
+        publicUrl: string;
+    }>;
+    getPublishedInstances(req: ExpressRequest, agentId: string): Promise<AgentInfo[]>;
+    resetPublishedInstance(req: ExpressRequest, instanceId: string): Promise<void>;
+    deleteRoom(req: ExpressRequest, roomId: string): Promise<void>;
+    sendRoomMessage(req: ExpressRequest, roomId: string, body: {
+        content: string;
+        sender: string;
+        action?: string;
+        targets?: string[];
+        clearQueue?: boolean;
+    }): Promise<void>;
+    pauseRoom(req: ExpressRequest, roomId: string): Promise<{
+        success: boolean;
+    }>;
+    resumeRoom(req: ExpressRequest, roomId: string): Promise<{
+        success: boolean;
+    }>;
+    getUserPreferences(req: ExpressRequest): Promise<any>;
+    saveUserPreferences(req: ExpressRequest, preferences: any): Promise<void>;
+    listPromptFilesDeprecated(req: ExpressRequest, folderName: string): Promise<FileList>;
+    getPromptFileDeprecated(req: ExpressRequest, folderName: string, fileName: string): Promise<PromptFileContent>;
+    savePromptFileDeprecated(req: ExpressRequest, body: {
+        folderName: string;
+        fileName: string;
+        content: string;
+        fileType: string;
+    }): Promise<void>;
+    deletePromptFileDeprecated(req: ExpressRequest, body: {
+        folderName: string;
+        fileName: string;
+    }): Promise<void>;
+    deletePromptFolderDeprecated(req: ExpressRequest, body: {
+        folderName: string;
+    }): Promise<void>;
+    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>;
+    resetRoom(req: ExpressRequest, roomId: string): Promise<void>;
+    publishRoom(req: ExpressRequest, templateId: string, body: {
+        publishedName?: string;
+    }): Promise<{
+        roomId: string;
+    }>;
+    getPublishedRoomInstances(req: ExpressRequest, templateId: string): Promise<RoomInfo[]>;
+    resetPublishedRoomInstance(req: ExpressRequest, instanceId: string): Promise<void>;
+    resetStory(req: ExpressRequest, storyId: string): Promise<void>;
+    getRoomArtifacts(req: ExpressRequest, roomId: string): Promise<{
+        artifacts: any[];
+    }>;
+    publishArtifact(req: ExpressRequest, roomId: string, body: {
+        name: string;
+        creator: string;
+        body: string;
+        viewers?: string[];
+    }): Promise<void>;
+    createPromptFolderDeprecated(req: ExpressRequest, body: {
+        folderName: string;
+    }): Promise<void>;
+    listStories(req: ExpressRequest): StoryInfo[];
+    listStoryGenres(req: ExpressRequest): string[];
+    getRandomStoryIdea(req: ExpressRequest): Promise<StoryIdea | null>;
+    getStoryIdeasByGenre(req: ExpressRequest, genreName: string): Promise<StoryIdea | null>;
+    createStory(req: ExpressRequest, body: {
+        name: string;
+        idea: string;
+        userCharacterDesc: string;
+        otherCharactersDesc: string;
+        storyModel?: string;
+        isImport?: boolean;
+        imageModelName?: string;
+    }): Promise<StoryInfo>;
+    importStoryZip(req: ExpressRequest, file: Express.Multer.File): Promise<StoryInfo>;
+    deleteStory(req: ExpressRequest, storyId: string): Promise<void>;
+    compactStory(req: ExpressRequest, storyId: string): Promise<void>;
+    progressStory(req: ExpressRequest, storyId: string): Promise<{
+        chapterIndex: number;
+    }>;
+    getStoryState(req: ExpressRequest, storyId: string): Promise<StoryState>;
+    respondToStory(req: ExpressRequest, storyId: string, body: {
+        content: string;
+    }): Promise<void>;
+    introduceCharacter(req: ExpressRequest, storyId: string, body: {
+        name: string;
+        description?: string;
+        storyModel?: string;
+        fromNarratorSuggestion?: boolean;
+    }): Promise<void>;
+    declineCharacter(req: ExpressRequest, storyId: string, characterName: string): Promise<{
+        success: boolean;
+    }>;
+    deleteCharacter(req: ExpressRequest, storyId: string, characterName: string): Promise<void>;
+    listChapters(req: ExpressRequest, storyId: string): {
+        chapters: ChapterInfo[];
+    };
+    getChapter(req: ExpressRequest, storyId: string, chapterIndex: string): Promise<{
+        content: RoomMessage[];
+    }>;
+    saveChapter(req: ExpressRequest, storyId: string, chapterIndex: string, body: {
+        content: string;
+    }): void;
+    deleteChapter(req: ExpressRequest, storyId: string, chapterIndex: string): void;
+    exportStoryMarkdown(req: ExpressRequest, storyId: string, res: Response): Promise<void>;
+    exportStoryZip(req: ExpressRequest, storyId: string, res: Response): Promise<void>;
+    listCharacters(req: ExpressRequest, storyId: string): Promise<Character[]>;
+    getCharacter(req: ExpressRequest, storyId: string, characterName: string): Promise<{
+        content: string;
+    }>;
+    saveCharacter(req: ExpressRequest, storyId: string, characterName: string, body: {
+        content: string;
+    }): Promise<void>;
+    getPlotPlan(req: ExpressRequest, storyId: string): Promise<{
+        content: string;
+    }>;
+    getAgentHistory(req: ExpressRequest, storyId: string, agentId: string): Promise<{
+        content: string;
+    }>;
+    savePlotPlan(req: ExpressRequest, storyId: string, body: {
+        content: string;
+    }): Promise<void>;
+    listStoryArtifacts(req: ExpressRequest, storyId: string): Promise<{
+        artifacts: any[];
+    }>;
+    getStoryArtifact(req: ExpressRequest, storyId: string, artifactId: string, res: Response): Promise<void>;
+    storyProgress(req: ExpressRequest, storyId: string): Observable<MessageEvent>;
+    storyMessages(req: ExpressRequest, storyId: string): Observable<MessageEvent>;
+    agentMessages(req: ExpressRequest, agentId: string): Promise<Observable<MessageEvent>>;
+    roomMessages(req: ExpressRequest, roomId: string): Promise<Observable<MessageEvent>>;
+    balanceUpdates(req: ExpressRequest): Observable<MessageEvent>;
+    getBalance(req: ExpressRequest): Promise<{
+        balance: number;
+    }>;
+    listArtifacts(req: ExpressRequest): Promise<{
+        artifacts: any[];
+    }>;
+    getArtifact(req: ExpressRequest, artifactId: string): Promise<{
+        content: string;
+    }>;
+    createArtifact(req: ExpressRequest, body: {
+        name: string;
+    }, file: Express.Multer.File): Promise<{
+        artifactId: string;
+    }>;
+    updateArtifact(req: ExpressRequest, artifactId: string, body: {
+        content: string;
+    }): Promise<void>;
+    renameArtifact(req: ExpressRequest, artifactId: string, body: {
+        name: string;
+    }): Promise<void>;
+    deleteArtifact(req: ExpressRequest, artifactId: string): Promise<void>;
+    listAgentArtifacts(req: ExpressRequest, agentId: string): Promise<{
+        artifacts: any[];
+    }>;
+    attachArtifactToAgent(req: ExpressRequest, agentId: string, body: {
+        artifactId: string;
+    }): Promise<void>;
+    detachArtifactFromAgent(req: ExpressRequest, agentId: string, artifactId: string): Promise<void>;
+}