briyah 1.2.3 → 1.2.5

package/dist-sdk/server/src/app.controller.js

@@ -128,11 +128,23 @@ let AppController = class AppController {
             throw new common_1.HttpException('Failed to list story models', common_1.HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
-    listStoryModelDefaults(_req) {
+    async listStoryModelDefaults(req) {
+        const appService = this.getAppService(req);
+        const imageModels = await appService.listImageModels();
+        const resolveImageDefault = (envName) => {
+            const exact = imageModels.find((m) => m.name === envName);
+            if (exact)
+                return exact.name;
+            if (envName) {
+                const ci = imageModels.find((m) => m.name.toLowerCase() === envName.toLowerCase());
+                if (ci)
+                    return ci.name;
+            }
+            return imageModels[0]?.name ?? '';
+        };
         return {
             selectedStoryModel: process.env.DEFAULT_STORY_MODEL,
-            selectedImageModel: process.env.DEFAULT_IMAGE_MODEL,
-            selectedImageEditModel: process.env.DEFAULT_IMAGE_EDIT_MODEL,
+            selectedImageModel: resolveImageDefault(process.env.DEFAULT_IMAGE_MODEL),
             enforceDefaultModels: process.env.ENFORCE_DEFAULT_MODELS === 'true',
         };
     }
@@ -350,6 +362,68 @@ let AppController = class AppController {
             throw new common_1.HttpException('Failed to delete prompt file', common_1.HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
+    async getTools(req) {
+        try {
+            const appService = this.getAppService(req);
+            return { tools: await appService.listTools() };
+        }
+        catch (error) {
+            logger_1.logger.error(`[${req.user?.sub}] Error listing tools:`, error);
+            return { tools: [] };
+        }
+    }
+    async createTool(req, body) {
+        if (!body.name) {
+            throw new common_1.BadRequestException('Tool name is required');
+        }
+        try {
+            const appService = this.getAppService(req);
+            return await appService.createTool(body);
+        }
+        catch (error) {
+            logger_1.logger.error(`[${req.user?.sub}] Error creating tool ${body.name}:`, error);
+            if (error instanceof errors_1.OperationFailedError) {
+                throw new common_1.ConflictException(error.message);
+            }
+            throw new common_1.HttpException(error.message || 'Failed to create tool', common_1.HttpStatus.BAD_REQUEST);
+        }
+    }
+    async updateTool(req, name, body) {
+        try {
+            const appService = this.getAppService(req);
+            return await appService.updateTool(name, body);
+        }
+        catch (error) {
+            logger_1.logger.error(`[${req.user?.sub}] Error updating tool ${name}:`, error);
+            if (error instanceof errors_1.NotFoundError) {
+                throw new common_1.NotFoundException(error.message);
+            }
+            throw new common_1.HttpException(error.message || 'Failed to update tool', common_1.HttpStatus.BAD_REQUEST);
+        }
+    }
+    async deleteTool(req, name) {
+        try {
+            const appService = this.getAppService(req);
+            await appService.deleteTool(name);
+        }
+        catch (error) {
+            logger_1.logger.error(`[${req.user?.sub}] Error deleting tool ${name}:`, error);
+            if (error instanceof errors_1.NotFoundError) {
+                throw new common_1.NotFoundException(error.message);
+            }
+            throw new common_1.HttpException('Failed to delete tool', common_1.HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+    async testTool(req, name, body) {
+        try {
+            const appService = this.getAppService(req);
+            return await appService.testTool(name, body?.args || {});
+        }
+        catch (error) {
+            logger_1.logger.error(`[${req.user?.sub}] Error testing tool ${name}:`, error);
+            return { ok: false, error: error.message || 'Tool test failed' };
+        }
+    }
     listLibraryPrompts() {
         return { prompts: this.libraryService.listLocalPrompts() };
     }
@@ -1154,7 +1228,7 @@ let AppController = class AppController {
         }
         try {
             const appService = this.getAppService(req);
-            return appService.createStory(body.name, body.idea, body.userCharacterDesc, body.otherCharactersDesc, body.illustrateStory ?? true, body.storyModel, body.isImport, body.imageModelName, body.imageEditModelName);
+            return appService.createStory(body.name, body.idea, body.userCharacterDesc, body.otherCharactersDesc, body.illustrateStory ?? true, body.storyModel, body.isImport, body.imageModelName, body.skipDetailedPlot ?? false);
         }
         catch (error) {
             logger_1.logger.error(`[${req.user?.sub}] Error creating story ${body.name}:`, error);
@@ -1476,6 +1550,35 @@ let AppController = class AppController {
             throw new common_1.HttpException('Failed to save character', common_1.HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
+    async getCharacterInventory(req, storyId, characterName) {
+        try {
+            const appService = this.getAppService(req);
+            return await appService.getCharacterInventory(storyId, characterName);
+        }
+        catch (error) {
+            logger_1.logger.error(`[${req.user?.sub}] Error getting inventory for character ${characterName} in story ${storyId}:`, error);
+            return { content: '' };
+        }
+    }
+    async saveCharacterInventory(req, storyId, characterName, body) {
+        if (body.content === undefined || body.content === null) {
+            throw new common_1.BadRequestException('Content is required');
+        }
+        try {
+            const appService = this.getAppService(req);
+            await appService.saveCharacterInventory(storyId, characterName, body.content);
+        }
+        catch (error) {
+            logger_1.logger.error(`[${req.user?.sub}] Error saving inventory for character ${characterName} in story ${storyId}:`, 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);
+            }
+            throw new common_1.HttpException('Failed to save inventory', common_1.HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
     async getPlotPlan(req, storyId) {
         try {
             const appService = this.getAppService(req);
@@ -1861,7 +1964,7 @@ __decorate([
     __param(0, (0, common_1.Request)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Object)
+    __metadata("design:returntype", Promise)
 ], AppController.prototype, "listStoryModelDefaults", null);
 __decorate([
     (0, common_1.Post)('agents'),
@@ -1976,6 +2079,49 @@ __decorate([
     __metadata("design:paramtypes", [Object, String, String]),
     __metadata("design:returntype", Promise)
 ], AppController.prototype, "deletePromptFile", null);
+__decorate([
+    (0, common_1.Get)('tools'),
+    __param(0, (0, common_1.Request)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AppController.prototype, "getTools", null);
+__decorate([
+    (0, common_1.Post)('tools'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.CREATED),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AppController.prototype, "createTool", null);
+__decorate([
+    (0, common_1.Put)('tools/:name'),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Param)('name')),
+    __param(2, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", Promise)
+], AppController.prototype, "updateTool", null);
+__decorate([
+    (0, common_1.Delete)('tools/:name'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.NO_CONTENT),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Param)('name')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], AppController.prototype, "deleteTool", null);
+__decorate([
+    (0, common_1.Post)('tools/:name/test'),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Param)('name')),
+    __param(2, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", Promise)
+], AppController.prototype, "testTool", null);
 __decorate([
     (0, common_1.Get)('library/prompts'),
     (0, public_decorator_1.Public)(),
@@ -2611,6 +2757,26 @@ __decorate([
     __metadata("design:paramtypes", [Object, String, String, Object]),
     __metadata("design:returntype", Promise)
 ], AppController.prototype, "saveCharacter", null);
+__decorate([
+    (0, common_1.Get)('stories/:storyId/characters/:characterName/inventory'),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Param)('storyId')),
+    __param(2, (0, common_1.Param)('characterName')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, String]),
+    __metadata("design:returntype", Promise)
+], AppController.prototype, "getCharacterInventory", null);
+__decorate([
+    (0, common_1.Put)('stories/:storyId/characters/:characterName/inventory'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.NO_CONTENT),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Param)('storyId')),
+    __param(2, (0, common_1.Param)('characterName')),
+    __param(3, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, String, Object]),
+    __metadata("design:returntype", Promise)
+], AppController.prototype, "saveCharacterInventory", null);
 __decorate([
     (0, common_1.Get)('stories/:storyId/plot-plan'),
     __param(0, (0, common_1.Request)()),

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

@@ -12,7 +12,7 @@ import { StoryService } from './story/story.service';
 import { UserPathsService } from './config/user-paths.service';
 import { AttachedFileService } from './ai/attached-file.service';
 import { ArtifactService } from './ai/artifact.service';
-import { ArtifactMetadata, ModelInfo, ChapterInfo, StoryIdea } from '../../shared/types/app.types';
+import { ArtifactMetadata, ModelInfo, ImageModelOption, ChapterInfo, StoryIdea } from '../../shared/types/app.types';
 import { PublishedAgentsService } from './ai/published-agents.service';
 import { PublishedRoomsService } from './room/published-rooms.service';
 import { BalanceService } from './app/balance.service';
@@ -21,8 +21,10 @@ 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, Transaction, TransactionHistoryResponse } 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, ToolDefinition, ToolRunResult } from '../../shared/types/app.types';
 import { RoomMessage } from './room/message';
+import { ToolStoreService } from './tools/tool-store.service';
+import { ToolExecutionService } from './tools/tool-execution.service';
 export declare class AppService {
     private readonly aiFactoryService;
     private readonly agentStore;
@@ -41,13 +43,15 @@ export declare class AppService {
     private readonly transactionService;
     private readonly agentFactory;
     private readonly roomFactory;
+    private readonly toolStore;
+    private readonly toolExecution;
     private aiServices;
     private readonly userPreferencesFile;
-    constructor(aiFactoryService: AiFactoryService, agentStore: AgentStoreService, agentMessageService: AgentMessageService, roomStore: RoomStoreService, roomMessageService: RoomMessageService, userPaths: UserPathsService, attachedFileService: AttachedFileService, artifactService: ArtifactService, storyStore: StoryStoreService, storyService: StoryService, publishedAgentsService: PublishedAgentsService, publishedRoomsService: PublishedRoomsService, balanceService: BalanceService, balanceMessageService: BalanceMessageService, transactionService: TransactionService, agentFactory: AgentFactory, roomFactory: RoomFactory);
+    constructor(aiFactoryService: AiFactoryService, agentStore: AgentStoreService, agentMessageService: AgentMessageService, roomStore: RoomStoreService, roomMessageService: RoomMessageService, userPaths: UserPathsService, attachedFileService: AttachedFileService, artifactService: ArtifactService, storyStore: StoryStoreService, storyService: StoryService, publishedAgentsService: PublishedAgentsService, publishedRoomsService: PublishedRoomsService, balanceService: BalanceService, balanceMessageService: BalanceMessageService, transactionService: TransactionService, agentFactory: AgentFactory, roomFactory: RoomFactory, toolStore: ToolStoreService, toolExecution: ToolExecutionService);
     getAiServiceNames(): string[];
     getAiServiceFromServiceName(serviceName: string): BaseAiService;
     listAiModels(aiServiceName: string): Promise<ModelInfo[]>;
-    listImageModels(): Promise<ModelInfo[]>;
+    listImageModels(): Promise<ImageModelOption[]>;
     listStoryModels(): Promise<ModelInfo[]>;
     listStoryGenres(): string[];
     getRandomStoryIdeaByGenre(genreName: string): StoryIdea | null;
@@ -107,7 +111,13 @@ export declare class AppService {
         maxOutputTokens?: number;
         allowSearch?: boolean;
         beginInstruction?: string;
+        toolNames?: string[];
     }): Promise<void>;
+    listTools(): Promise<ToolDefinition[]>;
+    createTool(tool: ToolDefinition): Promise<ToolDefinition>;
+    updateTool(name: string, tool: ToolDefinition): Promise<ToolDefinition>;
+    deleteTool(name: string): Promise<void>;
+    testTool(name: string, args: Record<string, any>): Promise<ToolRunResult>;
     listAttachedFiles(agentId: string): Promise<FileList>;
     deleteAttachedFile(agentId: string, fileName: string): Promise<void>;
     deleteAttachedFileById(documentId: string): Promise<void>;
@@ -116,7 +126,7 @@ export declare class AppService {
     resetRoom(roomId: string): Promise<void>;
     resetStory(storyId: string): Promise<void>;
     revertStoryChapter(storyId: string): Promise<void>;
-    createStory(name: string, idea: string, userCharacterDesc: string, otherCharactersDesc: string, illustrateStory: boolean, storyModel?: string, isImport?: boolean, imageModelName?: string, imageEditModelName?: string): Promise<StoryInfo>;
+    createStory(name: string, idea: string, userCharacterDesc: string, otherCharactersDesc: string, illustrateStory: boolean, storyModel?: string, isImport?: boolean, imageModelName?: string, skipDetailedPlot?: boolean): Promise<StoryInfo>;
     importStoryFromZip(zipBuffer: Buffer): Promise<StoryInfo>;
     getStoryProgressEmitter(storyId: string): EventEmitter<any>;
     getStoryMessageEmitter(storyId: string): EventEmitter<any>;
@@ -156,6 +166,10 @@ export declare class AppService {
         content: string;
     }>;
     saveCharacter(storyId: string, characterName: string, content: string): void;
+    getCharacterInventory(storyId: string, characterName: string): Promise<{
+        content: string;
+    }>;
+    saveCharacterInventory(storyId: string, characterName: string, content: string): Promise<void>;
     getPlotPlan(storyId: string): Promise<{
         content: string;
     }>;

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

@@ -59,9 +59,11 @@ class AppService {
     transactionService;
     agentFactory;
     roomFactory;
+    toolStore;
+    toolExecution;
     aiServices;
     userPreferencesFile = 'user-preferences.json';
-    constructor(aiFactoryService, agentStore, agentMessageService, roomStore, roomMessageService, userPaths, attachedFileService, artifactService, storyStore, storyService, publishedAgentsService, publishedRoomsService, balanceService, balanceMessageService, transactionService, agentFactory, roomFactory) {
+    constructor(aiFactoryService, agentStore, agentMessageService, roomStore, roomMessageService, userPaths, attachedFileService, artifactService, storyStore, storyService, publishedAgentsService, publishedRoomsService, balanceService, balanceMessageService, transactionService, agentFactory, roomFactory, toolStore, toolExecution) {
         this.aiFactoryService = aiFactoryService;
         this.agentStore = agentStore;
         this.agentMessageService = agentMessageService;
@@ -79,6 +81,8 @@ class AppService {
         this.transactionService = transactionService;
         this.agentFactory = agentFactory;
         this.roomFactory = roomFactory;
+        this.toolStore = toolStore;
+        this.toolExecution = toolExecution;
         this.aiServices = this.aiFactoryService.getAllAiServices();
     }
     getAiServiceNames() {
@@ -94,7 +98,10 @@ class AppService {
     async listImageModels() {
         const imageModelsPath = path.join(this.userPaths.getCommonConfigDir(), 'image_models.json');
         try {
-            return JSON.parse(fs.readFileSync(imageModelsPath, 'utf8'));
+            const entries = JSON.parse(fs.readFileSync(imageModelsPath, 'utf8'));
+            return entries
+                .filter((entry) => entry.name && entry.name !== 'No images')
+                .map((entry) => ({ name: entry.name, description: entry.description ?? '' }));
         }
         catch (error) {
             logger_1.logger.error(`Image models file could not be read from ${imageModelsPath}: `, error);
@@ -299,6 +306,7 @@ class AppService {
                     totalCost: agent.totalCost,
                     isPublished: agent.isPublished,
                     beginInstruction: agent.beginInstruction,
+                    toolNames: agent.toolNames,
                 });
             }
         }
@@ -327,6 +335,7 @@ class AppService {
                 totalCost: agent.totalCost,
                 isPublished: agent.isPublished,
                 beginInstruction: agent.beginInstruction,
+                toolNames: agent.toolNames,
             };
         }
         catch (error) {
@@ -535,6 +544,7 @@ class AppService {
             totalCost: agent.totalCost,
             isPublished: agent.isPublished,
             beginInstruction: agent.beginInstruction,
+            toolNames: agent.toolNames,
         }));
     }
     async resetPublishedInstance(instanceId) {
@@ -570,6 +580,7 @@ class AppService {
                     totalCost: agent.totalCost,
                     isPublished: agent.isPublished,
                     beginInstruction: agent.beginInstruction,
+                    toolNames: agent.toolNames,
                 });
             }
         }
@@ -823,8 +834,36 @@ class AppService {
             agent.allowSearch = updates.allowSearch;
         if (updates.beginInstruction !== undefined)
             agent.beginInstruction = updates.beginInstruction;
+        if (updates.toolNames !== undefined)
+            agent.toolNames = updates.toolNames;
         agent.save();
     }
+    async listTools() {
+        return this.toolStore.listTools();
+    }
+    async createTool(tool) {
+        const existing = await this.toolStore.getTool(tool.name);
+        if (existing) {
+            throw new errors_1.OperationFailedError(`Tool "${tool.name}" already exists`);
+        }
+        return this.toolStore.saveTool(tool);
+    }
+    async updateTool(name, tool) {
+        const existing = await this.toolStore.getTool(name);
+        if (!existing) {
+            throw new errors_1.NotFoundError(`Tool "${name}" not found`);
+        }
+        return this.toolStore.saveTool({ ...tool, name });
+    }
+    async deleteTool(name) {
+        const deleted = await this.toolStore.deleteTool(name);
+        if (!deleted) {
+            throw new errors_1.NotFoundError(`Tool "${name}" not found`);
+        }
+    }
+    async testTool(name, args) {
+        return this.toolExecution.test(name, args);
+    }
     async listAttachedFiles(agentId) {
         const agent = await this.agentStore.getAgent(agentId);
         if (!agent) {
@@ -972,8 +1011,8 @@ class AppService {
     async revertStoryChapter(storyId) {
         return this.storyService.revertStoryChapter(storyId);
     }
-    async createStory(name, idea, userCharacterDesc, otherCharactersDesc, illustrateStory, storyModel, isImport, imageModelName, imageEditModelName) {
-        return this.storyService.createStory(name, idea, userCharacterDesc, otherCharactersDesc, illustrateStory, storyModel, isImport, imageModelName, imageEditModelName);
+    async createStory(name, idea, userCharacterDesc, otherCharactersDesc, illustrateStory, storyModel, isImport, imageModelName, skipDetailedPlot) {
+        return this.storyService.createStory(name, idea, userCharacterDesc, otherCharactersDesc, illustrateStory, storyModel, isImport, imageModelName, skipDetailedPlot);
     }
     async importStoryFromZip(zipBuffer) {
         return this.storyService.importStoryFromZip(zipBuffer);
@@ -1148,6 +1187,13 @@ class AppService {
     saveCharacter(storyId, characterName, content) {
         this.storyService.saveCharacter(storyId, characterName, content);
     }
+    async getCharacterInventory(storyId, characterName) {
+        const content = await this.storyService.getCharacterInventory(storyId, characterName);
+        return { content: content || '' };
+    }
+    async saveCharacterInventory(storyId, characterName, content) {
+        await this.storyService.saveCharacterInventory(storyId, characterName, content);
+    }
     async getPlotPlan(storyId) {
         const content = await this.storyService.getPlotPlan(storyId);
         return { content: content || '' };

package/dist-sdk/server/src/room/message.js

@@ -44,7 +44,9 @@ class RoomMessage {
         }
         if (this.action === app_types_1.MessageAction.WHISPER ||
             this.action === app_types_1.MessageAction.RELAY ||
-            this.action === app_types_1.MessageAction.RELAY_SILENT) {
+            this.action === app_types_1.MessageAction.RELAY_SILENT ||
+            this.action === app_types_1.MessageAction.COMMISSION ||
+            this.action === app_types_1.MessageAction.DELIVER) {
             return this.targets.includes(agentName);
         }
         if (this.targets.length > 0) {
@@ -56,6 +58,8 @@ class RoomMessage {
         if (this.sender === agentNickname) {
             return false;
         }
+        if (this.action === app_types_1.MessageAction.TOOL)
+            return false;
         if (this.action === app_types_1.MessageAction.RELAY || this.action === app_types_1.MessageAction.RELAY_SILENT)
             return this.targets.includes(agentNickname);
         if (this.action === app_types_1.MessageAction.PUBLISH)

package/dist-sdk/server/src/room/room-factory.d.ts

@@ -1,7 +1,11 @@
 import { Room } from './room';
 import { RoomStoreService } from './room-store.service';
+import { ToolStoreService } from '../tools/tool-store.service';
+import { ToolExecutionService } from '../tools/tool-execution.service';
 export declare class RoomFactory {
     private readonly roomStoreService;
-    constructor(roomStoreService: RoomStoreService);
+    private readonly toolStoreService;
+    private readonly toolExecutionService;
+    constructor(roomStoreService: RoomStoreService, toolStoreService: ToolStoreService, toolExecutionService: ToolExecutionService);
     createRoom(name: string, goal: string, baseRoomDir?: string, storageDir?: string): Room;
 }

package/dist-sdk/server/src/room/room-factory.js

@@ -4,12 +4,17 @@ exports.RoomFactory = void 0;
 const room_1 = require("./room");
 class RoomFactory {
     roomStoreService;
-    constructor(roomStoreService) {
+    toolStoreService;
+    toolExecutionService;
+    constructor(roomStoreService, toolStoreService, toolExecutionService) {
         this.roomStoreService = roomStoreService;
+        this.toolStoreService = toolStoreService;
+        this.toolExecutionService = toolExecutionService;
     }
     createRoom(name, goal, baseRoomDir = '', storageDir = '') {
         const finalStorageDir = storageDir || this.roomStoreService.getDefaultStorageDir();
         const room = new room_1.Room(null, name, goal, baseRoomDir, finalStorageDir, this.roomStoreService);
+        room.setToolServices(this.toolStoreService, this.toolExecutionService);
         return room;
     }
 }

package/dist-sdk/server/src/room/room-store.service.d.ts

@@ -6,16 +6,20 @@ import { RoomInfo } from '../../../shared/types/app.types';
 import { RoomMessage } from './message';
 import { ArtifactStoreService } from './artifact-store.service';
 import { Artifact } from './artifact';
+import { ToolStoreService } from '../tools/tool-store.service';
+import { ToolExecutionService } from '../tools/tool-execution.service';
 export declare class RoomStoreService {
     private readonly userPaths;
     private readonly agentStore;
     private readonly attachedFileService;
     private readonly artifactStoreService;
+    private readonly toolStoreService;
+    private readonly toolExecutionService;
     private rooms;
     private readonly defaultStorageDir;
     private loaded;
     private loadPromise;
-    constructor(userPaths: UserPathsService, agentStore: AgentStoreService, attachedFileService: AttachedFileService, artifactStoreService: ArtifactStoreService);
+    constructor(userPaths: UserPathsService, agentStore: AgentStoreService, attachedFileService: AttachedFileService, artifactStoreService: ArtifactStoreService, toolStoreService: ToolStoreService, toolExecutionService: ToolExecutionService);
     getDefaultStorageDir(): string;
     storeRoom(room: Room, storageDir?: string): string;
     getRoom(id: string): Promise<Room | null>;

package/dist-sdk/server/src/room/room-store.service.js

@@ -52,21 +52,27 @@ const user_paths_service_1 = require("../config/user-paths.service");
 const agent_store_service_1 = require("../ai/agent-store.service");
 const attached_file_service_1 = require("../ai/attached-file.service");
 const artifact_store_service_1 = require("./artifact-store.service");
+const tool_store_service_1 = require("../tools/tool-store.service");
+const tool_execution_service_1 = require("../tools/tool-execution.service");
 const logger_1 = require("../common/logger");
 let RoomStoreService = class RoomStoreService {
     userPaths;
     agentStore;
     attachedFileService;
     artifactStoreService;
+    toolStoreService;
+    toolExecutionService;
     rooms = new Map();
     defaultStorageDir;
     loaded = false;
     loadPromise = null;
-    constructor(userPaths, agentStore, attachedFileService, artifactStoreService) {
+    constructor(userPaths, agentStore, attachedFileService, artifactStoreService, toolStoreService, toolExecutionService) {
         this.userPaths = userPaths;
         this.agentStore = agentStore;
         this.attachedFileService = attachedFileService;
         this.artifactStoreService = artifactStoreService;
+        this.toolStoreService = toolStoreService;
+        this.toolExecutionService = toolExecutionService;
         this.defaultStorageDir = path.join(this.userPaths.getUserDataDir(), 'rooms');
     }
     getDefaultStorageDir() {
@@ -76,6 +82,7 @@ let RoomStoreService = class RoomStoreService {
         const finalStorageDir = storageDir || this.defaultStorageDir;
         room.setStorageDir(finalStorageDir);
         room.setRoomStoreService(this);
+        room.setToolServices(this.toolStoreService, this.toolExecutionService);
         this.rooms.set(room.getId(), room);
         this.saveRoomToFile(room, finalStorageDir);
         return room.getId();
@@ -118,6 +125,7 @@ let RoomStoreService = class RoomStoreService {
             }
         }
         const instance = new room_1.Room(instanceId, publishedName, template.getGoal(), template.getBaseRoomDir(), this.defaultStorageDir, this);
+        instance.setToolServices(this.toolStoreService, this.toolExecutionService);
         for (const agentId of clonedAgentIds) {
             const agent = await this.agentStore.getAgent(agentId);
             if (agent) {
@@ -219,6 +227,7 @@ let RoomStoreService = class RoomStoreService {
                     const config = JSON.parse(fileContent);
                     let messages = await this.readRoomMessagesFromFileAsync(messagesPath);
                     const room = new room_1.Room(config.id, config.name, config.goal, '', storageDir, this);
+                    room.setToolServices(this.toolStoreService, this.toolExecutionService);
                     room.setLoading(true);
                     room.setCreatedAt(new Date(config.createdAt));
                     room.setRoomMessages(messages);
@@ -353,5 +362,7 @@ exports.RoomStoreService = RoomStoreService = __decorate([
     __metadata("design:paramtypes", [user_paths_service_1.UserPathsService,
         agent_store_service_1.AgentStoreService,
         attached_file_service_1.AttachedFileService,
-        artifact_store_service_1.ArtifactStoreService])
+        artifact_store_service_1.ArtifactStoreService,
+        tool_store_service_1.ToolStoreService,
+        tool_execution_service_1.ToolExecutionService])
 ], RoomStoreService);

package/dist-sdk/server/src/room/room.d.ts

@@ -1,7 +1,10 @@
 import { Agent } from '../ai/agent';
 import { RoomMessage } from './message';
 import { Artifact } from './artifact';
+import { ToolStoreService } from '../tools/tool-store.service';
+import { ToolExecutionService } from '../tools/tool-execution.service';
 export declare class Room {
+    private static readonly MAX_TOOL_ITERATIONS;
     private id;
     private name;
     private goal;
@@ -22,11 +25,14 @@ export declare class Room {
     private onStateChangeCallbacks;
     private onError?;
     private currentSituation;
+    private currentSituationTime;
     private onSituationUpdate?;
     private onModeratorResponseCallback?;
     private templateRoomId;
     private storageDir;
     private roomStoreService;
+    private toolStoreService?;
+    private toolExecutionService?;
     constructor(id: string | null, name: string, goal: string, baseRoomDir?: string, storageDir?: string, roomStoreService?: any);
     deleteRoom(): void;
     setLoading(isLoading: boolean): void;
@@ -59,7 +65,9 @@ export declare class Room {
     };
     getLatestRoomMessages(fromIndex?: number, includeThoughts?: boolean): RoomMessage[];
     setRoomMessages(messages: RoomMessage[]): void;
-    addRoomMessage(message: RoomMessage): void;
+    addRoomMessage(message: RoomMessage, options?: {
+        suppressSituationUpdate?: boolean;
+    }): void;
     addRoomMessages(messages: RoomMessage[]): void;
     getCreatedAt(): Date;
     setCreatedAt(date: Date): void;
@@ -69,6 +77,14 @@ export declare class Room {
     private parseAgentResponse;
     private static extractPreamble;
     private static coerceMessageAction;
+    private getPresentCharacters;
+    private buildCharacterPrivateContextDigest;
+    private buildAvailableTools;
+    private buildPerceiveVariables;
+    private buildTransientPrompt;
+    private promptAgentOnce;
+    private runAgentTurn;
+    private executeToolForAgent;
     private getAgentAiResponse;
     perceive(agent: Agent, message: RoomMessage, onResponse: (message: RoomMessage | null) => void): void;
     moderate(moderatorAgent: Agent, message: RoomMessage, onResponse: (message: RoomMessage | null) => void): Promise<void>;
@@ -83,6 +99,7 @@ export declare class Room {
     setStorageDir(dir: string): void;
     getRoomStoreService(): any;
     setRoomStoreService(service: any): void;
+    setToolServices(toolStore: ToolStoreService, toolExecution: ToolExecutionService): void;
     saveMessages(messages: RoomMessage[]): void;
     saveMetadata(): string;
     setOnStateChange(key: string, callback: () => void): void;
@@ -93,13 +110,14 @@ export declare class Room {
     getHumanAgentName(): string;
     getModeratorAgent(): Agent | undefined;
     getSituation(): string;
+    getSituationTime(): string;
+    setSituationTime(time: string): void;
+    private buildSituationHeader;
     setSituation(situation: string): void;
-    setOnSituationUpdate(callback: (situation: string) => void): void;
+    setOnSituationUpdate(callback: (situation: string, messageBody?: string) => void | Promise<void>): void;
     setOnModeratorResponse(callback: (message: RoomMessage) => void): void;
     private handleSituationUpdate;
     handlePublishMessages(messages: RoomMessage[]): void;
-    handleExecuteMessages(messages: RoomMessage[]): void;
-    private executeCommand;
     handleAdjournMessages(messages: RoomMessage[]): void;
     addPendingMessage(message: RoomMessage, clearQueue?: boolean): void;
     isProcessingInProgress(): boolean;
@@ -108,6 +126,9 @@ export declare class Room {
     interrupt(): void;
     checkAgentNicknameMatch(existingNickname: string, targetNickname: string): boolean;
     private handleModeratorResponse;
+    private runDeliverTurn;
+    private handleCommissionMessage;
+    private respondToCommissioner;
     private processPendingMessages;
     private filterConcurrentMessages;
 }