briyah 1.0.2 → 1.0.3

package/dist/room/room.js

@@ -1,833 +0,0 @@
-"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;