briyah 1.2.4 → 1.2.5

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;
 }