briyah 1.0.0

package/dist/room/room.js

@@ -0,0 +1,833 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Room = void 0;
+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");
+class Room {
+    id;
+    name;
+    goal;
+    baseRoomDir;
+    agents = [];
+    roomLeader;
+    roomMessages = [];
+    pendingMessages;
+    nextMessageIndex = 0;
+    createdAt;
+    artifacts = [];
+    isAdjourned = false;
+    processingInProgress = true;
+    isPaused = false;
+    currentSpeaker = null;
+    isPublished = false;
+    isLoading = false;
+    onStateChange;
+    onError;
+    currentSituation = '';
+    onSituationUpdate;
+    templateRoomId;
+    storageDir;
+    roomStoreService;
+    constructor(id, name, goal, baseRoomDir = '', storageDir = '', roomStoreService = null) {
+        this.name = name;
+        this.goal = goal;
+        this.baseRoomDir = baseRoomDir;
+        this.storageDir = storageDir;
+        this.roomStoreService = roomStoreService;
+        this.createdAt = new Date();
+        this.processingInProgress = true;
+        this.id = id ? id : (0, crypto_1.randomUUID)();
+        this.isLoading = false;
+    }
+    deleteRoom() {
+        this.roomStoreService.removeRoom(this.id, this.storageDir);
+    }
+    setLoading(isLoading) {
+        this.isLoading = isLoading;
+    }
+    getName() {
+        return this.name;
+    }
+    setName(name) {
+        this.name = name;
+    }
+    getGoal() {
+        return this.goal;
+    }
+    setGoal(goal) {
+        this.goal = goal;
+    }
+    getBaseRoomDir() {
+        return this.baseRoomDir;
+    }
+    setBaseRoomDir(dir) {
+        this.baseRoomDir = dir;
+    }
+    getIsPublished() {
+        return this.isPublished;
+    }
+    setPublished(published) {
+        this.isPublished = published;
+        this.saveMetadata();
+    }
+    getPaused() {
+        return this.isPaused;
+    }
+    getTemplateRoomId() {
+        return this.templateRoomId;
+    }
+    setTemplateRoomId(templateId) {
+        this.templateRoomId = templateId;
+    }
+    clearRoomMessages() {
+        this.roomMessages = [];
+        this.roomStoreService.clearRoomMessages(this.id, this.storageDir);
+    }
+    arrive(agent) {
+        if (this.agents.some((a) => a.agentNickname === agent.agentNickname)) {
+            return false;
+        }
+        this.agents.push(agent);
+        return true;
+    }
+    getAgents() {
+        return [...this.agents];
+    }
+    setAgents(newAgents) {
+        this.agents = [];
+        for (const agent of newAgents) {
+            this.arrive(agent);
+        }
+    }
+    describeAgentsInRoom() {
+        return this.agents.map((a) => `${a.agentNickname}: ${a.description}`).join('\n');
+    }
+    setRoomLeader(agentNickname) {
+        this.roomLeader = agentNickname;
+    }
+    getRoomLeader() {
+        if (this.roomLeader)
+            return this.roomLeader;
+        if (this.agents.length > 0 && this.agents[0]) {
+            return this.agents[0].agentNickname || '';
+        }
+        return '';
+    }
+    getAgentCount() {
+        return this.agents.length;
+    }
+    ready() {
+        if (this.isAdjourned || this.processingInProgress) {
+            this.isAdjourned = false;
+            this.processingInProgress = false;
+            this.setCurrentSpeaker(this.getHumanAgentName());
+            this.notifyStateChange();
+        }
+    }
+    getCurrentSpeaker() {
+        return this.currentSpeaker;
+    }
+    setCurrentSpeaker(agentNickname) {
+        this.currentSpeaker = agentNickname;
+        this.notifyStateChange();
+    }
+    isAgentsTurn(agentNickname) {
+        return this.currentSpeaker === agentNickname;
+    }
+    getRoomMessageStats() {
+        let numMessages = this.roomMessages.length;
+        let numChars = this.roomMessages.map((m) => m.content?.length).reduce((a, b) => a + b, 0);
+        return { numMessages, numChars };
+    }
+    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;
+    }
+    setRoomMessages(messages) {
+        this.roomMessages = messages.map((m, idx) => {
+            m.index = idx;
+            return m;
+        });
+        this.nextMessageIndex = this.roomMessages.length;
+    }
+    addRoomMessage(message) {
+        message.index = this.nextMessageIndex++;
+        this.roomMessages.push(message);
+        this.saveMessages([message]);
+        if (message.situation) {
+            this.handleSituationUpdate(message.situation);
+        }
+        this.notifyStateChange();
+    }
+    addRoomMessages(messages) {
+        if (!messages || messages.length === 0)
+            return;
+        let indexedMessages = messages.map((m) => {
+            m.index = this.nextMessageIndex++;
+            return m;
+        });
+        this.roomMessages = this.roomMessages.concat(indexedMessages);
+        this.saveMessages(indexedMessages);
+        this.notifyStateChange();
+    }
+    getCreatedAt() {
+        return this.createdAt;
+    }
+    setCreatedAt(date) {
+        this.createdAt = date;
+    }
+    getArtifacts() {
+        return [...this.artifacts];
+    }
+    isRoomAdjourned() {
+        return this.isAdjourned;
+    }
+    setArtifacts(artifacts) {
+        this.artifacts = [...artifacts];
+    }
+    parseAgentResponse(agent, response) {
+        let needsModeration = false;
+        let targets = [];
+        let content = response;
+        let situation;
+        if (typeof response !== 'object') {
+            needsModeration = true;
+            const lines = response.split('\n');
+            for (const line of lines) {
+                const trimmedLine = line.trim();
+                if (trimmedLine.startsWith('# Situation:')) {
+                    situation = trimmedLine.substring('# Situation:'.length).trim();
+                    content = lines
+                        .filter((l) => !l.startsWith('# Situation:'))
+                        .join('\n')
+                        .trimStart();
+                    break;
+                }
+            }
+            situation = situation || undefined;
+        }
+        else if (!response.content) {
+            needsModeration = true;
+        }
+        else if (!response.action) {
+            needsModeration = true;
+        }
+        else if (response.targets) {
+            targets = response.targets;
+            if (targets.length === 0) {
+                if (response.action === app_types_1.MessageAction.WHISPER) {
+                    needsModeration = true;
+                }
+                if (response.action === app_types_1.MessageAction.RELAY) {
+                    needsModeration = true;
+                }
+            }
+        }
+        if (needsModeration) {
+            return new message_1.RoomMessage(agent.agentNickname, app_types_1.MessageAction.MODERATE, content, [], null, situation);
+        }
+        situation = response.situation || undefined;
+        return new message_1.RoomMessage(agent.agentNickname, response.action, response.content, targets, response.name, situation);
+    }
+    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);
+        }
+        catch (e) {
+            if (e instanceof errors_1.InsufficientBalanceError) {
+                this.handleInsufficientBalance(e);
+            }
+            else {
+                let internalizedError = `${agent.agentNickname} thinks: No one heard me because ${e.message}`;
+                agent.addToConversationHistory(internalizedError, true);
+            }
+        }
+        onResponse(answer);
+    }
+    perceive(agent, message, onResponse) {
+        if (!message.canHear(agent.agentNickname)) {
+            onResponse(null);
+            return;
+        }
+        agent.addToConversationHistory(message, false);
+        agent.save();
+        if (!agent.canRespond(message)) {
+            onResponse(null);
+            return;
+        }
+        if (agent.isControlledByHuman) {
+            return;
+        }
+        this.getAgentAiResponse(agent, onResponse);
+    }
+    async moderate(moderatorAgent, message, onResponse) {
+        const humanAgent = this.getAgents().find((agent) => agent.isControlledByHuman);
+        const humanAgentName = humanAgent ? humanAgent.agentNickname : 'Player';
+        const variables = {
+            agentName: moderatorAgent.agentName,
+            agentNickname: moderatorAgent.agentNickname || moderatorAgent.agentName,
+            agentDescription: moderatorAgent.description,
+            otherAgents: this.agents.filter((a) => a.agentNickname !== moderatorAgent.agentNickname),
+            agents: this.getAgents(),
+            roomLeader: this.getRoomLeader(),
+            roomGoal: this.getGoal(),
+            scenario: this.getGoal(),
+            humanAgent: humanAgent,
+            humanAgentName: humanAgentName,
+        };
+        let prompt = `
+Current Situation: ${this.getSituation()}
+Sender: ${message.getSender()}
+Recent Message: ${message.getContent()}
+`;
+        try {
+            let response = await moderatorAgent.instructedPrompt(prompt, 'moderate', variables, false, true);
+            let answer = this.parseAgentResponse(moderatorAgent, response);
+            moderatorAgent.addToConversationHistory(message, false);
+            moderatorAgent.addToConversationHistory(answer, true);
+            moderatorAgent.save();
+            onResponse(answer);
+        }
+        catch (e) {
+            if (e instanceof errors_1.InsufficientBalanceError) {
+                this.handleInsufficientBalance(e, onResponse);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    handleInsufficientBalance(error, onResponse) {
+        this.notifyError(error);
+        const balanceMessage = new message_1.RoomMessage('System', app_types_1.MessageAction.SYSTEM, `Conversation paused: ${error.message}`, [], null, null);
+        this.addRoomMessage(balanceMessage);
+        this.processingInProgress = false;
+        this.notifyStateChange();
+        if (onResponse) {
+            onResponse(null);
+        }
+    }
+    findArtifact(name) {
+        return this.artifacts.find((a) => a.name === name);
+    }
+    publishArtifact(name, creator, body, viewers = []) {
+        if (!body || body.trim().length === 0) {
+            this.deleteArtifact(name);
+            return null;
+        }
+        const existingIndex = this.artifacts.findIndex((a) => a.name === name);
+        let returnedArtifact;
+        if (existingIndex >= 0) {
+            this.artifacts[existingIndex].body = body;
+            this.artifacts[existingIndex].creator = creator;
+            this.artifacts[existingIndex].viewers = viewers.length > 0 ? viewers : [creator];
+            returnedArtifact = this.artifacts[existingIndex];
+        }
+        else {
+            const newArtifact = {
+                name,
+                creator,
+                body,
+                viewers: viewers.length > 0 ? viewers : [creator],
+            };
+            this.artifacts.push(newArtifact);
+            returnedArtifact = newArtifact;
+        }
+        if (this.roomStoreService && this.storageDir) {
+            this.roomStoreService.saveArtifactFile(this.id, this.storageDir, returnedArtifact);
+        }
+        this.saveMetadata();
+        return returnedArtifact;
+    }
+    deleteArtifact(name) {
+        const index = this.artifacts.findIndex((a) => a.name === name);
+        if (index === -1) {
+            return false;
+        }
+        this.artifacts.splice(index, 1);
+        if (this.roomStoreService && this.storageDir) {
+            this.roomStoreService.deleteArtifactFile(this.id, this.storageDir, name);
+        }
+        return true;
+    }
+    getVisibleArtifacts(agentNickname) {
+        return this.artifacts.filter((a) => a.creator === agentNickname ||
+            (a.viewers && a.viewers.includes(agentNickname)) ||
+            !a.viewers);
+    }
+    getId() {
+        return this.id;
+    }
+    setId(id) {
+        this.id = id;
+    }
+    getStorageDir() {
+        return this.storageDir;
+    }
+    setStorageDir(dir) {
+        this.storageDir = dir;
+    }
+    getRoomStoreService() {
+        return this.roomStoreService;
+    }
+    setRoomStoreService(service) {
+        this.roomStoreService = service;
+    }
+    saveMessages(messages) {
+        if (!this.roomStoreService || !this.storageDir || !this.id) {
+            return;
+        }
+        for (const message of messages) {
+            this.roomStoreService.appendMessageToFile(this.id, message, this.storageDir);
+        }
+    }
+    saveMetadata() {
+        if (!this.roomStoreService || !this.storageDir) {
+            return;
+        }
+        if (this.isLoading) {
+            return;
+        }
+        let id = this.roomStoreService.storeRoom(this, this.storageDir);
+        this.notifyStateChange();
+        return id;
+    }
+    setOnStateChange(callback) {
+        this.onStateChange = callback;
+    }
+    notifyStateChange() {
+        if (this.onStateChange) {
+            this.onStateChange();
+        }
+    }
+    setOnError(callback) {
+        this.onError = callback;
+    }
+    notifyError(error) {
+        if (this.onError) {
+            this.onError(error);
+        }
+    }
+    getHumanAgentName() {
+        const humanAgent = this.agents.find((agent) => agent.isControlledByHuman);
+        return humanAgent ? humanAgent.agentNickname : '';
+    }
+    getModeratorAgent() {
+        if (this.agents.length > 0)
+            return this.agents[0];
+    }
+    getSituation() {
+        return this.currentSituation;
+    }
+    setSituation(situation) {
+        this.currentSituation = situation;
+    }
+    setOnSituationUpdate(callback) {
+        this.onSituationUpdate = callback;
+    }
+    handleSituationUpdate(situation) {
+        console.log(`Situation updated: ${situation}`);
+        this.currentSituation = situation;
+        if (this.onSituationUpdate) {
+            this.onSituationUpdate(situation);
+        }
+    }
+    handlePublishMessages(messages) {
+        for (const message of messages) {
+            if (message.name) {
+                const artifactName = message.name;
+                const creator = message.sender;
+                const body = message.content;
+                const viewers = message.targets;
+                this.publishArtifact(artifactName, creator, body, viewers);
+            }
+        }
+    }
+    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();
+        console.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}`;
+                console.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;
+        }
+        const adjournedAgents = messages.map((m) => m.sender);
+        const allAgentNames = this.agents.map((a) => a.agentNickname);
+        const allAdjourned = allAgentNames.every((name) => adjournedAgents.includes(name));
+        if (allAdjourned) {
+            this.isAdjourned = true;
+            this.notifyStateChange();
+            this.addRoomMessage(new message_1.RoomMessage('system', app_types_1.MessageAction.SYSTEM, 'All agents have agreed to adjourn. The conversation has ended.'));
+            this.pendingMessages = null;
+        }
+        if (adjournedAgents.includes('system')) {
+            this.isAdjourned = true;
+            this.notifyStateChange();
+            this.addRoomMessage(new message_1.RoomMessage('system', app_types_1.MessageAction.SYSTEM, 'The conversation has been ended by the system.'));
+            this.pendingMessages = null;
+        }
+        if (adjournedAgents.includes(this.getRoomLeader())) {
+            this.addRoomMessage(messages[0]);
+        }
+    }
+    addPendingMessage(message, clearQueue = false) {
+        if (!this.pendingMessages) {
+            this.pendingMessages = [];
+        }
+        if (!message.sender) {
+            message.sender = this.getHumanAgentName();
+        }
+        if (!message.sender) {
+            message.sender = 'system';
+        }
+        const humanAgent = this.agents.find((a) => a.isControlledByHuman);
+        const isHumanMessage = humanAgent && message.sender === humanAgent.agentNickname;
+        if (isHumanMessage && this.isPaused) {
+            if (clearQueue) {
+                this.pendingMessages = [];
+            }
+            humanAgent.addToConversationHistory(message, true);
+            humanAgent.save();
+            this.pendingMessages.push(message);
+            this.resume();
+            return;
+        }
+        if (isHumanMessage) {
+            if (this.currentSpeaker !== null && this.currentSpeaker !== humanAgent.agentNickname) {
+                console.warn(`Human agent ${humanAgent.agentNickname} tried to speak out of turn. Current speaker: ${this.currentSpeaker}`);
+                return;
+            }
+            humanAgent.addToConversationHistory(message, true);
+            humanAgent.save();
+            this.setCurrentSpeaker(null);
+        }
+        this.pendingMessages.push(message);
+        if (!this.processingInProgress) {
+            this.processPendingMessages();
+        }
+    }
+    isProcessingInProgress() {
+        return this.processingInProgress;
+    }
+    pause() {
+        this.isPaused = true;
+        const humanAgent = this.agents.find(a => a.isControlledByHuman);
+        if (humanAgent) {
+            this.currentSpeaker = humanAgent.agentNickname;
+        }
+        this.notifyStateChange();
+    }
+    resume() {
+        this.isPaused = false;
+        this.notifyStateChange();
+        if (this.pendingMessages && this.pendingMessages.length > 0) {
+            this.processPendingMessages();
+        }
+    }
+    checkAgentNicknameMatch(existingNickname, targetNickname) {
+        if (existingNickname.toLowerCase() === targetNickname.toLowerCase())
+            return true;
+        const nicknameFirstWord = existingNickname.split(/\s+/)[0];
+        if (nicknameFirstWord.toLowerCase() === targetNickname.toLowerCase())
+            return true;
+        return false;
+    }
+    handleModeratorResponse(moderatorMessage, originalMessage) {
+        try {
+            let responderNickname = moderatorMessage.name;
+            const roomLeaderName = this.getRoomLeader();
+            const targets = moderatorMessage.targets || [];
+            if (!targets.includes(roomLeaderName))
+                targets.push(roomLeaderName);
+            let content = moderatorMessage.content;
+            if (content && content.startsWith('relay'))
+                content = originalMessage.getContent();
+            if (originalMessage.content != content) {
+                console.warn(`Moderator changed content:\n${originalMessage.content}\nto\n${content}`);
+                originalMessage.content = content;
+            }
+            if (this.checkAgentNicknameMatch(originalMessage.sender, responderNickname)) {
+                let responder = this.getHumanAgentName();
+                if (!responder)
+                    responder = roomLeaderName;
+                this.setCurrentSpeaker(responder);
+                console.warn(`Moderator routed message to sender: ${originalMessage.sender}. Setting responder to room leader: ${responder}`);
+            }
+            console.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));
+            }
+            for (const recipientName of targets) {
+                if (recipientName === responderNickname)
+                    continue;
+                if (recipientName === originalMessage.sender)
+                    continue;
+                const recipient = this.agents.find((a) => this.checkAgentNicknameMatch(a.agentNickname, recipientName));
+                if (recipient) {
+                    recipient.addToConversationHistory(`From: ${originalMessage.sender}\n${content}`, false);
+                    recipient.save();
+                }
+            }
+            let responderAgent = this.agents.find((a) => this.checkAgentNicknameMatch(a.agentNickname, responderNickname));
+            if (!responderAgent) {
+                let roomLeaderAgent = this.agents.find((a) => a.agentNickname === this.getRoomLeader());
+                if (!roomLeaderAgent)
+                    throw new Error(`Room leader agent not found`);
+                console.warn(`Responder agent not found: ${responderNickname}`);
+                responderAgent = roomLeaderAgent;
+                if (responderNickname) {
+                    if (this.onSituationUpdate && responderNickname.length > 0) {
+                        this.onSituationUpdate(`INTRODUCE: ${responderNickname}`);
+                    }
+                }
+            }
+            if (responderAgent.isControlledByHuman) {
+                console.log(`Waiting for human agent ${responderNickname} to respond`);
+                responderAgent.addToConversationHistory(`From: ${originalMessage.sender}\n${content}`, false);
+                responderAgent.save();
+                this.processingInProgress = false;
+                this.notifyStateChange();
+                this.setCurrentSpeaker(responderNickname);
+                return;
+            }
+            this.setCurrentSpeaker(responderNickname);
+            this.perceive(responderAgent, originalMessage, (response) => {
+                if (response !== null) {
+                    this.pendingMessages = [response, ...this.pendingMessages];
+                }
+                this.setCurrentSpeaker(null);
+                this.processingInProgress = false;
+                this.notifyStateChange();
+                if (this.pendingMessages && this.pendingMessages.length > 0) {
+                    this.processPendingMessages();
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error parsing moderator response:', error);
+            console.error('Moderator message content:', moderatorMessage.content);
+            this.processingInProgress = false;
+            this.notifyStateChange();
+            if (this.pendingMessages && this.pendingMessages.length > 0) {
+                this.processPendingMessages();
+            }
+        }
+    }
+    processPendingMessages() {
+        if (this.isPaused ||
+            this.processingInProgress ||
+            !this.pendingMessages ||
+            this.pendingMessages.length === 0) {
+            return;
+        }
+        this.processingInProgress = true;
+        this.notifyStateChange();
+        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));
+        this.handleAdjournMessages(messages.filter((m) => m.getAction() === app_types_1.MessageAction.ADJOURN));
+        if (this.isAdjourned) {
+            console.log(`Room ${this.name} has been adjourned. Message processing stopped.`);
+            this.pendingMessages = null;
+            this.processingInProgress = false;
+            this.notifyStateChange();
+            return;
+        }
+        const moderateMessages = messages.filter((m) => m.getAction() === app_types_1.MessageAction.MODERATE);
+        let regularMessages = messages.filter((m) => m.getAction() !== app_types_1.MessageAction.MODERATE &&
+            m.getAction() !== app_types_1.MessageAction.PUBLISH &&
+            m.getAction() !== app_types_1.MessageAction.EXECUTE &&
+            m.getAction() !== app_types_1.MessageAction.ADJOURN);
+        if (moderateMessages.length > 0) {
+            const moderator = this.getModeratorAgent();
+            if (!moderator) {
+                console.warn('MODERATE messages found but no moderator agent in room');
+                this.processingInProgress = false;
+                this.notifyStateChange();
+                return;
+            }
+            const originalMessage = moderateMessages[0];
+            if (moderateMessages.length > 1) {
+                this.pendingMessages = [...moderateMessages.slice(1), ...this.pendingMessages];
+            }
+            this.moderate(moderator, originalMessage, (response) => {
+                if (response !== null) {
+                    this.handleModeratorResponse(response, originalMessage);
+                }
+                else {
+                    this.processingInProgress = false;
+                    this.notifyStateChange();
+                    if (this.pendingMessages && this.pendingMessages.length > 0) {
+                        this.processPendingMessages();
+                    }
+                }
+            });
+            return;
+        }
+        if (regularMessages.length === 0)
+            return;
+        let nextMessage;
+        if (regularMessages.length == 1)
+            nextMessage = regularMessages[0];
+        else if (regularMessages.length > 1) {
+            let filteredMessage = this.filterConcurrentMessages(regularMessages);
+            for (const m of regularMessages) {
+                if (m.sender !== filteredMessage.sender) {
+                    let skippedAgent = this.agents.find((a) => a.agentNickname === m.sender);
+                    if (skippedAgent)
+                        skippedAgent.addToConversationHistory(`From system: Your most recent response was not heard in the room because you were interrupted by ${filteredMessage.sender}`, false);
+                }
+            }
+            nextMessage = filteredMessage;
+        }
+        this.addRoomMessage(nextMessage);
+        this.setCurrentSpeaker(nextMessage.targets[0]);
+        let agentsRemaining = this.agents.length;
+        for (const agent of this.agents) {
+            this.perceive(agent, nextMessage, (message) => {
+                agentsRemaining--;
+                if (message !== null) {
+                    if (message.action === app_types_1.MessageAction.THINK) {
+                        this.addRoomMessage(message);
+                    }
+                    else if (message.action === app_types_1.MessageAction.SHOUT) {
+                        this.pendingMessages = [message, ...this.pendingMessages];
+                    }
+                    else {
+                        this.pendingMessages = [...this.pendingMessages, message];
+                    }
+                }
+                if (agentsRemaining === 0) {
+                    this.processingInProgress = false;
+                    this.notifyStateChange();
+                    if (this.pendingMessages && this.pendingMessages.length > 0) {
+                        this.processPendingMessages();
+                    }
+                }
+            });
+        }
+        this.processingInProgress = false;
+        this.notifyStateChange();
+    }
+    filterConcurrentMessages(messages) {
+        if (messages.length == 0)
+            return null;
+        if (messages.length == 1) {
+            return messages[0];
+        }
+        let filtered = messages;
+        const systemMessages = filtered.filter((m) => m.getSender() === 'system');
+        if (systemMessages.length > 0) {
+            return systemMessages[0];
+        }
+        const shoutMessages = filtered.filter((m) => m.getAction() === app_types_1.MessageAction.SHOUT);
+        if (shoutMessages.length > 0) {
+            filtered = shoutMessages;
+        }
+        if (filtered.length > 1) {
+            const speakMessages = filtered.filter((m) => m.getAction() === app_types_1.MessageAction.SPEAK);
+            const whisperMessages = filtered.filter((m) => m.getAction() === app_types_1.MessageAction.WHISPER);
+            if (speakMessages.length > 0) {
+                filtered = speakMessages;
+            }
+            else {
+                filtered = whisperMessages;
+            }
+        }
+        if (filtered.length > 1) {
+            const targetedMessages = filtered.filter((m) => m.getSender() === this.currentSpeaker);
+            if (targetedMessages.length === 1) {
+                filtered = targetedMessages;
+            }
+        }
+        if (filtered.length > 1) {
+            let earliestMessage = null;
+            let earliestIndex = Infinity;
+            for (const message of filtered) {
+                const agentIndex = this.agents.findIndex((a) => a.agentNickname === message.getSender());
+                if (agentIndex !== -1 && agentIndex < earliestIndex) {
+                    earliestIndex = agentIndex;
+                    earliestMessage = message;
+                }
+            }
+            if (earliestMessage) {
+                filtered = [earliestMessage];
+            }
+            else if (filtered.length > 0) {
+                filtered = [filtered[0]];
+            }
+        }
+        if (filtered.length > 0) {
+            return filtered[0];
+        }
+        return null;
+    }
+}
+exports.Room = Room;