briyah 1.0.0

package/dist/app.service.js

@@ -0,0 +1,1334 @@
+"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.AppService = void 0;
+const errors_1 = require("./common/errors");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const app_types_1 = require("@shared/types/app.types");
+const pdf_lib_1 = require("pdf-lib");
+const message_1 = require("./room/message");
+class AppService {
+    aiFactoryService;
+    agentStore;
+    agentMessageService;
+    roomStore;
+    roomMessageService;
+    configService;
+    attachedFileService;
+    artifactService;
+    storyStore;
+    storyService;
+    publishedAgentsService;
+    publishedRoomsService;
+    balanceService;
+    balanceMessageService;
+    transactionService;
+    agentFactory;
+    roomFactory;
+    aiServices;
+    userPreferencesFile = 'user-preferences.json';
+    constructor(aiFactoryService, agentStore, agentMessageService, roomStore, roomMessageService, configService, attachedFileService, artifactService, storyStore, storyService, publishedAgentsService, publishedRoomsService, balanceService, balanceMessageService, transactionService, agentFactory, roomFactory) {
+        this.aiFactoryService = aiFactoryService;
+        this.agentStore = agentStore;
+        this.agentMessageService = agentMessageService;
+        this.roomStore = roomStore;
+        this.roomMessageService = roomMessageService;
+        this.configService = configService;
+        this.attachedFileService = attachedFileService;
+        this.artifactService = artifactService;
+        this.storyStore = storyStore;
+        this.storyService = storyService;
+        this.publishedAgentsService = publishedAgentsService;
+        this.publishedRoomsService = publishedRoomsService;
+        this.balanceService = balanceService;
+        this.balanceMessageService = balanceMessageService;
+        this.transactionService = transactionService;
+        this.agentFactory = agentFactory;
+        this.roomFactory = roomFactory;
+        this.aiServices = this.aiFactoryService.getAllAiServices();
+    }
+    getAiServiceNames() {
+        return this.aiServices.map((s) => s.getServiceName());
+    }
+    getAiServiceFromServiceName(serviceName) {
+        return this.aiFactoryService.createAiService(serviceName);
+    }
+    async listAiModels(aiServiceName) {
+        let service = this.getAiServiceFromServiceName(aiServiceName);
+        return service.listModels();
+    }
+    async listImageModels() {
+        const imageModelsPath = path.join(this.configService.getCommonConfigDir(), 'image_models.json');
+        try {
+            return JSON.parse(fs.readFileSync(imageModelsPath, 'utf8'));
+        }
+        catch (error) {
+            console.error(`Image models file could not be read from ${imageModelsPath}: `, error);
+            return [];
+        }
+    }
+    async listStoryModels() {
+        const storyModelsPath = path.join(this.configService.getCommonConfigDir(), 'story_models.json');
+        try {
+            return JSON.parse(fs.readFileSync(storyModelsPath, 'utf8'));
+        }
+        catch (error) {
+            console.error(`Story models file could not be read from ${storyModelsPath}: `, error);
+            return [];
+        }
+    }
+    listStoryGenres() {
+        const storyIdeasPath = path.join(this.configService.getDataDir(), 'common', 'story_ideas');
+        try {
+            if (!fs.existsSync(storyIdeasPath)) {
+                console.warn(`Story ideas directory does not exist: ${storyIdeasPath}`);
+                return [];
+            }
+            return fs.readdirSync(storyIdeasPath)
+                .filter(file => file.endsWith('.json'))
+                .map(file => file.replace('.json', ''));
+        }
+        catch (error) {
+            console.error('Error reading story genres:', error);
+            return [];
+        }
+    }
+    getRandomStoryIdeaByGenre(genreName) {
+        const storyIdeasPath = path.join(this.configService.getDataDir(), 'common', 'story_ideas', `${genreName}.json`);
+        try {
+            if (!fs.existsSync(storyIdeasPath)) {
+                throw new errors_1.NotFoundError(`Genre "${genreName}" not found`);
+            }
+            const ideas = JSON.parse(fs.readFileSync(storyIdeasPath, 'utf8'));
+            if (ideas.length === 0) {
+                return null;
+            }
+            const randomIndex = Math.floor(Math.random() * ideas.length);
+            return ideas[randomIndex];
+        }
+        catch (error) {
+            if (error instanceof errors_1.NotFoundError) {
+                throw error;
+            }
+            console.error(`Error reading story ideas for genre ${genreName}:`, error);
+            throw new errors_1.OperationFailedError('Failed to read story ideas');
+        }
+    }
+    getRandomStoryIdea() {
+        const genres = this.listStoryGenres();
+        if (genres.length === 0) {
+            return null;
+        }
+        const randomGenre = genres[Math.floor(Math.random() * genres.length)];
+        return this.getRandomStoryIdeaByGenre(randomGenre);
+    }
+    createAgent(aiServiceName, agentName, agentNickname, description, aiModel, promptName = 'default', controlledByHuman, reasoningEffort, maxOutputTokens, beginInstruction) {
+        const agent = this.agentFactory.createAgent(aiServiceName, agentName, agentNickname, description, promptName, aiModel);
+        if (controlledByHuman !== undefined) {
+            agent.isControlledByHuman = controlledByHuman;
+        }
+        if (reasoningEffort !== undefined) {
+            agent.reasoningEffort = reasoningEffort;
+        }
+        if (maxOutputTokens !== undefined) {
+            agent.maxOutputTokens = maxOutputTokens;
+        }
+        if (beginInstruction !== undefined) {
+            agent.beginInstruction = beginInstruction;
+        }
+        this.setupAgentStateCallback(agent);
+        return agent;
+    }
+    async processText(agentId, text) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError(`Agent with ID ${agentId} not found`);
+        }
+        this.setupAgentStateCallback(agent);
+        const result = await agent.textPrompt(text, null, true, null, true);
+        agent.save();
+        const messages = agent.getFormattedMessages();
+        return {
+            result,
+            latestMessage: messages[messages.length - 1],
+            messageIndex: messages.length - 1,
+            totalInputTokens: agent.totalInputTokens,
+            totalOutputTokens: agent.totalOutputTokens,
+            totalCost: agent.totalCost,
+        };
+    }
+    async attachDocument(agentId, fileName, fileData) {
+        let agent = await this.agentStore.getAgent(agentId);
+        if (!agent)
+            throw new Error(`Agent with ID ${agentId} not found`);
+        const fileId = this.attachedFileService.storeFile(agentId, fileName, new Uint8Array(fileData));
+        const fileMetadata = this.attachedFileService.getFileMetadataByName(agentId, fileName);
+        if (fileMetadata && !agent.attachedFiles.some((f) => f.fileName === fileName)) {
+            agent.attachedFiles.push(fileMetadata);
+        }
+        await agent.attachDocument(fileName, new Uint8Array(fileData));
+        agent.save();
+        return { documentId: fileId };
+    }
+    listPromptFolders() {
+        const folders = new Set();
+        const commonDir = this.configService.getCommonPromptsDir();
+        if (fs.existsSync(commonDir)) {
+            fs.readdirSync(commonDir, { withFileTypes: true })
+                .filter((dirent) => dirent.isDirectory())
+                .forEach((dirent) => folders.add(dirent.name));
+        }
+        const userDir = this.configService.getUserPromptsDir();
+        if (fs.existsSync(userDir)) {
+            fs.readdirSync(userDir, { withFileTypes: true })
+                .filter((dirent) => dirent.isDirectory())
+                .forEach((dirent) => folders.add(dirent.name));
+        }
+        return Array.from(folders).sort();
+    }
+    listPromptFoldersWithScope(scope) {
+        const folders = [];
+        const folderMap = new Map();
+        const commonDir = this.configService.getCommonPromptsDir();
+        if ((!scope || scope === 'common') && fs.existsSync(commonDir)) {
+            fs.readdirSync(commonDir, { withFileTypes: true })
+                .filter((dirent) => dirent.isDirectory())
+                .forEach((dirent) => {
+                folderMap.set(dirent.name, 'common');
+            });
+        }
+        const userDir = this.configService.getUserPromptsDir();
+        if ((!scope || scope === 'user') && fs.existsSync(userDir)) {
+            fs.readdirSync(userDir, { withFileTypes: true })
+                .filter((dirent) => dirent.isDirectory())
+                .forEach((dirent) => {
+                folderMap.set(dirent.name, 'user');
+            });
+        }
+        folderMap.forEach((folderScope, name) => {
+            folders.push({ name, scope: folderScope });
+        });
+        folders.sort((a, b) => a.name.localeCompare(b.name));
+        return { folders };
+    }
+    async listPrompts(agentId) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError(`Agent with ID ${agentId} not found`);
+        }
+        let agentPromptsDir = path.join(this.configService.getPromptsDir(), agent.promptFolder);
+        let promptFiles = [];
+        if (fs.existsSync(agentPromptsDir)) {
+            promptFiles = fs
+                .readdirSync(agentPromptsDir)
+                .filter((file) => file.endsWith('.prompt') && file !== 'system_instruction.prompt')
+                .map((file) => file.replace('.prompt', ''));
+        }
+        const rootPromptFiles = fs
+            .readdirSync(this.configService.getPromptsDir())
+            .filter((file) => file.endsWith('.prompt') && file !== 'system_instruction.prompt')
+            .map((file) => file.replace('.prompt', ''));
+        promptFiles = [...new Set([...promptFiles, ...rootPromptFiles])];
+        return promptFiles;
+    }
+    async runPreparedPrompt(agentId, promptName, variables = {}) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError(`Agent with ID ${agentId} not found`);
+        }
+        const serviceName = agent.serviceName;
+        let service = this.getAiServiceFromServiceName(serviceName);
+        const result = await service.preparedPrompt(agent, promptName, variables || {}, true);
+        return { result };
+    }
+    async listAgents() {
+        const agentIds = await this.agentStore.getAllAgentIds();
+        const agentInfos = [];
+        for (const id of agentIds) {
+            const agent = await this.agentStore.getAgent(id);
+            if (agent) {
+                if (agent.ownerRoomId)
+                    continue;
+                agentInfos.push({
+                    id,
+                    name: agent.agentName,
+                    agentNickname: agent.agentNickname,
+                    description: agent.description,
+                    aiService: agent.serviceName,
+                    aiModel: agent.modelName,
+                    promptFolder: agent.promptFolder,
+                    reasoningEffort: agent.reasoningEffort,
+                    allowSearch: agent.allowSearch,
+                    maxOutputTokens: agent.maxOutputTokens,
+                    controlledByHuman: agent.isControlledByHuman,
+                    totalInputTokens: agent.totalInputTokens,
+                    totalOutputTokens: agent.totalOutputTokens,
+                    totalCost: agent.totalCost,
+                    isPublished: agent.isPublished,
+                    beginInstruction: agent.beginInstruction,
+                });
+            }
+        }
+        return agentInfos;
+    }
+    async getAgentDetails(agentId) {
+        try {
+            const agent = await this.agentStore.getAgent(agentId);
+            if (!agent) {
+                return null;
+            }
+            return {
+                id: agentId,
+                name: agent.agentName,
+                agentNickname: agent.agentNickname,
+                description: agent.description,
+                aiService: agent.serviceName,
+                aiModel: agent.modelName,
+                promptFolder: agent.promptFolder,
+                reasoningEffort: agent.reasoningEffort,
+                allowSearch: agent.allowSearch,
+                maxOutputTokens: agent.maxOutputTokens,
+                controlledByHuman: agent.isControlledByHuman,
+                totalInputTokens: agent.totalInputTokens,
+                totalOutputTokens: agent.totalOutputTokens,
+                totalCost: agent.totalCost,
+                isPublished: agent.isPublished,
+                beginInstruction: agent.beginInstruction,
+            };
+        }
+        catch (error) {
+            console.error('Error getting agent details:', error);
+            return null;
+        }
+    }
+    async createRoom(roomName, goal, agentIds) {
+        for (const agentId of agentIds) {
+            const agent = await this.agentStore.getAgent(agentId);
+            if (!agent) {
+                throw new errors_1.NotFoundError(`Agent with ID ${agentId} not found`);
+            }
+        }
+        const room = this.roomFactory.createRoom(roomName, goal);
+        for (const agentId of agentIds) {
+            const agent = await this.agentStore.getAgent(agentId);
+            room.arrive(agent);
+        }
+        room.ready();
+        const roomId = room.saveMetadata();
+        this.setupRoomStateCallback(room);
+        return { roomId };
+    }
+    async editRoom(roomId, roomName, goal, baseRoomDir, agentIds = []) {
+        const room = await this.roomStore.getRoom(roomId);
+        if (!room) {
+            throw new errors_1.NotFoundError('Room not found');
+        }
+        if (room.getIsPublished() && room.getTemplateRoomId()) {
+            throw new errors_1.OperationFailedError('Cannot edit published room instances');
+        }
+        room.setName(roomName);
+        room.setGoal(goal);
+        room.setBaseRoomDir(baseRoomDir || '');
+        const newAgents = [];
+        for (const agentId of agentIds) {
+            const agent = await this.agentStore.getAgent(agentId);
+            if (agent) {
+                newAgents.push(agent);
+            }
+            else {
+                console.warn(`Agent ${agentId} not found when editing room ${roomName}`);
+            }
+        }
+        room.setAgents(newAgents);
+        room.saveMetadata();
+    }
+    async listRooms() {
+        return await this.roomStore.getAllRooms();
+    }
+    async getRoomDetails(roomId) {
+        const room = await this.roomStore.getRoom(roomId);
+        if (!room) {
+            return null;
+        }
+        const roomAgents = room.getAgents();
+        const agents = [];
+        for (const agent of roomAgents) {
+            const agentDetails = await this.getAgentDetails(agent.id);
+            if (agentDetails) {
+                agents.push(agentDetails);
+            }
+        }
+        return {
+            id: roomId,
+            name: room.getName(),
+            goal: room.getGoal(),
+            agentIds: roomAgents.map((agent) => agent.id),
+            agents,
+            baseRoomDir: room.getBaseRoomDir(),
+            isPublished: room.getIsPublished(),
+        };
+    }
+    async getRoomById(roomId) {
+        return await this.roomStore.getRoom(roomId);
+    }
+    async getRoomMessages(roomId, fromIndex = 0, includeThoughts = false) {
+        const room = await this.roomStore.getRoom(roomId);
+        if (!room) {
+            return {
+                messages: [],
+                totalCost: 0,
+            };
+        }
+        const indexedMessages = room.getLatestRoomMessages(fromIndex, includeThoughts);
+        const totalCost = room
+            .getAgents()
+            .map((a) => a.totalCost)
+            .reduce((acc, v) => acc + v, 0);
+        return {
+            messages: indexedMessages,
+            totalCost: totalCost,
+        };
+    }
+    async getAgentMessages(agentId, fromIndex = 0) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            return {
+                messages: [],
+                totalOutputTokens: 0,
+                totalInputTokens: 0,
+                totalCost: 0,
+            };
+        }
+        this.setupAgentStateCallback(agent);
+        const formattedMessages = agent.getFormattedMessages(fromIndex);
+        return {
+            messages: formattedMessages,
+            totalOutputTokens: agent.totalOutputTokens,
+            totalInputTokens: agent.totalInputTokens,
+            totalCost: agent.totalCost,
+        };
+    }
+    async getStoryMessages(storyId, fromIndex) {
+        const story = this.storyStore.getStory(storyId);
+        if (!story) {
+            return { messages: [], totalCost: 0 };
+        }
+        const room = await this.roomStore.getRoom(story.roomId);
+        if (!room) {
+            return { messages: [], totalCost: 0 };
+        }
+        const messages = room.getLatestRoomMessages(fromIndex, true);
+        const totalCost = story.totalCost || 0;
+        return { messages, totalCost };
+    }
+    async sendRoomMessage(roomId, content, sender, action = 'moderate', targets = [], clearQueue = false) {
+        const room = await this.roomStore.getRoom(roomId);
+        if (!room) {
+            throw new errors_1.NotFoundError('Room not found');
+        }
+        let messageAction;
+        switch (action.toLowerCase()) {
+            case 'moderate':
+                messageAction = app_types_1.MessageAction.MODERATE;
+                break;
+            case 'whisper':
+                messageAction = app_types_1.MessageAction.WHISPER;
+                break;
+            case 'shout':
+                messageAction = app_types_1.MessageAction.SHOUT;
+                break;
+            case 'think':
+                messageAction = app_types_1.MessageAction.THINK;
+                break;
+            default:
+                messageAction = app_types_1.MessageAction.SPEAK;
+        }
+        room.ready();
+        room.addPendingMessage(new message_1.RoomMessage(sender, messageAction, content, targets), clearQueue);
+    }
+    async pauseRoom(roomId) {
+        const room = await this.roomStore.getRoom(roomId);
+        if (!room) {
+            throw new errors_1.NotFoundError('Room not found');
+        }
+        room.pause();
+    }
+    async resumeRoom(roomId) {
+        const room = await this.roomStore.getRoom(roomId);
+        if (!room) {
+            throw new errors_1.NotFoundError('Room not found');
+        }
+        room.resume();
+    }
+    async deleteAgent(agentId) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError('Agent not found');
+        }
+        if (agent.isPublished) {
+            this.publishedAgentsService.removePublishedAgent(agentId);
+        }
+        await agent.deleteAgent();
+    }
+    async publishAgentInstance(templateId, instanceName) {
+        const template = await this.agentStore.getAgent(templateId);
+        if (!template) {
+            throw new errors_1.NotFoundError('Template agent not found');
+        }
+        const userId = this.configService.getUserId();
+        const instanceId = await this.agentStore.cloneAgentAsPublished(templateId, instanceName, userId);
+        this.publishedAgentsService.addPublishedAgent(instanceId, userId);
+        return {
+            instanceId,
+            publicUrl: `/public/agents/${instanceId}`,
+        };
+    }
+    async getPublishedInstances(templateId) {
+        const instances = await this.agentStore.getPublishedInstances(templateId);
+        return instances.map((agent) => ({
+            id: agent.id,
+            name: agent.agentName,
+            agentNickname: agent.agentNickname,
+            description: agent.description,
+            aiService: agent.serviceName,
+            aiModel: agent.modelName,
+            promptFolder: agent.promptFolder,
+            reasoningEffort: agent.reasoningEffort,
+            allowSearch: agent.allowSearch,
+            maxOutputTokens: agent.maxOutputTokens,
+            controlledByHuman: agent.isControlledByHuman,
+            totalInputTokens: agent.totalInputTokens,
+            totalOutputTokens: agent.totalOutputTokens,
+            totalCost: agent.totalCost,
+            isPublished: agent.isPublished,
+            beginInstruction: agent.beginInstruction,
+        }));
+    }
+    async resetPublishedInstance(instanceId) {
+        const instance = await this.agentStore.getAgent(instanceId);
+        if (!instance) {
+            throw new errors_1.NotFoundError('Instance agent not found');
+        }
+        if (!instance.templateAgentId) {
+            throw new errors_1.OperationFailedError('Agent is not a published instance');
+        }
+        await this.agentStore.resetPublishedInstance(instanceId, instance.templateAgentId);
+    }
+    async listPublishedAgents() {
+        const agentIds = await this.agentStore.getAllAgentIds();
+        const agents = [];
+        for (const id of agentIds) {
+            const agent = await this.agentStore.getAgent(id);
+            if (agent && agent.isPublished && !agent.ownerRoomId) {
+                agents.push({
+                    id: agent.id,
+                    name: agent.agentName,
+                    agentNickname: agent.agentNickname,
+                    description: agent.description,
+                    aiService: agent.serviceName,
+                    aiModel: agent.modelName,
+                    promptFolder: agent.promptFolder,
+                    reasoningEffort: agent.reasoningEffort,
+                    allowSearch: agent.allowSearch,
+                    maxOutputTokens: agent.maxOutputTokens,
+                    controlledByHuman: agent.isControlledByHuman,
+                    totalInputTokens: agent.totalInputTokens,
+                    totalOutputTokens: agent.totalOutputTokens,
+                    totalCost: agent.totalCost,
+                    isPublished: agent.isPublished,
+                    beginInstruction: agent.beginInstruction,
+                });
+            }
+        }
+        return agents;
+    }
+    async deleteRoom(roomId) {
+        const room = await this.roomStore.getRoom(roomId);
+        if (!room) {
+            throw new errors_1.NotFoundError('Room not found');
+        }
+        const isPublishedInstance = !!(room.getIsPublished() && room.getTemplateRoomId());
+        const isTemplate = !room.getTemplateRoomId();
+        if (isTemplate) {
+            const instances = await this.roomStore.getPublishedInstances(roomId);
+            for (const instance of instances) {
+                await this.deleteRoom(instance.getId());
+            }
+        }
+        this.attachedFileService.deleteAllFiles(roomId);
+        if (room.getIsPublished()) {
+            this.publishedRoomsService.removePublishedRoom(roomId);
+        }
+        const removed = this.roomStore.removeRoom(roomId, undefined, isPublishedInstance);
+        if (!removed) {
+            throw new errors_1.OperationFailedError('Failed to delete room');
+        }
+    }
+    async publishRoom(templateId, publishedName, userId) {
+        const template = await this.roomStore.getRoom(templateId);
+        if (!template) {
+            throw new errors_1.NotFoundError('Template room not found');
+        }
+        const instanceId = await this.roomStore.cloneRoomAsPublished(templateId, publishedName || template.getName(), userId);
+        this.publishedRoomsService.addPublishedRoom(instanceId, userId);
+        return instanceId;
+    }
+    async getPublishedRoomInstances(templateId) {
+        const instances = await this.roomStore.getPublishedInstances(templateId);
+        return instances.map((room) => ({
+            id: room.getId(),
+            name: room.getName(),
+            goal: room.getGoal(),
+            agentCount: room.getAgentCount(),
+        }));
+    }
+    async resetPublishedRoomInstance(instanceId) {
+        const instance = await this.roomStore.getRoom(instanceId);
+        if (!instance) {
+            throw new errors_1.NotFoundError('Instance not found');
+        }
+        const templateId = instance.getTemplateRoomId();
+        if (!templateId) {
+            throw new errors_1.OperationFailedError('Not a published instance');
+        }
+        this.roomStore.clearRoomMessages(instanceId);
+        const storageDir = this.roomStore.getDefaultStorageDir();
+        const roomDir = path.join(storageDir, instanceId);
+        if (fs.existsSync(roomDir)) {
+            const artifacts = instance.getArtifacts();
+            for (const artifact of artifacts) {
+                try {
+                    const artifactPath = path.join(roomDir, `${artifact.name}.artifact`);
+                    if (fs.existsSync(artifactPath)) {
+                        fs.unlinkSync(artifactPath);
+                    }
+                }
+                catch (err) {
+                    console.error(`Failed to delete artifact ${artifact.name}:`, err);
+                }
+            }
+        }
+        instance.setArtifacts([]);
+        const instanceAgents = instance.getAgents();
+        for (const agent of instanceAgents) {
+            if (agent.templateAgentId) {
+                await this.agentStore.resetPublishedInstance(agent.id, agent.templateAgentId);
+            }
+        }
+        instance.saveMetadata();
+    }
+    getUserPreferences() {
+        if (!this.configService.exists(this.userPreferencesFile)) {
+            return {};
+        }
+        const preferencesData = this.configService.load(this.userPreferencesFile);
+        return preferencesData ? JSON.parse(preferencesData) : {};
+    }
+    saveUserPreferences(preferences) {
+        this.configService.store(this.userPreferencesFile, JSON.stringify(preferences, null, 2));
+    }
+    listPromptFiles(folderName) {
+        const baseNames = new Set();
+        const scanDirectory = (baseDir) => {
+            let targetDir = baseDir;
+            if (folderName !== 'shared') {
+                targetDir = path.join(baseDir, folderName);
+            }
+            if (!fs.existsSync(targetDir)) {
+                return;
+            }
+            const allFiles = fs.readdirSync(targetDir);
+            const promptFiles = allFiles.filter((file) => file.endsWith('.prompt') || file.endsWith('.json'));
+            promptFiles.forEach((file) => {
+                const baseName = file.replace(/\.(prompt|json)$/, '');
+                baseNames.add(baseName);
+            });
+        };
+        scanDirectory(this.configService.getCommonPromptsDir());
+        scanDirectory(this.configService.getUserPromptsDir());
+        return { files: Array.from(baseNames).sort() };
+    }
+    listPromptFilesWithScope(folderName) {
+        const fileMap = new Map();
+        const scanDirectory = (baseDir, scope) => {
+            let targetDir = baseDir;
+            if (folderName !== 'shared') {
+                targetDir = path.join(baseDir, folderName);
+            }
+            if (!fs.existsSync(targetDir)) {
+                return;
+            }
+            const allFiles = fs.readdirSync(targetDir);
+            const promptFiles = allFiles.filter((file) => file.endsWith('.prompt') || file.endsWith('.json'));
+            promptFiles.forEach((file) => {
+                const baseName = file.replace(/\.(prompt|json)$/, '');
+                fileMap.set(baseName, scope);
+            });
+        };
+        scanDirectory(this.configService.getCommonPromptsDir(), 'common');
+        scanDirectory(this.configService.getUserPromptsDir(), 'user');
+        const files = [];
+        fileMap.forEach((scope, name) => {
+            files.push({ name, scope });
+        });
+        files.sort((a, b) => a.name.localeCompare(b.name));
+        return { files };
+    }
+    getPromptFile(folderName, fileName) {
+        const fileExtension = fileName.endsWith('.prompt') || fileName.endsWith('.json') ? '' : '.prompt';
+        const fullFileName = fileName + fileExtension;
+        const userDir = this.configService.getUserPromptsDir();
+        const commonDir = this.configService.getCommonPromptsDir();
+        const searchPaths = [];
+        if (folderName === 'shared') {
+            searchPaths.push({ path: path.join(userDir, fullFileName), scope: 'user' }, { path: path.join(commonDir, fullFileName), scope: 'common' });
+        }
+        else {
+            searchPaths.push({ path: path.join(userDir, folderName, fullFileName), scope: 'user' }, { path: path.join(userDir, fullFileName), scope: 'user' }, {
+                path: path.join(commonDir, folderName, fullFileName),
+                scope: 'common',
+            }, { path: path.join(commonDir, fullFileName), scope: 'common' });
+        }
+        for (const { path: filePath, scope } of searchPaths) {
+            if (fs.existsSync(filePath)) {
+                const content = fs.readFileSync(filePath, 'utf8');
+                return { content, scope };
+            }
+        }
+        return { content: '' };
+    }
+    savePromptFile(folderName, fileName, content, fileType) {
+        let targetDir = this.configService.getUserPromptsDir();
+        if (folderName !== 'shared') {
+            targetDir = path.join(this.configService.getUserPromptsDir(), folderName);
+        }
+        if (!fs.existsSync(targetDir)) {
+            fs.mkdirSync(targetDir, { recursive: true });
+        }
+        const fileExtension = fileType === 'json' ? '.json' : '.prompt';
+        const filePath = path.join(targetDir, fileName + fileExtension);
+        if (content.trim() === '' && fileType === 'json') {
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+            }
+            return;
+        }
+        fs.writeFileSync(filePath, content);
+    }
+    deletePromptFile(folderName, fileName) {
+        let targetDir = this.configService.getPromptsDir();
+        if (folderName !== 'shared') {
+            targetDir = path.join(this.configService.getPromptsDir(), folderName);
+        }
+        const promptPath = path.join(targetDir, fileName + '.prompt');
+        if (fs.existsSync(promptPath)) {
+            fs.unlinkSync(promptPath);
+        }
+        const jsonPath = path.join(targetDir, fileName + '.json');
+        if (fs.existsSync(jsonPath)) {
+            fs.unlinkSync(jsonPath);
+        }
+    }
+    async getRoomArtifacts(roomId) {
+        const room = await this.roomStore.getRoom(roomId);
+        if (!room) {
+            return { artifacts: [] };
+        }
+        const artifacts = room.getArtifacts();
+        return { artifacts };
+    }
+    async publishArtifact(roomId, name, creator, body, viewers = []) {
+        const room = await this.roomStore.getRoom(roomId);
+        if (!room)
+            throw new errors_1.NotFoundError('Room not found');
+        if (!name)
+            throw new errors_1.OperationFailedError('Artifact name is required');
+        room.publishArtifact(name, creator, body, viewers);
+    }
+    createPromptFolder(folderName) {
+        const targetDir = path.join(this.configService.getUserPromptsDir(), folderName);
+        if (fs.existsSync(targetDir)) {
+            throw new errors_1.OperationFailedError(`Folder ${folderName} already exists`);
+        }
+        fs.mkdirSync(targetDir, { recursive: true });
+        const systemInstructionPath = path.join(targetDir, 'system_instruction.prompt');
+        fs.writeFileSync(systemInstructionPath, '');
+    }
+    deletePromptFolder(folderName) {
+        if (folderName === 'shared') {
+            throw new errors_1.OperationFailedError('Cannot delete the shared folder');
+        }
+        const targetDir = path.join(this.configService.getUserPromptsDir(), folderName);
+        if (!fs.existsSync(targetDir)) {
+            throw new errors_1.NotFoundError(`Folder ${folderName} does not exist`);
+        }
+        fs.rmSync(targetDir, { recursive: true, force: true });
+    }
+    async updateAgent(agentId, updates) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError('Agent not found');
+        }
+        if (updates.agentNickname !== undefined)
+            agent.agentNickname = updates.agentNickname;
+        if (updates.description !== undefined)
+            agent.description = updates.description;
+        if (updates.modelName !== undefined)
+            agent.modelName = updates.modelName;
+        if (updates.reasoningEffort !== undefined)
+            agent.reasoningEffort = updates.reasoningEffort;
+        if (updates.isControlledByHuman !== undefined)
+            agent.isControlledByHuman = updates.isControlledByHuman;
+        if (updates.maxOutputTokens !== undefined)
+            agent.maxOutputTokens = updates.maxOutputTokens;
+        if (updates.allowSearch !== undefined)
+            agent.allowSearch = updates.allowSearch;
+        if (updates.beginInstruction !== undefined)
+            agent.beginInstruction = updates.beginInstruction;
+        agent.save();
+    }
+    async listAttachedFiles(agentId) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            return { files: [] };
+        }
+        const files = this.attachedFileService.listFiles(agentId);
+        return { files };
+    }
+    async deleteAttachedFile(agentId, fileName) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError('Agent not found');
+        }
+        const deleted = this.attachedFileService.deleteFileByName(agentId, fileName);
+        if (!deleted) {
+            throw new errors_1.NotFoundError(`File ${fileName} not found`);
+        }
+        agent.attachedFiles = agent.attachedFiles.filter((file) => file.fileName !== fileName);
+        agent.save();
+    }
+    async deleteAttachedFileById(documentId) {
+        const allAgentIds = await this.agentStore.getAllAgentIds();
+        let ownerAgent = null;
+        let fileMetadata = null;
+        for (const agentId of allAgentIds) {
+            const agent = await this.agentStore.getAgent(agentId);
+            if (agent) {
+                const file = agent.attachedFiles.find((f) => f.fileId === documentId);
+                if (file) {
+                    ownerAgent = agent;
+                    fileMetadata = file;
+                    break;
+                }
+            }
+        }
+        if (!ownerAgent || !fileMetadata) {
+            throw new errors_1.NotFoundError('File not found');
+        }
+        const deleted = this.attachedFileService.deleteFile(ownerAgent.id, documentId);
+        if (!deleted) {
+            throw new errors_1.OperationFailedError('Failed to delete file');
+        }
+        ownerAgent.attachedFiles = ownerAgent.attachedFiles.filter((file) => file.fileId !== documentId);
+        ownerAgent.save();
+    }
+    async reloadAgent(agentId) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError('Agent not found');
+        }
+        const serviceName = agent.serviceName;
+        const aiService = this.getAiServiceFromServiceName(serviceName);
+        if (agent.history &&
+            agent.history.length > 0 &&
+            agent.history[0].content &&
+            agent.history[0].content.includes('[CONVERSATION HISTORY SUMMARY]'))
+            agent.history.splice(1);
+        else
+            agent.history = [];
+        const fileMetadataList = agent.attachedFiles;
+        for (const metadata of fileMetadataList) {
+            const fileData = this.attachedFileService.getFile(agent.id, metadata.fileId);
+            if (fileData) {
+                aiService.attachDocument(agent, metadata.fileName, fileData);
+            }
+        }
+        agent.save();
+    }
+    async resetRoom(roomId) {
+        const room = await this.roomStore.getRoom(roomId);
+        if (!room) {
+            throw new errors_1.NotFoundError('Room not found');
+        }
+        const roomName = room.getName();
+        const storageDir = room.getStorageDir() || this.roomStore.getDefaultStorageDir();
+        this.roomStore.clearRoomMessages(roomId, storageDir);
+        this.roomStore.deleteAllArtifactFiles(roomId, storageDir);
+        room.setArtifacts([]);
+        const warnings = [];
+        for (const agent of room.getAgents()) {
+            try {
+                this.reloadAgent(agent.id);
+            }
+            catch (agentError) {
+                warnings.push(`Failed to reset agent ${agent.agentName}: ${agentError.message}`);
+            }
+        }
+        if (warnings.length > 0) {
+            console.warn(`Room "${roomName}" reset with warnings:`, warnings);
+        }
+    }
+    async resetStory(storyId) {
+        const story = this.storyStore.getStory(storyId);
+        if (!story || !story.roomId) {
+            throw new errors_1.NotFoundError('Story not found');
+        }
+        const storyName = story.name;
+        const room = await this.roomStore.getRoom(story.roomId);
+        if (!room) {
+            throw new errors_1.NotFoundError('Story room not found');
+        }
+        const roomMessages = room.getLatestRoomMessages();
+        const openingSceneMessage = roomMessages.find((msg) => msg.sender === 'Opening Scene');
+        const openingSceneText = openingSceneMessage?.content || '';
+        const storageDir = room.getStorageDir() ||
+            path.join(this.configService.getUserDataDir(), 'stories', storyId, 'rooms');
+        this.roomStore.clearRoomMessages(story.roomId, storageDir);
+        room.setRoomMessages([]);
+        const chapters = this.storyStore.listChapters(storyId);
+        const warnings = [];
+        if (chapters.length > 0) {
+            console.log(`Restoring agents from chapter 1 backup for story ${storyId}`);
+            const restoredAgentIds = await this.storyStore.restoreAgentsFromChapter(storyId, 1, this.agentStore);
+            console.log(`Restored ${restoredAgentIds.length} agents from chapter 1 backup`);
+        }
+        else {
+            console.warn(`No chapter 1 backup found for story ${storyId}, clearing agent histories`);
+            for (const agent of room.getAgents()) {
+                try {
+                    this.reloadAgent(agent.id);
+                }
+                catch (agentError) {
+                    warnings.push(`Failed to reset agent ${agent.agentName}: ${agentError.message}`);
+                }
+            }
+        }
+        if (openingSceneText) {
+            this.storyService.populateStoryHistory(room, openingSceneText);
+        }
+        if (story) {
+            story.declinedCharacters = [];
+            this.storyStore.updateStoryMetadata(storyId, story);
+        }
+        if (warnings.length > 0) {
+            console.warn(`Story "${storyName}" reset with warnings:`, warnings);
+        }
+    }
+    async createStory(name, idea, userCharacterDesc, otherCharactersDesc, storyModel, isImport, imageModelName) {
+        return this.storyService.createStory(name, idea, userCharacterDesc, otherCharactersDesc, storyModel, isImport, imageModelName);
+    }
+    async importStoryFromZip(zipBuffer) {
+        return this.storyService.importStoryFromZip(zipBuffer);
+    }
+    getStoryProgressEmitter(storyId) {
+        return this.storyService.getProgressEmitter(storyId);
+    }
+    getStoryMessageEmitter(storyId) {
+        return this.storyService.getMessageEmitter(storyId);
+    }
+    getAgentMessageEmitter(agentId) {
+        return this.agentMessageService.getOrCreateEmitter(agentId);
+    }
+    async ensureAgentStateCallback(agentId) {
+        try {
+            const agent = await this.agentStore.getAgent(agentId);
+            if (agent) {
+                this.setupAgentStateCallback(agent);
+            }
+        }
+        catch (error) {
+            console.warn(`Could not set up SSE callback for agent ${agentId}:`, error.message);
+        }
+    }
+    setupAgentStateCallback(agent) {
+        if (!agent.id) {
+            console.warn('Cannot set up SSE callback for agent without ID');
+            return;
+        }
+        agent.setOnStateChange(() => {
+            const messages = agent.getFormattedMessages();
+            const agentState = {
+                agentId: agent.id,
+                latestMessage: messages.length > 0 ? messages[messages.length - 1] : undefined,
+                messageIndex: messages.length > 0 ? messages.length - 1 : undefined,
+                totalInputTokens: agent.totalInputTokens,
+                totalOutputTokens: agent.totalOutputTokens,
+                totalCost: agent.totalCost,
+            };
+            this.agentMessageService.emitUpdate(agent.id, agentState);
+        });
+    }
+    getRoomMessageEmitter(roomId) {
+        return this.roomMessageService.getOrCreateEmitter(roomId);
+    }
+    getBalanceMessageEmitter(userId) {
+        return this.balanceMessageService.getOrCreateEmitter(userId);
+    }
+    async ensureRoomStateCallback(roomId) {
+        try {
+            const room = await this.roomStore.getRoom(roomId);
+            if (room) {
+                this.setupRoomStateCallback(room);
+            }
+        }
+        catch (error) {
+            console.warn(`Could not set up SSE callback for room ${roomId}:`, error.message);
+        }
+    }
+    setupRoomStateCallback(room) {
+        const roomId = room.getId();
+        if (!roomId) {
+            console.warn('Cannot set up SSE callback for room without ID');
+            return;
+        }
+        room.setOnStateChange(() => {
+            const messages = room.getLatestRoomMessages(0, false);
+            const latestMessage = messages.length > 0 ? messages[messages.length - 1] : undefined;
+            const totalCost = room
+                .getAgents()
+                .map((a) => a.totalCost)
+                .reduce((acc, v) => acc + v, 0);
+            const roomState = {
+                roomId: roomId,
+                latestMessage: latestMessage,
+                messageIndex: messages.length > 0 ? messages.length - 1 : undefined,
+                totalCost: totalCost,
+                isPaused: room.getPaused(),
+                currentSpeaker: room.getCurrentSpeaker(),
+                processingInProgress: room.isProcessingInProgress(),
+            };
+            this.roomMessageService.emitUpdate(roomId, roomState);
+        });
+    }
+    listStories() {
+        return this.storyStore.getAllStories();
+    }
+    async resumePausedStories() {
+        const stories = this.storyStore.getAllStories();
+        let resumedCount = 0;
+        for (const story of stories) {
+            if (!story.roomId)
+                continue;
+            try {
+                const room = await this.roomStore.getRoom(story.roomId);
+                if (!room)
+                    continue;
+                const isPaused = !room.isProcessingInProgress() && room['pendingMessages']?.length > 0;
+                if (isPaused) {
+                    console.log(`Resuming paused story: ${story.name} (${story.id})`);
+                    const resumeMessage = new message_1.RoomMessage('System', app_types_1.MessageAction.SYSTEM, 'Balance added. Conversation resumed.', [], null, null);
+                    room.addRoomMessage(resumeMessage);
+                    room['processPendingMessages']();
+                    resumedCount++;
+                }
+            }
+            catch (error) {
+                console.error(`Error resuming story ${story.id}:`, error);
+            }
+        }
+        if (resumedCount > 0) {
+            console.log(`Resumed ${resumedCount} paused story/stories`);
+        }
+        return resumedCount;
+    }
+    async deleteStory(storyId) {
+        await this.storyService.deleteStory(storyId);
+    }
+    async compactStory(storyId) {
+        return this.storyService.compactStory(storyId);
+    }
+    async progressStory(storyId) {
+        return this.storyService.progressStoryToNextChapter(storyId);
+    }
+    async getStoryState(storyId) {
+        return this.storyService.getStoryState(storyId);
+    }
+    async getStoryInfo(storyId) {
+        return this.storyStore.getStory(storyId);
+    }
+    async respondToStory(storyId, content) {
+        return this.storyService.respondToStory(storyId, content);
+    }
+    async introduceCharacterToStory(storyId, name, description, storyModel, fromNarratorSuggestion) {
+        await this.storyService.introduceCharacter(storyId, name, description, storyModel, fromNarratorSuggestion);
+    }
+    async declineCharacter(storyId, characterName) {
+        await this.storyService.declineCharacter(storyId, characterName);
+    }
+    async deleteCharacterFromStory(storyId, characterName) {
+        await this.storyService.deleteCharacter(storyId, characterName);
+    }
+    listChapters(storyId) {
+        const chapters = this.storyStore.listChapters(storyId);
+        return { chapters };
+    }
+    async getChapter(storyId, chapterIndex) {
+        return await this.storyStore.getChapterContent(storyId, chapterIndex);
+    }
+    saveChapter(storyId, chapterIndex, content) {
+        const saved = this.storyStore.saveChapterContent(storyId, chapterIndex, content);
+        if (!saved) {
+            throw new errors_1.OperationFailedError('Failed to save chapter');
+        }
+    }
+    deleteChapter(storyId, chapterIndex) {
+        const deleted = this.storyStore.deleteChapter(storyId, chapterIndex);
+        if (!deleted) {
+            throw new errors_1.NotFoundError('Chapter not found');
+        }
+    }
+    async listCharacters(storyId) {
+        return await this.storyService.listCharacters(storyId);
+    }
+    async getCharacter(storyId, characterName) {
+        const content = await this.storyService.getCharacter(storyId, characterName);
+        return { content: content || '' };
+    }
+    saveCharacter(storyId, characterName, content) {
+        this.storyService.saveCharacter(storyId, characterName, content);
+    }
+    async getPlotPlan(storyId) {
+        const content = await this.storyService.getPlotPlan(storyId);
+        return { content: content || '' };
+    }
+    async downloadStoryMarkdown(storyId) {
+        return await this.storyService.generateStoryMarkdown(storyId);
+    }
+    async exportStoryData(storyId) {
+        return await this.storyService.exportStoryData(storyId);
+    }
+    async getAgentHistory(storyId, agentId) {
+        const history = await this.storyService.getAgentHistory(storyId, agentId);
+        return { content: history };
+    }
+    async savePlotPlan(storyId, content) {
+        await this.storyService.savePlotPlan(storyId, content);
+    }
+    getBalance() {
+        return this.balanceService.getBalance();
+    }
+    addBalance(amount) {
+        return this.balanceService.addBalance(amount);
+    }
+    getTransactionService() {
+        return this.transactionService;
+    }
+    listUserArtifacts() {
+        return this.artifactService.listArtifacts();
+    }
+    getUserArtifact(artifactId) {
+        return this.artifactService.getArtifact(artifactId);
+    }
+    createUserArtifact(name, content) {
+        return this.artifactService.storeArtifact(name, content);
+    }
+    updateUserArtifact(artifactId, content) {
+        return this.artifactService.updateArtifact(artifactId, content);
+    }
+    convertUserArtifact(name, pdfBuffer) {
+        const placeholderContent = 'Converting PDF. This text will be replaced when the conversion is finished.';
+        const artifactId = this.artifactService.storeArtifact(name, placeholderContent);
+        this.convertPdfInBackground(artifactId, name, pdfBuffer).catch((error) => {
+            console.error(`Background PDF conversion failed for ${artifactId}:`, error);
+            const errorContent = `# Conversion Failed\n\nThe PDF conversion failed with the following error:\n\n${error.message}\n\nPlease try uploading the file again.`;
+            this.artifactService.updateArtifact(artifactId, errorContent);
+        });
+        return artifactId;
+    }
+    async convertSinglePagePDF(pdfDoc, pageIndex) {
+        const pageNum = pageIndex + 1;
+        const agent = this.agentFactory.createAgent(process.env.DOC_CONVERSION_AI_SERVICE, 'PDF Converter', '', `Single page (#${pageNum}) PDF to Markdown conversion`, 'pdf_converter', process.env.DOC_CONVERSION_AI_MODEL);
+        const singlePageDoc = await pdf_lib_1.PDFDocument.create();
+        const [copiedPage] = await singlePageDoc.copyPages(pdfDoc, [pageIndex]);
+        singlePageDoc.addPage(copiedPage);
+        const singlePageBuffer = await singlePageDoc.save();
+        const fileName = `Page${pageNum}.pdf`;
+        await agent.attachDocument(fileName, singlePageBuffer);
+        let response = null;
+        try {
+            let markdownContent = await agent.preparedPrompt('convert_pdf_page', {
+                fileName: fileName,
+                pageNum: pageNum,
+                targetFormat: 'markdown',
+            }, false);
+            response = { markdownContent, cost: agent.totalCost };
+        }
+        finally {
+            await agent.finishAgent();
+        }
+        return response;
+    }
+    async convertLargePdfInBackground(artifactId, name, pdfDoc) {
+        const pageCount = pdfDoc.getPageCount();
+        console.log(`Converting large PDF with ${pageCount} pages concurrently for artifact ${artifactId}`);
+        try {
+            const conversionPromises = Array.from({ length: pageCount }, (_, pageIndex) => {
+                const pageNum = pageIndex + 1;
+                console.log(`Starting conversion for page ${pageNum}/${pageCount} for artifact ${artifactId}`);
+                return this.convertSinglePagePDF(pdfDoc, pageIndex)
+                    .then((pageResponse) => ({
+                    pageNum,
+                    success: true,
+                    cost: pageResponse.cost,
+                    content: `**[Page ${pageNum}]**  \n${pageResponse.markdownContent}  \n`,
+                }))
+                    .catch((pageError) => {
+                    console.error(`Error converting page ${pageNum}:`, pageError);
+                    return {
+                        pageNum,
+                        success: false,
+                        cost: 0,
+                        content: `\n\n---\n**[Error converting page ${pageNum}: ${pageError.message}]**\n---\n\n`,
+                    };
+                });
+            });
+            console.log(`Waiting for ${pageCount} concurrent page conversions...`);
+            const results = await Promise.all(conversionPromises);
+            const pageMarkdowns = results.map((result) => result.content);
+            const totalCost = results.map((result) => result.cost).reduce((acc, v) => acc + v, 0);
+            const markdownContent = pageMarkdowns.join('\n\n');
+            if (!markdownContent || markdownContent.trim().length === 0) {
+                throw new Error('PDF conversion produced empty content');
+            }
+            this.artifactService.updateArtifact(artifactId, markdownContent);
+            const successCount = results.filter((r) => r.success).length;
+            const failureCount = pageCount - successCount;
+            console.log(`Large PDF conversion complete: ${artifactId}. ` +
+                `Pages: ${pageCount} (${successCount} succeeded, ${failureCount} failed), ` +
+                `Output: ${markdownContent.length} chars (total cost: ${totalCost})`);
+        }
+        catch (error) {
+            console.error(`Error in large PDF conversion for ${artifactId}:`, error);
+            const errorContent = `# Conversion Failed\n\nThe PDF conversion failed with the following error:\n\n${error.message}\n\nPlease try uploading the file again.`;
+            this.artifactService.updateArtifact(artifactId, errorContent);
+            throw error;
+        }
+    }
+    async convertPdfInBackground(artifactId, name, pdfBuffer) {
+        console.log(`Starting background PDF conversion for artifact ${artifactId}`);
+        let agent = null;
+        if (!process.env.DOC_CONVERSION_AI_SERVICE)
+            throw new Error('DOC_CONVERSION_AI_SERVICE environment variable not set');
+        if (!process.env.DOC_CONVERSION_AI_MODEL)
+            throw new Error('DOC_CONVERSION_AI_MODEL environment variable not set');
+        try {
+            const pdfData = new Uint8Array(pdfBuffer);
+            const pdfDoc = await pdf_lib_1.PDFDocument.load(pdfBuffer);
+            const pageCount = pdfDoc.getPageCount();
+            if (pageCount > 10) {
+                return this.convertLargePdfInBackground(artifactId, name, pdfDoc);
+            }
+            agent = this.agentFactory.createAgent(process.env.DOC_CONVERSION_AI_SERVICE, 'PDF Converter', '', 'Small PDF to Markdown conversion', 'pdf_converter', process.env.DOC_CONVERSION_AI_MODEL);
+            await agent.attachDocument(`${name}.pdf`, pdfData);
+            let markdownContent = await agent.preparedPrompt('convert_pdf', {
+                fileName: `${name}.pdf`,
+                targetFormat: 'markdown',
+            }, false);
+            if (!markdownContent || markdownContent.trim().length === 0) {
+                throw new Error('PDF conversion produced empty content');
+            }
+            this.artifactService.updateArtifact(artifactId, markdownContent);
+            console.log(`PDF conversion complete: ${artifactId}. ` +
+                `Input: ${pdfBuffer.length} bytes, Output: ${markdownContent.length} chars, ` +
+                `Cost: $${agent.totalCost.toFixed(4)}`);
+        }
+        finally {
+            try {
+                await agent?.finishAgent();
+            }
+            catch (cleanupError) {
+                console.error('Agent cleanup error:', cleanupError);
+            }
+        }
+    }
+    renameUserArtifact(artifactId, newName) {
+        return this.artifactService.renameArtifact(artifactId, newName);
+    }
+    deleteUserArtifact(artifactId) {
+        return this.artifactService.deleteArtifact(artifactId);
+    }
+    getStoryArtifactService(storyId) {
+        return this.storyService.getStoryArtifactService(storyId);
+    }
+    listStoryArtifacts(storyId) {
+        const storyArtifactService = this.getStoryArtifactService(storyId);
+        return storyArtifactService.listArtifacts();
+    }
+    getStoryArtifact(storyId, artifactId) {
+        const storyArtifactService = this.getStoryArtifactService(storyId);
+        return storyArtifactService.getArtifact(artifactId);
+    }
+    async listAgentArtifacts(agentId) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError(`Agent ${agentId} not found`);
+        }
+        const artifactIds = agent.getAttachedArtifacts();
+        const allArtifacts = this.artifactService.listArtifacts();
+        return allArtifacts.filter((a) => artifactIds.includes(a.artifactId));
+    }
+    async attachArtifactToAgent(agentId, artifactId) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError(`Agent ${agentId} not found`);
+        }
+        const artifact = this.artifactService.getArtifactMetadata(artifactId);
+        if (!artifact) {
+            throw new errors_1.NotFoundError(`Artifact ${artifactId} not found`);
+        }
+        agent.attachArtifact(artifactId);
+        agent.save();
+    }
+    async detachArtifactFromAgent(agentId, artifactId) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError(`Agent ${agentId} not found`);
+        }
+        agent.detachArtifact(artifactId);
+        agent.save();
+    }
+}
+exports.AppService = AppService;