briyah 1.2.4 → 1.2.5

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

@@ -5,9 +5,9 @@ const app_types_1 = require("../../../shared/types/app.types");
 const message_1 = require("./message");
 const crypto_1 = require("crypto");
 const errors_1 = require("../common/errors");
-const child_process_1 = require("child_process");
 const logger_1 = require("../common/logger");
 class Room {
+    static MAX_TOOL_ITERATIONS = 5;
     id;
     name;
     goal;
@@ -28,11 +28,14 @@ class Room {
     onStateChangeCallbacks = new Map();
     onError;
     currentSituation = '';
+    currentSituationTime = '';
     onSituationUpdate;
     onModeratorResponseCallback;
     templateRoomId;
     storageDir;
     roomStoreService;
+    toolStoreService;
+    toolExecutionService;
     constructor(id, name, goal, baseRoomDir = '', storageDir = '', roomStoreService = null) {
         this.name = name;
         this.goal = goal;
@@ -147,7 +150,7 @@ class Room {
     getLatestRoomMessages(fromIndex = 0, includeThoughts = false) {
         const messages = this.roomMessages.filter((msg) => msg.index >= fromIndex);
         if (!includeThoughts) {
-            return messages.filter((msg) => msg.action !== app_types_1.MessageAction.THINK);
+            return messages.filter((msg) => msg.action !== app_types_1.MessageAction.THINK && msg.action !== app_types_1.MessageAction.TOOL);
         }
         return messages;
     }
@@ -158,12 +161,12 @@ class Room {
         });
         this.nextMessageIndex = this.roomMessages.length;
     }
-    addRoomMessage(message) {
+    addRoomMessage(message, options) {
         message.index = this.nextMessageIndex++;
         this.roomMessages.push(message);
         this.saveMessages([message]);
-        if (message.situation) {
-            this.handleSituationUpdate(message.situation);
+        if (message.situation && !options?.suppressSituationUpdate) {
+            void this.handleSituationUpdate(message.situation);
         }
         this.notifyStateChange();
     }
@@ -233,6 +236,12 @@ class Room {
                     }
                 }
             }
+            if (normalizedAction === app_types_1.MessageAction.EXECUTE && (!response.name || !response.name.trim())) {
+                needsModeration = true;
+            }
+            if (normalizedAction === app_types_1.MessageAction.COMMISSION && targets.length === 0) {
+                needsModeration = true;
+            }
         }
         if (needsModeration) {
             return new message_1.RoomMessage(agent.agentNickname, app_types_1.MessageAction.MODERATE, content, [], null, situation);
@@ -284,45 +293,162 @@ class Room {
         const values = Object.values(app_types_1.MessageAction);
         return values.includes(lowered) ? lowered : undefined;
     }
-    async getAgentAiResponse(agent, onResponse) {
-        let answer = null;
-        try {
-            const visibleArtifacts = this.getVisibleArtifacts(agent.agentNickname)
-                .map((a) => `${a.name} (by ${a.creator}): ${a.body}`)
-                .join('\n\n');
-            const allArtifacts = this.getArtifacts();
-            const invisibleArtifactNames = allArtifacts
-                .filter((a) => !this.getVisibleArtifacts(agent.agentNickname).includes(a))
-                .map((a) => a.name)
-                .join(', ');
-            const humanAgent = this.getAgents().find((a) => a.isControlledByHuman);
-            const humanCharacterName = humanAgent ? humanAgent.agentNickname : 'Player';
-            const maxOutputChars = 4096;
-            const variables = {
-                agentName: agent.agentName,
-                agentNickname: agent.agentNickname,
-                agentDescription: agent.description,
-                otherAgents: this.agents.filter((a) => a.agentNickname !== agent.agentNickname),
-                roomLeader: this.getRoomLeader(),
-                roomGoal: this.getGoal(),
-                scenario: this.getGoal(),
-                situation: this.getSituation() || 'Story beginning',
-                visibleArtifacts: visibleArtifacts,
-                invisibleArtifactNames: invisibleArtifactNames,
-                humanCharacterName: humanCharacterName,
-                humanAgentName: humanCharacterName,
-                maxOutputChars: maxOutputChars
-            };
-            let prompt = null;
-            let situation = this.getSituation();
-            if (situation)
-                prompt = `Current Situation: ${situation}`;
-            let response = await agent.instructedPrompt(prompt, 'perceive', variables, false, true, maxOutputChars);
-            answer = this.parseAgentResponse(agent, response);
-            agent.addToConversationHistory(response, true);
+    getPresentCharacters(perceivingAgent, message) {
+        const audienceNames = message.getTargets();
+        const senderName = message.getSender();
+        return this.agents.filter((a) => {
+            if (a.promptFolder !== 'character')
+                return false;
+            if (a.agentNickname === perceivingAgent.agentNickname)
+                return false;
+            if (this.checkAgentNicknameMatch(a.agentNickname, senderName))
+                return true;
+            if (audienceNames.some((name) => this.checkAgentNicknameMatch(a.agentNickname, name)))
+                return true;
+            if (audienceNames.length === 0 && message.canHear(a.agentNickname))
+                return true;
+            return false;
+        });
+    }
+    buildCharacterPrivateContextDigest() {
+        return this.agents
+            .filter((a) => a.promptFolder === 'character' && a.privateContext && a.privateContext.trim())
+            .map((a) => `### ${a.agentNickname}\n${a.privateContext}`)
+            .join('\n\n');
+    }
+    async buildAvailableTools(agent) {
+        if (!this.toolStoreService || !agent.toolNames || agent.toolNames.length === 0) {
+            return [];
+        }
+        const tools = [];
+        for (const name of agent.toolNames) {
+            const tool = await this.toolStoreService.getTool(name);
+            if (tool) {
+                tools.push({
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.parameters || [],
+                });
+            }
+        }
+        return tools;
+    }
+    async buildPerceiveVariables(agent) {
+        const visibleArtifacts = this.getVisibleArtifacts(agent.agentNickname)
+            .map((a) => `${a.name} (by ${a.creator}): ${a.body}`)
+            .join('\n\n');
+        const allArtifacts = this.getArtifacts();
+        const invisibleArtifactNames = allArtifacts
+            .filter((a) => !this.getVisibleArtifacts(agent.agentNickname).includes(a))
+            .map((a) => a.name)
+            .join(', ');
+        const humanAgent = this.getAgents().find((a) => a.isControlledByHuman);
+        const humanCharacterName = humanAgent ? humanAgent.agentNickname : 'Player';
+        const maxOutputChars = 4096;
+        return {
+            agentName: agent.agentName,
+            agentNickname: agent.agentNickname,
+            agentDescription: agent.description,
+            otherAgents: this.agents.filter((a) => a.agentNickname !== agent.agentNickname),
+            roomLeader: this.getRoomLeader(),
+            roomGoal: this.getGoal(),
+            scenario: this.getGoal(),
+            situation: this.getSituation() || 'Story beginning',
+            visibleArtifacts: visibleArtifacts,
+            invisibleArtifactNames: invisibleArtifactNames,
+            humanCharacterName: humanCharacterName,
+            humanAgentName: humanCharacterName,
+            maxOutputChars: maxOutputChars,
+            availableTools: await this.buildAvailableTools(agent),
+        };
+    }
+    buildTransientPrompt(agent, message) {
+        let prompt = this.buildSituationHeader() || null;
+        if (message) {
+            const presentCharacters = this.getPresentCharacters(agent, message);
+            if (presentCharacters.length > 0) {
+                const descriptions = presentCharacters
+                    .map((c) => `- ${c.agentNickname}: ${c.description}`)
+                    .join('\n');
+                const charactersPresent = `Characters present (how they currently appear to you):\n${descriptions}`;
+                prompt = prompt ? `${prompt}\n\n${charactersPresent}` : charactersPresent;
+            }
+        }
+        if (agent.privateContext && agent.privateContext.trim()) {
+            const privateBlock = `Your private context (known only to you):\n${agent.privateContext}`;
+            prompt = prompt ? `${prompt}\n\n${privateBlock}` : privateBlock;
+        }
+        if (agent.agentNickname === this.getRoomLeader()) {
+            const digest = this.buildCharacterPrivateContextDigest();
+            if (digest) {
+                const digestBlock = `Character Inventories and Conditions:\n${digest}`;
+                prompt = prompt ? `${prompt}\n\n${digestBlock}` : digestBlock;
+            }
+        }
+        return prompt;
+    }
+    async promptAgentOnce(agent, transientPrompt, variables) {
+        const response = await agent.instructedPrompt(transientPrompt, 'perceive', variables, false, true, variables.maxOutputChars);
+        const answer = this.parseAgentResponse(agent, response);
+        agent.addToConversationHistory(response, true);
+        agent.save();
+        return answer;
+    }
+    async runAgentTurn(agent, heardMessage, opts = {}) {
+        const variables = await this.buildPerceiveVariables(agent);
+        let response = await this.promptAgentOnce(agent, this.buildTransientPrompt(agent, heardMessage), variables);
+        for (let i = 0; i < Room.MAX_TOOL_ITERATIONS; i++) {
+            if (this.isPaused || this.isAdjourned)
+                return null;
+            let feedback;
+            if (response.action === app_types_1.MessageAction.PUBLISH && response.name) {
+                this.publishArtifact(response.name, agent.agentNickname, response.content, response.targets);
+                const wasDeleted = !response.content || !response.content.trim();
+                feedback = `From system: Artifact "${response.name}" was ${wasDeleted ? 'deleted' : 'published'}.`;
+            }
+            else if (response.action === app_types_1.MessageAction.EXECUTE) {
+                feedback = await this.executeToolForAgent(agent, response);
+            }
+            else if (opts.inCommission && response.action === app_types_1.MessageAction.COMMISSION) {
+                feedback = `From system: Nested commissions are not permitted. Complete your own task and respond with action "deliver".`;
+            }
+            else {
+                if (!opts.inCommission && response.action === app_types_1.MessageAction.DELIVER) {
+                    response.action = app_types_1.MessageAction.SPEAK;
+                }
+                return response;
+            }
+            agent.addToConversationHistory(feedback, false);
             agent.save();
+            response = await this.promptAgentOnce(agent, this.buildTransientPrompt(agent, null), variables);
         }
-        catch (e) {
+        if (this.isPaused || this.isAdjourned)
+            return null;
+        agent.addToConversationHistory(`From system: You have reached the tool-call limit for this turn. Respond now with an audible action (speak, whisper, think, ...).`, false);
+        agent.save();
+        response = await this.promptAgentOnce(agent, this.buildTransientPrompt(agent, null), variables);
+        if (response.action === app_types_1.MessageAction.EXECUTE ||
+            response.action === app_types_1.MessageAction.PUBLISH) {
+            response = new message_1.RoomMessage(agent.agentNickname, app_types_1.MessageAction.THINK, response.content, []);
+        }
+        return response;
+    }
+    async executeToolForAgent(agent, message) {
+        const toolName = message.name;
+        const result = this.toolExecutionService
+            ? await this.toolExecutionService.runForAgent(toolName, message.content, agent.toolNames || [])
+            : { ok: false, error: 'Tool execution is not available in this room' };
+        const argsPreview = message.content && message.content.length > 200
+            ? `${message.content.slice(0, 200)}...`
+            : message.content || '';
+        const statusText = 'error' in result ? `error: ${result.error}` : 'ok';
+        this.addRoomMessage(new message_1.RoomMessage(agent.agentNickname, app_types_1.MessageAction.TOOL, `${toolName}(${argsPreview}) → ${statusText}`));
+        return `From system: Result of tool "${toolName}":\n${JSON.stringify(result)}`;
+    }
+    getAgentAiResponse(agent, message, onResponse) {
+        this.runAgentTurn(agent, message)
+            .then((answer) => onResponse(answer))
+            .catch((e) => {
             if (e instanceof errors_1.InsufficientBalanceError) {
                 this.handleInsufficientBalance(e);
             }
@@ -330,8 +456,8 @@ class Room {
                 let internalizedError = `${agent.agentNickname} thinks: No one heard me because ${e.message}`;
                 agent.addToConversationHistory(internalizedError, true);
             }
-        }
-        onResponse(answer);
+            onResponse(null);
+        });
     }
     perceive(agent, message, onResponse) {
         if (!message.canHear(agent.agentNickname)) {
@@ -347,7 +473,7 @@ class Room {
         if (agent.isControlledByHuman) {
             return;
         }
-        this.getAgentAiResponse(agent, onResponse);
+        this.getAgentAiResponse(agent, message, onResponse);
     }
     async moderate(moderatorAgent, message, onResponse) {
         const humanAgent = this.getAgents().find((agent) => agent.isControlledByHuman);
@@ -374,10 +500,14 @@ class Room {
             invisibleArtifactNames: invisibleArtifactNames,
         };
         let prompt = `
-Current Situation: ${this.getSituation()}
+${this.buildSituationHeader()}
 Sender: ${message.getSender()}
 Recent Message: ${message.getContent()}
 `;
+        const characterContexts = this.buildCharacterPrivateContextDigest();
+        if (characterContexts) {
+            prompt += `\nCharacter Inventories and Conditions:\n${characterContexts}\n`;
+        }
         try {
             let response = await moderatorAgent.instructedPrompt(prompt, 'moderate', variables, false, true);
             let answer = this.parseAgentResponse(moderatorAgent, response);
@@ -471,6 +601,10 @@ Recent Message: ${message.getContent()}
     setRoomStoreService(service) {
         this.roomStoreService = service;
     }
+    setToolServices(toolStore, toolExecution) {
+        this.toolStoreService = toolStore;
+        this.toolExecutionService = toolExecution;
+    }
     saveMessages(messages) {
         if (!this.roomStoreService || !this.storageDir || !this.id) {
             return;
@@ -520,6 +654,22 @@ Recent Message: ${message.getContent()}
     getSituation() {
         return this.currentSituation;
     }
+    getSituationTime() {
+        return this.currentSituationTime;
+    }
+    setSituationTime(time) {
+        this.currentSituationTime = time || '';
+    }
+    buildSituationHeader() {
+        const lines = [];
+        if (this.currentSituationTime) {
+            lines.push(`Current time: ${this.currentSituationTime} (24-hour clock)`);
+        }
+        if (this.currentSituation) {
+            lines.push(`Current Situation: ${this.currentSituation}`);
+        }
+        return lines.join('\n');
+    }
     setSituation(situation) {
         this.currentSituation = situation;
     }
@@ -529,11 +679,11 @@ Recent Message: ${message.getContent()}
     setOnModeratorResponse(callback) {
         this.onModeratorResponseCallback = callback;
     }
-    handleSituationUpdate(situation) {
+    async handleSituationUpdate(situation, messageBody) {
         logger_1.logger.log(`Situation updated: ${situation}`);
         this.currentSituation = situation;
         if (this.onSituationUpdate) {
-            this.onSituationUpdate(situation);
+            await this.onSituationUpdate(situation, messageBody);
         }
     }
     handlePublishMessages(messages) {
@@ -547,37 +697,6 @@ Recent Message: ${message.getContent()}
             }
         }
     }
-    handleExecuteMessages(messages) {
-        for (const message of messages) {
-            if (message.content && message.content.trim()) {
-                const command = message.content.trim();
-                const creator = message.sender;
-                const description = message.name || 'Command execution';
-                const resultViewers = message.targets;
-                this.executeCommand(command, creator, description, resultViewers);
-            }
-        }
-    }
-    executeCommand(command, creator, description, resultViewers = []) {
-        const workingDir = this.baseRoomDir || process.cwd();
-        logger_1.logger.log(`FEATURE DISABLED -- Executing command: ${command} in directory: ${workingDir} by agent: ${creator}`);
-        return;
-        (0, child_process_1.exec)(command, { cwd: workingDir }, (error, stdout, stderr) => {
-            let result = '';
-            if (error) {
-                result = `Error: ${error.message}\n${stderr}`;
-                logger_1.logger.error(`Command execution error: ${error.message}`);
-            }
-            else if (stderr) {
-                result = `${stdout}\n\nStderr: ${stderr}`;
-            }
-            else {
-                result = stdout;
-            }
-            const artifactBody = `Command: ${command}\nWorking Directory: ${workingDir}\n\n${result}`;
-            this.publishArtifact(description, creator, artifactBody, resultViewers);
-        });
-    }
     handleAdjournMessages(messages) {
         if (messages.length === 0) {
             return;
@@ -693,7 +812,7 @@ Recent Message: ${message.getContent()}
             }
             logger_1.logger.log(`Moderator routing: sender=${originalMessage.sender} action=${moderatorMessage.action}, name=${responderNickname}, targets=${targets.join(', ')}`);
             if (moderatorMessage.action === app_types_1.MessageAction.RELAY) {
-                this.addRoomMessage(new message_1.RoomMessage(originalMessage.sender, originalMessage.action, content, originalMessage.targets, originalMessage.name, originalMessage.situation));
+                this.addRoomMessage(new message_1.RoomMessage(originalMessage.sender, originalMessage.action, content, originalMessage.targets, originalMessage.name, originalMessage.situation), { suppressSituationUpdate: true });
             }
             for (const recipientName of targets) {
                 if (recipientName === responderNickname)
@@ -724,6 +843,7 @@ Recent Message: ${message.getContent()}
                 return;
             }
             this.setCurrentSpeaker(responderNickname);
+            originalMessage.targets = targets;
             this.perceive(responderAgent, originalMessage, (response) => {
                 if (this.isPaused) {
                     this.processingInProgress = false;
@@ -751,6 +871,149 @@ Recent Message: ${message.getContent()}
             }
         }
     }
+    async runDeliverTurn(agent, commission) {
+        try {
+            let response = await this.runAgentTurn(agent, commission, { inCommission: true });
+            if (response === null)
+                return null;
+            if (response.action !== app_types_1.MessageAction.DELIVER) {
+                agent.addToConversationHistory(`From system: You were commissioned by ${commission.sender}. Respond now with action "deliver" targeting ${commission.sender}, containing your complete result.`, false);
+                agent.save();
+                const variables = await this.buildPerceiveVariables(agent);
+                response = await this.promptAgentOnce(agent, this.buildTransientPrompt(agent, null), variables);
+            }
+            if (response.action !== app_types_1.MessageAction.DELIVER) {
+                return new message_1.RoomMessage(agent.agentNickname, app_types_1.MessageAction.DELIVER, response.content, [commission.sender]);
+            }
+            response.sender = agent.agentNickname;
+            response.targets = [commission.sender];
+            return response;
+        }
+        catch (e) {
+            if (e instanceof errors_1.InsufficientBalanceError) {
+                this.handleInsufficientBalance(e);
+                return null;
+            }
+            logger_1.logger.error(`Commissioned agent ${agent.agentNickname} failed:`, e);
+            return new message_1.RoomMessage(agent.agentNickname, app_types_1.MessageAction.DELIVER, `(No deliverable: ${agent.agentNickname} encountered an error: ${e.message})`, [commission.sender]);
+        }
+    }
+    async handleCommissionMessage(msg) {
+        try {
+            const aiTargets = [];
+            const humanTargetNames = [];
+            const unknownNames = [];
+            for (const name of [...new Set(msg.getTargets())]) {
+                const agent = this.agents.find((a) => this.checkAgentNicknameMatch(a.agentNickname, name));
+                if (!agent) {
+                    unknownNames.push(name);
+                }
+                else if (agent.agentNickname === msg.sender) {
+                }
+                else if (agent.isControlledByHuman) {
+                    humanTargetNames.push(agent.agentNickname);
+                }
+                else if (!aiTargets.includes(agent)) {
+                    aiTargets.push(agent);
+                }
+            }
+            for (const agent of this.agents) {
+                if (agent.agentNickname === msg.sender)
+                    continue;
+                agent.addToConversationHistory(msg, false);
+                agent.save();
+            }
+            const commissioner = this.agents.find((a) => this.checkAgentNicknameMatch(a.agentNickname, msg.sender));
+            if (aiTargets.length === 0) {
+                const reasons = [];
+                if (unknownNames.length > 0)
+                    reasons.push(`unknown agents: ${unknownNames.join(', ')}`);
+                if (humanTargetNames.length > 0)
+                    reasons.push(`human-controlled agents cannot be commissioned: ${humanTargetNames.join(', ')}`);
+                const note = `From system: Your commission could not be delivered (${reasons.join('; ') || 'no valid targets'}).`;
+                await this.respondToCommissioner(commissioner, note);
+                return;
+            }
+            const settled = await Promise.allSettled(aiTargets.map((t) => this.runDeliverTurn(t, msg)));
+            if (this.isPaused || this.isAdjourned || !this.processingInProgress) {
+                if (this.processingInProgress) {
+                    this.processingInProgress = false;
+                    this.notifyStateChange();
+                }
+                return;
+            }
+            const delivers = settled.map((result, i) => {
+                if (result.status === 'fulfilled' && result.value)
+                    return result.value;
+                return new message_1.RoomMessage(aiTargets[i].agentNickname, app_types_1.MessageAction.DELIVER, `(No deliverable: ${aiTargets[i].agentNickname} did not complete the commission)`, [msg.sender]);
+            });
+            for (const deliver of delivers) {
+                this.addRoomMessage(deliver);
+                for (const agent of this.agents) {
+                    if (agent.agentNickname === deliver.sender)
+                        continue;
+                    if (this.checkAgentNicknameMatch(agent.agentNickname, msg.sender))
+                        continue;
+                    agent.addToConversationHistory(deliver, false);
+                    agent.save();
+                }
+            }
+            const sections = delivers.map((d) => `## From ${d.sender}\n${d.content}`);
+            if (humanTargetNames.length > 0) {
+                sections.push(`(Skipped: ${humanTargetNames.join(', ')} — human-controlled agents cannot be commissioned)`);
+            }
+            if (unknownNames.length > 0) {
+                sections.push(`(Unknown agents: ${unknownNames.join(', ')})`);
+            }
+            const aggregate = `From system: Deliverables for your commission:\n\n${sections.join('\n\n')}`;
+            await this.respondToCommissioner(commissioner, aggregate);
+        }
+        catch (error) {
+            logger_1.logger.error('Error handling commission message:', error);
+            this.processingInProgress = false;
+            this.notifyStateChange();
+            if (this.pendingMessages && this.pendingMessages.length > 0) {
+                this.processPendingMessages();
+            }
+        }
+    }
+    async respondToCommissioner(commissioner, note) {
+        if (!commissioner) {
+            logger_1.logger.warn('Commissioner not found in room; dropping commission results');
+        }
+        else {
+            commissioner.addToConversationHistory(note, false);
+            commissioner.save();
+            if (commissioner.isControlledByHuman) {
+                this.addRoomMessage(new message_1.RoomMessage('system', app_types_1.MessageAction.SYSTEM, note, [
+                    commissioner.agentNickname,
+                ]));
+                this.processingInProgress = false;
+                this.notifyStateChange();
+                this.setCurrentSpeaker(commissioner.agentNickname);
+                return;
+            }
+            let reply = null;
+            try {
+                reply = await this.runAgentTurn(commissioner, null);
+            }
+            catch (e) {
+                if (e instanceof errors_1.InsufficientBalanceError) {
+                    this.handleInsufficientBalance(e);
+                    return;
+                }
+                throw e;
+            }
+            if (reply !== null && !this.isPaused && !this.isAdjourned) {
+                this.pendingMessages = [...(this.pendingMessages || []), reply];
+            }
+        }
+        this.processingInProgress = false;
+        this.notifyStateChange();
+        if (this.pendingMessages && this.pendingMessages.length > 0) {
+            this.processPendingMessages();
+        }
+    }
     processPendingMessages() {
         if (this.isPaused ||
             this.processingInProgress ||
@@ -763,7 +1026,10 @@ Recent Message: ${message.getContent()}
         const messages = [...this.pendingMessages];
         this.pendingMessages = [];
         this.handlePublishMessages(messages.filter((m) => m.getAction() === app_types_1.MessageAction.PUBLISH));
-        this.handleExecuteMessages(messages.filter((m) => m.getAction() === app_types_1.MessageAction.EXECUTE));
+        const strayExecuteMessages = messages.filter((m) => m.getAction() === app_types_1.MessageAction.EXECUTE);
+        if (strayExecuteMessages.length > 0) {
+            logger_1.logger.warn(`Dropping ${strayExecuteMessages.length} queued EXECUTE message(s); tool calls are handled within the sender's turn`);
+        }
         this.handleAdjournMessages(messages.filter((m) => m.getAction() === app_types_1.MessageAction.ADJOURN));
         if (this.isAdjourned) {
             logger_1.logger.log(`Room ${this.name} has been adjourned. Message processing stopped.`);
@@ -789,21 +1055,34 @@ Recent Message: ${message.getContent()}
             if (moderateMessages.length > 1) {
                 this.pendingMessages = [...moderateMessages.slice(1), ...this.pendingMessages];
             }
-            this.moderate(moderator, originalMessage, (response) => {
-                if (this.isPaused) {
-                    this.processingInProgress = false;
-                    this.notifyStateChange();
-                    return;
-                }
-                if (response !== null) {
-                    this.handleModeratorResponse(response, originalMessage);
+            const dispatchToModerator = async () => {
+                if (originalMessage.situation) {
+                    await this.handleSituationUpdate(originalMessage.situation, originalMessage.getContent());
                 }
-                else {
-                    this.processingInProgress = false;
-                    this.notifyStateChange();
-                    if (this.pendingMessages && this.pendingMessages.length > 0) {
-                        this.processPendingMessages();
+                await this.moderate(moderator, originalMessage, (response) => {
+                    if (this.isPaused) {
+                        this.processingInProgress = false;
+                        this.notifyStateChange();
+                        return;
                     }
+                    if (response !== null) {
+                        this.handleModeratorResponse(response, originalMessage);
+                    }
+                    else {
+                        this.processingInProgress = false;
+                        this.notifyStateChange();
+                        if (this.pendingMessages && this.pendingMessages.length > 0) {
+                            this.processPendingMessages();
+                        }
+                    }
+                });
+            };
+            dispatchToModerator().catch((error) => {
+                logger_1.logger.error('Error dispatching message to moderator:', error);
+                this.processingInProgress = false;
+                this.notifyStateChange();
+                if (this.pendingMessages && this.pendingMessages.length > 0) {
+                    this.processPendingMessages();
                 }
             });
             return;
@@ -825,6 +1104,10 @@ Recent Message: ${message.getContent()}
             nextMessage = filteredMessage;
         }
         this.addRoomMessage(nextMessage);
+        if (nextMessage.getAction() === app_types_1.MessageAction.COMMISSION) {
+            void this.handleCommissionMessage(nextMessage);
+            return;
+        }
         this.setCurrentSpeaker(nextMessage.targets[0]);
         let agentsInProgress = this.agents.length;
         if (agentsInProgress === 0) {
@@ -872,7 +1155,8 @@ Recent Message: ${message.getContent()}
             filtered = shoutMessages;
         }
         if (filtered.length > 1) {
-            const speakMessages = filtered.filter((m) => m.getAction() === app_types_1.MessageAction.SPEAK);
+            const speakMessages = filtered.filter((m) => m.getAction() === app_types_1.MessageAction.SPEAK ||
+                m.getAction() === app_types_1.MessageAction.COMMISSION);
             const whisperMessages = filtered.filter((m) => m.getAction() === app_types_1.MessageAction.WHISPER);
             if (speakMessages.length > 0) {
                 filtered = speakMessages;

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

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